My views on free software have changed somewhat since my last essay on the subject of software licenses. Looking at the previous one, it seems to me too much of a restatement of the arguments of Richard Stallman. I also felt that much of what I said was Microsoft bashing which was unrelated to the debate about free software. In this version, I will argue the merits of free software, but I will also point out where Stallman and the FSF are wrong. I will present some of my ideas for a compromise between the benefits of proprietary and completely free/open source licenses.

Whenever people do work with their brains instead of their hands and create ideas instead of tangible objects, they must ask themselves, "how much control do I want over this work?" They may decide that they want to prevent anyone else from using it, copyright it, and attach an "All Rights Reserved" label to it. They may decide to allow anyone to use it for any purpose and put it in the public domain. They may let others use it for any non-commercial purposes. If they retain greater control, they will most likely be able to make more money than if they allow anyone to use it in any way because customers are then prohibited from using it in any way. If they have less control, the rest of society gains more, but the author receives less compensation for his/her work.

The collapse of the Soviet Union proved that capitalism, in some form or another, is the best economic system in existence. Like it or not, competition breeds higher quality products in the market place. The better companies, workers, and ideas are rewarded, and their weaker counterparts are punished. (If we look elsewhere in history, we can easily find faults of pure capitalism; these issues, however, are beyond the scope of this essay and are mostly irrelevant to the issue of software licenses, so I won't cover them here.) So, if capitalism works because of competition, what makes open source work?

For those who aren't programmers, whenever you run a computer program, you are (almost always) not running what the author(s) actually wrote. Your computer only understands machine language, which is made up of the famous 0s and 1s. Although some of the earliest computer programs were written in machine language, virtually none are today. As one might imagine, it's extremely cumbersome to write anything very complex with only 0s and 1s. If you directly translate the 0s and 1s into English-like syntax, you get assembly language, which, although it is decipherable, is difficult to write complex programs with. The commands that a computer can directly use are so basic that efficient software development requires a higher level language to simplify commands. To analogize this, on a scientific calculator, it's easy to, say, find the sine of a given angle. Although possible, finding the sine of any given angle on a four-function calculator would require many tedious equations. To save time, energy, and write better software faster, programmers write software in higher level languages. The code written in a higher level language is called the source code, but to the computer the source code is useless; it must first be translated into machine language. What programmers do is run the source code through a program called a compiler, which translates the higher level language code into assembly language, and then the assembly code is run through a program called an assembler, which translates the assembly language code into machine language, producing one or more files called binaries or executables because they can be executed by the machine. Can you get the source code of a binary or executable by running it through a decompiler or deassembler? You probably cannot, but even if you could, the license agreements to proprietary software almost always prohibit it.

So what's the big deal about the source code? If you have the source code to a program, you are able to learn from it and improve it. Suppose you find a bug in a program, and want to fix it. If you want to change the way a program does something, and you are allowed to modify the source code, you can do it. If the program is proprietary, you can't. If you're not a programmer, you most likely don't see any benefits to having the source code, but there are. If the source code is available, other people who do know how to program can change it; they may sell or put their improvements up for download, and you could hire a programmer to customize a program for you. Although most people don't know how cars work, they can still take their cars to an auto mechanic to get them fixed or improved. If the hood is locked shut, this wouldn't be possible.

Open source may not be a very capitalistic way to develop software, but it's impossible to deny its successes. Although some will dispute this, I feel very comfortable arguing that, based on purely technical merit, Windows is not the best operating system in existence, and I'm quite sure that a majority of the IT community would agree with this. If you look at the other major operating systems in use today, namely GNU/Linux, BSD, or Apple's Mac OS X, the first two are completely open source, and the last is open source in a proprietary wrapping developed by Apple. All of them owe much (if not all of) their success to open source development. Mozilla Firefox has blown Microsoft's proprietary Internet Explorer out of the water in the second round of the browser wars, and Apache is considered to be the most advanced web server software around. I could go on, but my point is that open source software isn't a just a bunch of cheesy programs; in many areas, it's on the bleeding edge of technology.

Open source software is often called free software. Free software, by definition, is not free in the sense of it having no cost. It is free in the sense of the user being able to do with it as he/she pleases. Users may modify and redistribute the software without restriction. The free software community often uses the phrase "free as in freedom, not free as in free beer" to explain this idea. The Free Software Foundation (FSF) and the GNU project believe that, by putting restrictions on their programs, proprietary programmers and software companies are violating the fundamental freedoms of the users. I disagree with this belief.

Richard Stallman, the founder of GNU, deserves great credit for starting the free/open source software movement. GNU has been very successful in turning out a world class operating system. But the idea that the fundamental freedoms of users are violated by placing limitations on software does not make much sense. It is the freedom of the user to choose not to buy proprietary software, and they are not coerced into buying it. Every time they install it on their computers, they agree not to violate it. Yes, open source software is "free as in freedom," but it's not freedom in the sense of something that should be put on a Bill of Rights. It's more like freedom in the sense of an SUV giving you the freedom to go off-road. Proprietary programmers don't violate the fundamental freedoms of consumers any more than the manufacturers of two-wheel drive vehicles do. The reason that restrictions are placed on software is that authors want to be compensated for their work. In spite of the fact that free software is not by definition "free as in beer," it's difficult for free programmers to earn any money by selling their software. Yes, when proprietary software goes on the market (or even before that), it gets placed on the Internet for download, but it's still illegal. Although many users don't care about this, they still risk getting caught. If one were to attempt to sell free software in a retail store, it would be next to impossible for the author(s) to make money. The retailer would simply buy one copy, and then make many copies on its own and make nearly a 100% profit on the software.

Many free software proponents point to companies like Red Hat, who sell free software, make no proprietary software and are still profitable. Red Hat sells subscriptions, which consist of software bundled with technical support and various guarantees. The fact is that free software itself makes virtually no money except through donation. If technical support is what software companies should be rewarded for, are we rewarding the programmers who write the best software? Of course we aren't; in fact, ideally software should require as little support as possible. Such a system might even backfire and give the most money to the worst programmers.

Another argument presented by free-redistribution advocates is what I'll call the "free lunch analogy." Suppose person A has a sandwich and person B doesn't. Person B magically copies person A's sandwich so that he/she has his own. So, person B got a sandwich and person A didn't lose anything. What's wrong with this? Well then, let's look at a very similar scenario: someone counterfeits money. The end result is that the counterfeiter has made money, and no one else lost money; what's wrong? Money is what we use to represent work. If we work, we want to be rewarded for it with something we want. Because different people want different things, we use money as a medium for bartering. If someone can just pretend that they did work (counterfeiting), the value of the real work diminishes through inflation. If counterfeiting is easy and the public lacks the principle to refrain from doing it, people realize they don't have to work. People not working because real work doesn't bring rewards is what brings down communism. Writing computer programs is real work, and if someone simply copies real work without rewarding the author, we end up with the same dilemma: real workers get no more than lazy people.

In some cases, it may be better for everyone if software is available for free (free as in free beer). Had Linus Torvalds charged money for Linux, it may well not have developed into what it did. This, however, is not the subject of this essay; donations happen in many fields besides software. Programmers, when they want it, deserve compensation for their labor, and there ought to be no question about that. I have actually bought a copy of Slackware Linux, but I downloaded a copy and tried it before I bought it, so in essence my purchase was a donation. I bought it because I wanted to reward those who went through the effort to produce it. Free software would be economically sound if users felt and acted upon an obligation to reward the authors of the software they run, but one cannot expect companies to make profits simply by donation. Programmers shouldn't be paid out of good will or for offering tech support; they should be paid for programming.

Richard Stallman lists four basic freedoms that he believes all users should have with regard to their software: 0) to run the program, for any purpose, 1) to study how the program works, and adapt it to your needs, 2) to redistribute copies so you can help your neighbor, and 3) to improve the program, and release your improvements to the public, so that the whole community benefits. There's nothing wrong with all of the freedoms except for number 2; in fact, it's hard to see how a business would be hurt by giving freedoms 0, 1, and 3 to users. However, exercising "freedom" 2 is no more a fundamental freedom than is the "freedom" to counterfeit money to help your neighbor pay for his/her bills. Redistributing software without the author's permission is making up work you didn't do. No, the programmer doesn't have a grudge against your neighbor; the programmer just wants to be paid.

The question is, how do we compensate programmers for their labor while simultaneously preserving the benefits of open source? Obviously, neither a pure proprietary nor a pure free/open source approach will work. Some companies, like id Software, release the source code to their programs a certain period of time after they release proprietary versions of their software. In some ways this works, but it still delays the improvements users could be making; it just slows the advancement of technology. Perhaps programmers and companies could subdivide the worth of a complete software package among the different parts of the source code, and if the code is used in other projects, the other projects would have to pay up for using the code. There wouldn't be anything wrong with competing projects using each other's code, but the people who wrote the good code should be paid for it. For example, software project A uses code from project B worth $10 per license. Project A licenses its entire package for $40, and so for each purchase of project A's software, 25% goes to B. As technology advances, values would depreciate until the code is free in every sense of the word; this is pretty much what happens to 100% proprietary software too. I don't have a magic answer, but this is just an idea I'm throwing out there.

When deciding what the "ideal" software license is, we must keep two things in mind. Capitalism and competition produces high-quality products, and open source code produces high-quality software. On a more personal level, when we do work, we want to be paid; when we work hard, and lazy people receive the same pay, we do and should be angry. But also on a personal level, we want to be able to modify the items we buy with our hard-earned salaries. If we want to add a room to our house or add a security system, we don't want to have to ask for permission, let alone be denied permission. We should be forced to pay for our sandwich, but we should also be able to add mustard or mayonnaise if we want to. The way to combine these two values, the best of capitalism with the best of open source, is to remove the "freedom" to freely redistribute software from the other three. Reward good programmers for good work, but let users make full use of the software they pay for.

I welcome comments on this essay. Please email me at lasindi@gmail.com.