Friday, April 17, 2009

Software Development Context

There is a lot of unfinished work waiting to be published. The engagement with porting the Z++ Visual IDE to Linux, in particular making Z47 Processor work with GTK+ has deprived me of a moment of useful thinking. The painful part is that, since Z++ is itself a system program, the context described in this article applies to its development. After all it has to be developed using C++.

Let us abuse the term context free, somewhat. For instance, we may thing of a C++ program as being context free. It only gains context when we interpret that program for a particular application. In practice we actually wrote that program specifically for the particular application we are mapping it to.

The notion of context that I have in mind is different, though. Consider the fact that C++ is a standard. What that ideally means is that, if you wrote a C++ program, using compiler A, you can compile the same program, using compiler B with identical results. For a moment, assume that is actually the case so long as you can avoid a few things.

So now the question is, what are the few things that you should avoid so that your C++ program is seamlessly portable? Well, that is no less than half of your program, which uses such things as system calls, third-party libraries, SDK etc. The development context that I have in mind is that half that takes a list of acronyms to describe, things like MFC, JDBC, GTK+ and a few more. That is the context of your development because your software cannot be ported to another platform without changing its context.

Thus, even though one may assume C++ programs are portable, C++ applications are bound to their context. Since C++ is a system programming language, C++ applications cannot be separated from their context. That is how it should be for otherwise we would not have a reasonable system programming language for large system programs. The problem is not C++. Rather, the incorrect use of C++ for developing applications, as opposed to system programs, is the cause of unwieldy cost of maintenance.

What is wrong is using a system programming language for developing system-independent applications. This practice constrains the application with the heavy weight of unnecessary context. Certainly, a device vendor loves to see applications developed by using their SDK so that they are tied up with their device. It is the software developer that has to make the right choice so he would not go down with the fall of the device. Applications developed in Z++ survive computing devices because they are context-free.

Labels: , , , ,