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