Saturday, August 13, 2005

Simplicity, complexity, expressiveness and minimalism

Finding inherent simplicity does not require inventing the simplicity. The discovery of abstractions pertaining to software development is similar in nature to mathematical discoveries. However, designing an abstract language for software development is an artistic activity that decorates scientific discoveries with its simplicity of expressiveness.

The term abstract signifies simple and general. An abstract language allows expressing solutions that transparently use lower-level abstractions. As an analogy, a mathematical structure such as Hilbert Space does not start out with the axioms of set theory. In the same vain, when expressing an abstract solution for a concurrent problem we need not be aware of the notion of semaphore.

Thus, the simplicity and generality of an abstract language depend on its ability to express abstractions at its own level without involving those of a lower level. Perhaps the best example of this principle is SQL for database applications. On the other hand, the multiplicity of formulations for an abstract software development language indicates the degree of complexity we are dealing with. For a specific domain of applications, as is the case for SQL, the scope of types of problems is limited to a few related abstractions. That, however, is not the case for a software development language.

The simplicity of an abstract language is a matter of artistic design rather than the discovery of a naturally occurring one. On the other hand, the design of an infrastructure and compiler for such a language is a scientific activity, which also requires the skills to accomplish the implementation. Without a proper understanding of the implementation side, the design of the language will start out like a sci-fi attraction and quickly reduce to useless as little fixes are thrown into the language.

Turning our attention to minimalism, it is remarkable that the notion of list can be used to define all other types. The problem is that, the syntax of a language derived from list alone will retain its fundamental characteristics. It is like thinking in terms of set unions and intersections when evaluating an integral that requires a trigonometric substitution.

There is no argument that all paradigms are equivalent with some advantages and disadvantages. It is also productive to investigate and improve each paradigm in its own right. However, the expressiveness demanded from an abstract language for software development requires simultaneous use of all paradigms. As a parallel, we can do arithmetic geometrically, and geometry can be studied algebraically. Nevertheless, in practice we use them simultaneously.

Kleene, using his simulation technique established the most important equivalences in computing power. Finding more of them is still significant. However, expressiveness is a notion apart from computability. Until we turn our attention to expressiveness, the software industry will remain plagued with minimal languages that must be glued together with python-sized scripting languages.

Presently, research has isolated all the elements needed to design an abstract language for developing distributed applications. The notions of component, thread, exception, signaling, GUI elements are all well understood. The problem is that, none of the incumbent languages were properly designed with all of these ideas in mind. Extending a language that is not close enough to its target will not be any better than what C++ has done to C. However, C++ is a great language when we confine its use to system programs as opposed to application programs.

The fact that Z++ includes C++ may sound like Z++ extends C++ in a manner similar to how C++ extends C. The proper statement is that, Z++ contains the corrected form of all of C++ as a small subset. I may not remember the number of times that I discarded several months of intense implementation because I realized the simplicity of expressiveness was not on the target. For instance, a particular design issue could not be properly adjusted without exposing lower-level details, such as mutex.

The simplicity of Z++ and its expressiveness for stating abstract solutions to platform-independent distributed applications is the result of decades of research. You are only reading about it because the research had a happy ending of success.

Z++ is freely available from ZH Micro.

Labels: , , , ,