An argument for free software

You may have noticed that I often call Yabasic "free software". In this context, I always mean "software that is free in the sense of freedom". (Of course, Yabasic is also available free of charge.) I am careful to avoid confusing the terms "open source software" and "free software": the former is a development methodology (a way of creating software), and the latter is a philosophy. Software can be "open source", yet not be "free" in the sense of freedom. Yabasic qualifies both as free and as open source software.

A program qualifies as "free software" if its copyright holders have made it available under terms that allow recipients to freely use, copy, study, modify, and distribute it (either modified or unmodified). I could procrastinate at length about the moral high ground of the free software movement, but I'm not going to do that. Instead, I want to develop an argument for free software which is often neglected, an argument that is quite relevant to many BASIC programmers today: the argument from preserving our software heritage. Allow me to elaborate.

We all know that computers change and that the computing world evolves. Not so long ago, computers were found only within the domains of universities and highly-funded institutes; now, it's not uncommon (in the Western world, at least) for individual households to have more than one personal computer. Software changes rapidly as new algorithms and better techniques for data storage become known, and also as companies try to outdo each other. Suffice it to say, a lot of software that we currently use will look quite different in ten years' time.

Data formats and programming languages change as well. I am confident that BASIC will not die out within the space of a decade, and its potential as a fun language, often agreeable to beginners, may even cause certain variants to gain in popularity. (I live in hope.) We would be fooling ourselves, though, to think that pre-compiled software that runs quite well on our 32- or 64-bit computers will run just as well on modern systems ten years later. Unless programs are changed as the computing world changes, it is unlikely even that most of today's body of source code—whether written in C, C++, Java, or some other language—would compile or run properly on a modern system in a decade's time.

What I'm getting at, then, is that software will quickly be rendered obsolete and unusable unless it is updated regularly as computers change, libraries are improved, and the computing world in general rolls on. Now to tie that into my main argument.

A program counts as "proprietary software" if its copyright holders do not allow users to use, copy, study, modify, or distribute it freely. Indeed, much proprietary software is licensed in such a way that users are forbidden from doing anything with the software except using it, and, usually to a very limited extent, copying it locally. The copyright holders of proprietary software most often refuse to make source code publicly available, and this has a number of profound negative consequences.

For many reasons, programmers cannot be expected to support archaic programs indefinitely. Sadly, many historically-important programs fall out of common use and are lost in the mists of time—often, really lost, because the copyright holders selfishly refuse to release the source code into the public domain. (In some cases, it's impossible to contact the copyright holders.) If such programs will not run on today's systems, how much less will they function on the systems to be found in a decade's time? When historians try to research the history of the computing world, they will run up against walls of all kinds: technical walls, legal walls, and, perhaps worst of all, "language" walls.

Open up an compiled executable file in a text editor, and observe the wonderful Language of the Computer. You almost certainly cannot understand it, and there are few who can (and even they cannot fully deduce the source code of a program from its compiled executable). And it's not a static Language; changes are made to it as new ways of doing things are discovered. Programmers will keep up with the Language of the day, and, in ten years' time, very few people will understand the arcane symbols you see in front of you now. In fifty? Well, I'll stop there, because you can guess the situation. If the program is free in the sense of freedom, you can rest in peace: the source code will probably still be accessible from some public archive even fifty years into the future.

How does this relate to us? Well, I think all of us have an interest in the history of BASIC, and a respect for our computing heritage. We now have to come to terms with the fact that so many BASIC interpreters and compilers, and so many BASIC programs, are no longer usable on modern systems (I know there are various emulators available, but often they are not fully functional). We will lose more and more BASIC-related programs in the future. Why? Because so many dialects of BASIC, and so much software created using BASIC, is proprietary, and the Language of the Computer slowly but surely changes.

Free software is the only kind of software that reliably preserves our software heritage. Already, we are losing old proprietary BASIC interpreters and compilers—pieces of software that would, ideally, help us to research, remember, and enjoy our history. Let's not support proprietary software. We need to address the problem now, so that humanity won't have to suffer ten, twenty, thirty, a hundred years from now because of our "short-mindedness".