Saturday, December 10, 2005

Z++ reduces C++ complexity

It is generally believed that C++ is the most complex language. This is a correct perception when we consider the fact that some other languages, like ADA are not as widely used. However, there are other factors that make C++ appear too complex.

C++ is inherently a system programming language. Vendors frequently provide their own SDK and platform specific libraries with their products as a means of organizing the needed system calls in a simpler set of API. The center of complexity is the combination of C libraries, system calls, SDKs and third-party libraries.

An engineer is almost always required to be familiar with a variety of packages for each item in the center of complexity. For instance, MFC, ATL, STL, COM, DCOM, CORBA, IDL to mention a few. After all of this, and a variety of SDK, come XML, ODBC, Oracle etc.

Software development is a legitimate branch of engineering with its own peculiarities and subdivisions. The chaos and the absurd complexity we are experiencing is not inherent to software engineering. Rather, it is a natural consequence of random solutions and standards, mainly for eliminating the competition.

Ordinarily, a technology company focuses on operating systems, device drivers and system tools. On the other hand, software companies manufacture applications based on those technologies. The chaos emanates from the activities of technology companies trying to leave competition behind by flooding the market with useless system products. Applications cannot create chaos because they are end products.

Sometime in the past, it appeared that we were making progress towards automating the process of software development. Some thinkers provided examples and evidences against this misconception. Many remember, “There is no silver bullet”, which is simply a variation of Halting Problem. It means that the process of software development itself cannot be automated. Actually, the lack of a silver bullet is a trivial empirical fact in all areas of engineering. Bridges and houses do not just get erected.

Misconceptions resulting from premature research have diminished the significance of an abstract medium for expressing solutions of software development in the area of Application Software. Researchers simply delegated this activity to companies with the capability to market languages of their choosing.

We have now reached the stage to understand and appreciate the fact that the development of application software is an abstract activity independent of platform. We need a properly researched monotonic language with orthogonal abstractions, a modern IDE and a tool for creating graphical user interface. No SDK, no third-party library, no system calls, indeed nothing else is needed, as any of these will merely pollute the abstraction. A language designed with marketing goals in mind will eventually block all research in its monotonic evolution, resulting in random, often inconsistent additions.

It is quite obvious that the combination of multiple libraries, SDK etc. is the cause of low quality applications, and high cost of their maintenance. Unfortunately there is no silver bullet here, either. Specifically, it is not possible to reduce complexity by adding yet another layer of complexity. Application software development needs to shed its complexity and begin its new life in a constant, and yet perpetually evolving medium. Evolution is a slow and natural move towards perfection, and is quite distinct from random accidental events that impede it.

The new generation of applications written in Z++ will be oblivious of the bizarre chaos that we are presently referring to as complexity. Obviously, an abstract, platform independent medium for expressing solutions cannot be trivial. Mathematics is not trivial, but it is not complex either. After all, we do not mix Algebra version II from Princeton with Calculus version IV from Stanford.

Z++ abstractions are derived from successes and failures of the entire history of software development. An example of reduction in complexity through linguistic abstractions is the way C++ templates and exceptions replaced C library implementations of these notions. However, there is a difference between mathematical abstractions and an abstract language for software development. In order to avoid sci-fi claims and support the abstractions of Z++ uniformly across all platforms, we need an actual infrastructure.

The Z++ infrastructure is Z47 processor, a self-contained distributed operating system about 500K in size. Z47 depends solely on the standards of C++ and SQL. This makes Z47 readily available on any reasonable platform without regard to its size. The only dependence to platform is the drawing of the GUI.

Z++ is freely available from ZH Micro.

Labels: , , ,