IT Infrastructure Architecture Blog

Sjaak Laan's vision on infrastructure architecture

Is software ever finished?

Some applications (and operating systems) like Windows, Oracle or Microsoft Word seem to never reach a final state.

Microsoft Word is a word processor, which is on the market for more than 10 years now. Why is it that an application like a word processor is still improved and changed after all these years? One would assume that at a certain point in time, the application would be finished, but it’s not. The same goes for applications like Oracle's database or the Apache webserver. There are three reasons for this: Bugs, adapting and improvements.

Bugs

Some software is built on an old, and sometimes unstable basis, like Microsoft Windows. Windows has it's base in MS-DOS, a command-line based operating system without multi-user or networking capabilities. Because people want Windows Vista to still run MS-DOS application from 20 years ago, much work must be done to keep everything working in every new release of Windows. This makes software very complex and error-prone. Therefore many bugfixes are inevitable.

Because software made by commercial companies can only be sold when it is market-ready, commercial drivers set release dates for software. Even if the software is not 100% bullet-proof, or if not all features are completely tested, the software must be released. This causes bugfixing after the software is released, sometimes for a considerable amount of time.

Since the widespread adoption of the Internet, much attention is given to security. Securitybugs nowadays are a large source of bugfixes.

Adapting

Some software is dependent of other software to function. This causes software that was originally finished, to be upgraded all the time. A good example of this is the Apache webserver. One could say that a webserver can be a simple program, serving HTML pages over a TCP port. And the original Apache webserver was indeed as simple as that.

But developers from for instance PHP wanted to have Apache run PHP programs that were embedded in webpages. This caused Apache to be extended. The same happened when support for databases was needed, or secure connections, or webservices. Apache became bigger and bigger.

Improvements and new versions

For commercial software vendors, it is not attractive to finish software completely. This would dry up the revenue stream. It is much more profitable to have a new release of the software every two years. Even if this new version contains new features that few people want or need. At some point in time, upgrading software just to have some new features nobody really wants or needs is just not interesting for customers anymore. This is what is happening to Microsoft Word for example. Few people want to upgrade to a new version after Word 2000, because this products is actually really finished.

To avoid the problem of customers not upgrading to the latest software release, software vendors came up with another strategy: support. While not many people (let alone companies) want to upgrade to Windows Vista, many are forced to. Microsoft will stop selling Windows XP, it is not installed on new computers anymore and the support for it will also stop in the near future, although Windows XP is still a fine product, that works perfectly for 95% of the customers,

Drawbacks

Because of the constant "improvements" and bugfixing, many applications will never be finished. This makes software very hard to manage for programmers. It would be much easier to build software using smaller components, that will be finished and never touched again. This is the design philosophy of UNIX. UNIX consists of a fairly small kernel, with addons as small components (drivers, modules and shell-commands). The philosophy of UNIX (and later Linux) was to have small tools that do one thing, but do it very well. Commands like tar,grep and ls are finished for many years, but are still used all the time. Very few people feel tar has too little functionality or bugs.

This works also for the Windows environment. For instance, Winzip is around for many years, without improvements or bugfixing. It works and it is finished. The same goes for paint and notepad for instance.

I feel it would be a good choice for software development companies to slit-up applications and let them consist of smaller components. These components could be completed and finished, while the main application can still be improved. It works. Look at the GNU/Linux operating system for example.