Principal orientation of
Lava
There are two rather different principal orientations or philosophies to
which a programming language may adhere, and it is primarily a matter of
taste and personal experiences which of these you prefer. They can be
characterized by two basic, conflicting notions or ideas which they would
particularly emphasize:
Clarity-centric languages would emphasize ...
- a minimum number of different, orthogonal language constructs.
- the comprehensibility of programs (also
for other programmers), which is a necessary precondition for
- ease and low cost of maintenance and
change, adaptability to new, changed requirements.
- a clear program structure in the small and in
the large, rather than "spaghetti programs" (i.e. a control flow
jungle) or "tortellini programs" (i.e. an unstructured hodgepodge of
numerous small pieces, e.g. methods of classes, lacking a proper structure
in the large).
- the static nature of the language and partly redundant
declarations that reveal the programmers intentions how and to
which end the various program entities shall be used; these enable not
only
- comprehensive static checks, particularly
initialization checks, prevention of programming errors at the earliest
possible moment, but make it also easier to
- understand the role that the respective
program entities play in their respective context.
- a more standardized structure and representation
of programs, independent of the personal taste and habits of different
authors.
Flexibility-centric languages would emphasize ...
- the utmost freedom of the programmer in which order to proceed, or
where to do what, or which things to put together or to separate,
- "expressiveness": a rich repertoire of specialized, very concise,
perhaps adaptable expressive means for special situations,
- allowing also access to lower-level features;
- the dynamic nature of the language, for instance dynamic creation of
new classes, fields, or methods at run time,
- extensibility of the language, macro and template support,
- run time checks; static checks only where possible in spite of the
flexibility and dynamic nature of the language.
Clarity and flexibility certainly aren't completely incompatible, but ...
experience shows that most programming languages can be easily classified
as putting more emphasis on "freedom" or more emphasis on "discipline".
Admittedly and understandably, most programmers would prefer freedom. But
today a program is no longer a dialog between a single programmer and a
computer. To an increasing degree programs are joint intellectual
property of a group of programmers whose membership may fequently
change.
Therefore it is of increasing importance that a program can be easily
understood not only by its author but also by other programmers having
different preferences and habits. Consequently ...
Lava is oriented towards the
clarity goal ...
since we believe that comprehensibility, ease of maintenance and
modification by different programmers, a clear and natural,
more standardized
structure and representation of programs in the small and in the large and comprehensive support by
structure-oriented programming tools, static checks and early error
reporting are those things that we need most urgently today.
They should have priority over tricky, sophisticated, hard to understand,
specialized or highly dynamic features, personal programming styles, and
superficial simplicity/shortness of expressions whose actual
effect is highly dependent on the respective static or even run time context
and can be understood only after an arduous analysis.
See also
Complete
static initialization checks
Object-Oriented Problem Separation
Using Lava
for object-oriented analysis and design