Software does not age, it matures

There is an old joke that goes like this: what is the main difference between hardware and software? When you use the hardware for a very long time, it eventually wears down and breaks. When you use software for a very long time, it eventually matures and stops breaking.

This joke is funny to software developers, because they know it is true. It flies above the head of the general public because it is rather counter-intuitive. The first part rings true for just about everyone. The less mentally agile citizens (or those who grew up in simpler times and have trouble finding themselves in the modern hustle and bustle of technology) can apply the car analogy in their heads (think of hardware as your car and how it ages) and it kinda works. Everyone else, whose brain can correctly interface with modern electronic appliances know this to be true from experience.

Modern electronics age quite rapidly, and generally has to be replaced long before it starts to break due to physical wear and tear. This is partly by design (planned obsolescence) and partly due to inherent forces within the industry (Moore’s Law). This process is very visible, even to the untrained eye. Anyone can probably name a dozen technologies that rose to prominence and then faded into obscurity within their lifetime.

Commercial software follows a similar obsolescence cycle – or at least so it would seem to an untrained eye. Publishes love to apply superficial UI redesigns and add minor changes to increase the number of bullet points in the feature list every few months, and force customers to re-buy their software under a new version number or even updated product name. Constant feature additions (which lead to inevitable bloat) usually make the software perpetually unstable. So those who are accustomed to working with proprietary licensed software the joke seems incomprehensible.

But for free software, it works. Free software doesn’t age and usually does not become obsolete. It matures, stabilizes and becomes a rock solid foundation upon which you build other software. It actually blows people’s minds when I tell them I use software that is over 30 years old every single day. Don’t believe me?

As you probably know, I am a LaTex user. At the core of that complex typesetting is the Tex codebase which was originally released back in 1978 and frozen in 1989 at version 3. That software is so stable that since then, whenever a new update is released the version number is not incremented, but instead a significant digit is added at the end of it, so that the version number as a whole approaches π. Donald Knuth himself proposed that after his death Tex ought to be updated one last time, and the version number should be changed to π at which point all future bugs will automatically become features.

The primary text editor I use is Vim which is based on vi, which was written by Bill Joy in 1976. While novice programmers often scoff at it, and regard it as archaic, it remains an extremely powerful tool for power users. It is also one of the Two True Text Editors™ – the other one is Emacs which was written by Richard Stallman around the same time as vi, but designed to solve an entirely different set of problems. Bill Joy was writing an ultimate tool for text manipulation over slow network connections – an editor that would minimize cursor movement and maximize the amount of work that could be done by chaining key-stroke commands. Emacs on the other hand was built as an infinitely customizable text editing framework. Stallman knew that coders will always need their editors to do weird things, and that no matter how great the plugin API is in your IDE, it will probably not be enough. So he created a LISP interpreter with a built in text editor allowing users to write and re-write the core of the system at a whim.

The shell I use is Bash which was first released back in 1989. It was a backwards compatible replacement to the Bourne shell (1977) which in turn replaced the Thompson shell (1971). Despite it’s age, Bash is a staple of the Linux and Unix worlds. Along with the Bourne shell it is the default shell on most systems, and a primary interface through which admins interact with most servers on the internet.

The C programming language, used to write all of the above (except maybe the Thompson Shell), as well as the operating systems on which these programs run was created in 1972, and the latest stable release is from 2011. It is still used to create modern applications today, and tends to be the preferred language for systems programming. The 22 year old Linux kernel, originally released in 1991 by Linus Torvalds is written primarily in C, and has been in continuous development since then.

Apache and PHP – the technology used on the back end of this site (and many others on the internet as part of the ever popular LAMP stack) are all close to 20 years old now. PHP is still big mess of a programming language, but it has matured considerably since it’s inception, and the community that spawned around it has become adept at working around it’s shortcomings and building bridges over it’s feature gaps and plugging its security holes.

Algorithms and methodologies used in all the above applications are even older than that. Most of the state of the art searching and sorting algorithms as well as most of the common data structures such as trees and graphs were discovered in the early 70’s. I like to joke around that the reason for this was that back then resources such as memory and disk space were very limited, and Moore’s law was not a known trend yet. These days programmers don’t have the same incentive to be clever – it is often much easier to throw hardware at the problem at hand, or wait 18 months and then double your performance than devise a clever method of working around your limitations. It is however probably more accurate to say that most of these fundamental algorithms were devised back then rather than now, for the same reason many of fundamental scientific and mathematical theorems were discovered in the ancient times – it is much easier to stumble upon patterns and solutions when the science is young and the field is almost entirely unexplored.

I guess my point is that free software does not typically age – it matures. It doesn’t become obsolete – it becomes stable. Most application software grows until both the creators and community agree it is feature full, and good enough, at which point it stabilizes. Since new features are no longer aggressively added, the code surface for bugs to hide in decreases and over time it approaches zero. Systems software on the other hand is in the unique situation – it can never be stable, because it always has to catch up to hardware and support new devices and new interaction paradigms. Therefore OS can be either slightly buggy or behind the times, but not both at once.

I usually tell young, impressionable new programmers that releasing open source software is like getting married. It is a life-long commitment. Once you put it out there, you are stuck with it. There will always be bugs to be fixed and new features that will need to be added. And there will always be users out there for whom backwards compatibility will be of paramount importance. Mistakes you make early in your design and development process will haunt your for the rest of your life. Even if you divorce yourself from your project, you can never erase it from existence. It will always be around in the form of various forks and continuation projects. The only way to kill a popular open source software is to make it irrelevant. That usually only happens when you or someone else develops a competing product that completely outclasses the original. And even then there will almost always be holdouts and old fashioned users refusing to let go.

Software is kind-of weird like that. On one hand it is a very volatile market with a lot of turnaround. The rapid churn of the hardware world, the breakneck pace of new advancements and discoveries makes it seem like there is very little permanence in there. To a layman’s eyes, it might seem that applications become obsolete almost the instant they hit the market. But this is not true. Software is surprisingly durable. It endures, it evolves and it carries on. You would be surprised how much of the shiny programs you use right now can trace their lineage all the way to the dawn of the information age.

I would wager that a lion share of software on your computer is also at least a decade or two in the making. What ancient, but still perfectly usable programs do you use? How old are they, and why do you think they survived for so long?