*)

an experimental object-oriented rapid application development (RAD) language
with parameterized ("virtual") types, refactoring, and extensive static checks.

The Lava programming environment LavaPE replaces text editors
completely by structure editors

Lava is an OpenSource project. The Lava sources are managed at


(See the project summary page)

The demand for new software grows continuously. Existing software has to be changed and adapted to new requirements in ever shorter intervals. On the other hand, the possibilities to recruit foreign programmers or to increase the number of qualified domestic programmers are limited. Rather, we shall be able to cope with this challenge only 

     if the productivity (or simply: the speed) of the programming process

     and if program quality, comprehensibility, and, as a consequence, program maintainability

can be decisively improved.

This means that we cannot stay with the presently popular programming languages like Java  and Visual Basic. We have to aim for greatly improved programming languages and RAD programming environments that fulfill the following requirements:

        They relieve programmers from clerical and error-prone work, and in particular:

        they replace text-editing with structure-editing throughout the program development process.

        They prevent or detect errors already at programming time wherever possible, for instance the omnipresent dangers

• of missing variable initialization caused by the absence of a stringent object initialization discipline,

• of "dangling" pointers caused by erroneous manual storage allocation and de-allocation,

• and of mismatching data types caused by erroneous "type casts".

        They are easy to learn and get along with a minimum number of orthogonal concepts.

        They support Lego-like composition and restructuring/refactoring of programs.

        They allow us to compose programs from small functions and classes that can be understood by themselves

        and decisively facilitate program comprehension in this way.

        They support smooth incremental transition from OO analysis to OO design and implementation.

        They unify what should not be separated ("embedded SQL")

        and separate what should not be intermingled ("interfaces and implementations").

        They facilitate reuse of certified components and proven design patterns   *)  **) ***)

        from clearly documented component libraries, pattern libraries and pattern languages *).

The productivity of the software development process will be increased considerably in this way, and the costs of software maintenance and continuous adaptation to changing requirements will be reduced decisively.

The experimental programming language Lava and the associated LavaPE programming environment are based on a systematic analysis of all those problems that currently impair the simplicity of languages and tools and that in this way obstruct the productivity of programmers, and they offer solutions to quite a number of these problems.

The overall approach of the Lava/LavaPE project is to combine an uncompromising point-and-click programming style with a more consistent, largely simplified and unified object-, component-, and pattern-oriented conceptual framework.

A particularly attractive feature of LavaPE is that it is perfectly point-and-click: 

• no text entry is required, neither for declarations nor for executable code (except for comments, constants, and new identifiers); 
• no syntax learning, no syntactic errors, many other formal errors are prevented, likewise, or are reported immediately at the moment when they arise during program editing. 
• Renaming / rearrangement operations on Lava declarations entail automatic updates of all existing references: Refactoring support *) is already provided by the basic Lava structure editors.

These and many other features make Lava particularly suited also for teaching object-oriented programming (and, to some extent, also OO analysis and design).

However, Lava isn't just the easy way of programming. According to the motto "less syntax, more semantics" Lava attempts to shift the programmer's attention and efforts away from the meticulous observance of complex syntactic rules towards a higher degree of "structured programming" and program comprehensibility. As a natural consequence, this requires also a higher degree of discipline, more conscious consideration, and it also required more fine-grained semantic distinctions in the Lava language. The latter, in turn, enable more detailed consistency checks and facilitate the comprehension of the roles that the various Lava entities play in the respective application context. More thorough consideration is required, for instance, with respect to

• distinction of state and value objects, 
• distinction of object creation/initialization/customization and usage, 
• distinction of input and output parameters, 
• distinction of constituents and acquaintances of objects,
• distinction of mandatory and optional member variables and function arguments,
• distinction of recursion and quantification as Lava successors to the usual loop constructs,
• meaningful nesting of declarations *),
• single-assignment etc.,
• adequate separation of programs into separately comprehensible and reusable modules and components.

For descendants of Ch. Morgenstern's "Mr. Korf", who like it short, here is a condensed list of the most outstanding features of Lava. You may also download our Lava project summary (1 page)

LavaProjectSummary.pdf   (~90KB, in English)
LavaProjektBlatt.pdf   (~125KB, in deutsch)

from our download page where you can find also some more comprehensive papers on Lava.

Before you download the Lava/LavaPE software (which includes the documentation) you may want to look into the web-based version of the documentation (JavaScript must be enabled):

Lava Online Documentation

and hopefully you won't view Lava as a blue balloon thereafter . . .

(But we would also be content if Lava would have the same effect on you as Korf's novel kind of joke.)

It is quite clear that Lava, which is currently being developed by two persons only, cannot compete with commercial products like Java and Visual Basic as to the comprehensive functionality, support, maintenance, documentation, training, etc..

LavaPE is now in a state where you can use it to produce little Lava programs and play around with them in order to assess the new Lava concepts and the new Lava look-and-feel of object- and component-oriented program development in pure point-and-click style.If you would like to discuss the Lava design with us or if you would even like to contribute one or the other component to the Lava development, then don't hesitate to contact us.

If, after all, you would rather consult an analyst since you are seriously disturbed at Lava, Java, objects, interfaces and all that stuff then proceed to Dr. Eliza Freud's consulting room now. She has plenty of time to listen to all your questions, complaints, and concerns.

Imprint / Contact