Free Software (Part 1: The Philosophy)

Update (February 27, 2012)

Almost four years after I first wrote this series of blog post, I found myself returning to them with the urge to update them with some of the latest developments.  I decided to combine all three posts into one wiki page that I’ll be able to keep current more easily as I make more connections regarding this huge and important topic.

I just installed a basic comment plugin to the wiki so feel free to comment there.

Preface

On May 13 2008, I had the chance to hear Mr. Richard Stallman speak at TsingHua University in Hsinchu, Taiwan. Over the following few months, this led me to research the issue of freedom and technology in more depth. During this time, I documented my findings in three blog posts.  Since then, I’ve come back to these blog posts a few times and edited them slightly, mainly to add new resources that I thought were relevant to the argument.

At the end of each post, you will find a link to the next part, as well as a reference section where more resources can be found on the topic. I hope you find this summary useful, and I welcome your feedback and comments.

Update (May 20, 2008):
Shortly after finishing this entry, I emailed Mr. Stallman to thank him for his talk and to ask him whether my interpretation of his ideas was correct. He emailed me back the next day saying that “aside from (…) two points, I think it is very good.” [6] I’ve added these points in green in the text.

Introduction

This is the first of a three part blog entry about free software. I will begin here by describing the meaning of “free” in the context of software, and give a brief survey of the philosophy behind it. In part 2, I will summarize Richard Stallman’s argument as to why using free software is particularly important in education. And finally, in part 3, I will propose concrete steps that we can take to migrate (if only partially) to using free software in schools.

One of the difficulties with discussing the concept of free software in English is that the word “free” has at least two meanings: free as in “free stuff” and free as in “freedom”. In French, for example, this ambiguity can be avoided easily by using the word gratuit for the first meaning, and libre for the second (in English, you can think of the words “gratis” and “liberty”). Here, it is the second meaning that is intended, and the phrase “free software” actually describes the freedom of the user, not the price of the software. Indeed, many pieces of freeware are gratuit but not libre, and it is possible to have to pay to acquire libre software. A lot of the time, however, software that is libre is also gratuit (but not necessarily).

Some Vocabulary

Although the important issue is related to ideas of freedom and ethics (and have little to do with programming in itself), familiarity with a few nerdy terms might be necessary to follow the argument. Here’s a short list of terms that should help the less tech-savvy readers.

OS: Acronym for “Operating System”. An OS is the collection of programs that allows the user to interact with other programs. Examples are Microsoft Windows, Mac OS X, Unix, GNU/Linux, etc. You can think of the OS as the stage on which other programs are made visible for the user to interact with.

Unix: A powerful proprietary OS mostly used in academic circles and installed on servers.

Kernel: A program at the heart of the OS. The kernel allocates resources to other parts of the OS.

GNU: A free OS pioneered by Richard Stallman in 1983. Since most of the variants of the system today use the Linux kernel, such systems are called GNU/Linux. Unfortunately, the name “Linux” has come to be mistakenly used to refer to the whole system instead of just its kernel.[1; p. 50] The name “GNU” is a recursive acronym for “Gnu is Not Unix”. It refers to Unix because it was built to be its free, compatible alternative.

GNU GPL: The GNU General Public License is a “copyleft” license that gives everyone permission to run the program, copy the program, modify the program, and distribute modified versions without being allowed to add restrictions of their own. [1; p. 22]

Machine Code: Computer code made of 0′s and 1′s that computers use to perform tasks. This code can’t usually be understood by programmers, except in very simple cases. The machine code (also called “binary program”) is what people download and install on their computers. It doesn’t contain human-readable instructions on what the program is actually doing. [1; p. 3]

Source Code: Code written in a programming language that is read (and written) by programmers. Source code also usually contains comments written in plain English that do not contain computer instructions, but instead explain the logic of the program so that other programmers can more easily understand it. Computers cannot execute source code directly, so it needs to be converted it into machine code first. [1; p. 3]

Compiler and Assembler: Computer programs whose task it is to convert source code written in a specific programming language, into machine code that the computer can read. [1; p. 3]

What is “free software”?

“Free software” doesn’t refer to the price of the software, but the freedom that the user has in using the software. According to the GNU GPL definition, a software is free if and only if it satisfies the following four conditions (called “the four freedoms”). [1; p.20, 165-166]

• You have the freedom to run the program, for any purpose.
  
• You have the freedom to modify the program to suit your needs. (To make this freedom effective in practice, you must have access to the source code, since making changes in a program without having the source code is exceedingly difficult.)
  
• You have the freedom to redistribute copies, either gratis or for a fee.
• You have the freedom to distribute modified versions of the program, so that the community can benefit from your improvements.

All of these four freedoms are necessary for a software to be called “free”, or else, loopholes appear in which it is possible for software developers to have unethical control over the users.

Why is free (libre) software important?

I think one of the difficulties that some people have with the idea of free software is that they don’t see any problems with the source code of a program being kept secret. To help us understand why this is a problem, Stallman used the analogy of a recipe. Unfortunately, during his talk last week, I don’t think he exploited this analogy as much as he could have. Thus, I expend his idea, hoping that it will help clarify the reason why it is important to use only free software.

Imagine that you have a very sophisticated robot-cook in your kitchen (for which you probably payed good money). In today’s day and age, kitchens are not designed for humans anymore so you don’t have access to it. Furthermore, the ingredients are being ordered by the robot, and delivered directly to your kitchen, so you don’t know what these are either. When you want a meal, the only thing you can do is tell your robot what you want (with a few personalized options) and the robot downloads the required instructions for making your meal from an online database (downloads for which you may or many not have to pay). Here are the problems with this scheme.

First, because you can’t understand the instructions (machine code) sent to your robot, you have to trust that the company who creates them is not trying to poison you. More realistically, companies would probably not want to kill their costumers (that would be a pretty bad business plan), but they might want to make their meals as delicious as they can (to be competitive) and cut corners, even if it means using some unhealthy chemicals to achieve this goal.

However, even assuming that you had complete trust in the company you use, there is still the possibility of honest mistakes, which you have no way of checking for yourself. For example, maybe one of the ingredients reacts badly with another, and no-one in the quality control team caught that. “Or maybe, there’s absolutely nothing wrong with the recipe itself, but a few people are allergic to ingredients that would normally be harmless to others.” [6] The point is that you have no freedom to check the ingredients and the recipe for yourself (or to ask your uncle’s cousin’s best friend who knows about stuff like that); and that’s bad.

Consider the following alternative. When you want a meal, your robot accesses an online database similar to Wikipedia where users write their own recipes, hold discussions and debate about them, and extend each other’s creative ideas. There are three obvious advantages to this scheme.

First, access to these recipes would probably be free (gratuit), but they wouldn’t have to. Secondly, the quality of the resulting recipes would probably be better because they are written by the people, for the people. Indeed, the fact that the recipes are public ensures that only the best recipes survive scrutiny. Imagine someone proposing an alternate recipe that was less healthy. With such public scrutiny, the flaws would quickly be exposed, the recipe fixed, and the reputation of the “developer” tarnished. Thirdly, and most importantly, a database of free (libre) recipes gives you the freedom to think for yourself and to make real choices about what you want to eat.

To continue with this analogy, consider the following criticism: In this day and age (where robots cook for us), very few people actually know how to read, analyze, and write recipes anymore, so really, only an elite portion of the population has this increased freedom. To some level, this is true. Only a few people can really exercise the second and forth freedoms defined in the GNU GPL. However, while it is true that the average Joe can’t really read recipes for himself, he still benefits from the peer review process under which recipes are subjected. As Aled justly pointed out during one of our conversations about this, the process is similar to that of scientific inquiry: Scientists propose hypotheses, form theories, devise experiments, and then subject their work to peer review; and the process starts over again with the next generation of ideas. All this time, less scientifically minded people benefit from the fruits of this open process.

The same goes for software. When only the machine code is given, only the programmer who wrote the code and the computer that executes it know what the program is really doing. The program might contain “evil” instructions to spy (spyware and viruses anyone?), or more charitably, honest mistakes (called “bugs”), but there’s no way of telling. [1; p. 117] When the programing source code is also given, then public discussions are generated which ensures a high level of quality and ethical standards.

Another criticism of free software is that we should not be allowed to copy and share all software since it would destroy the economy of computer programs. The third freedom of the GPL is not saying that programmers can’t get paid for their work. Indeed, they could still be commissioned to write custom-made programs for a particular users. As Stallman points out: “The free software philosophy rejects a specific widespread business practice, but it is not against business. When businesses respect the users’ freedom, we wish them success. ” [1; p. 24]

This leads, however, to a forth criticism that I heard yesterday when talking with a friend of mine about this: Nobody would ever go for such an idealistic scheme. Why would anyone want to spend time writing code (recipes or whatever) for free? Forcing companies to allow people to share their software freely will lead to the extinction of software used by normal people. Fortunately, we don’t need to try to theorize about the depths of human psychology to answer this one. The truth is that people do. Wikipedia is one of the best known examples and the GNU/Linux project has now reached such a high level of maturity and user-friendliness that everyone can download and use a free system already.[2] It’s already here and working! For some reason, people are contributing to this free knowledge. It’s just a matter of actually using it. Why the resistance?

Why is free (gratuit) software dangerous?

Software that is only gratuit but not libre is dangerous because it creates addictions. Doing the right thing is usually not the easiest thing to do. Sometimes it is, but most of the times it requires more effort. The same goes for using free (libre) software.

Companies usually have ulterior motives in developing attractive, free (gratuit) software. For example, Apple’s OS, though not free at all, could be argued to be easier to use than the free alternatives, but it is only allowed to run on Apple hardware. [5] Next thing you know, you not only want a MacBook, but also an iPod, an iPhone, and other iThings. Once you’re fully equipped, you really have to hope that Apple continues to go in the direction you like, or else you’re stuck. In addition to the long term problems that this creates, there are also serious short term problems: Software, and songs that are filled with DRM’s [7] can’t be used on other systems. Most songs bought though iTunes, for examples, can only be played on a restricted number of “authorized” computers. DRM’s are one example that immediately restrict the user’s freedom. [6]

The longer we use proprietary programs like Keynote, Pages, or Garage Band, the harder it becomes to convert our work and make the switch to a free system. I use Apple instead of Microsoft as an example because that’s what we use at our school, and also because Microsoft is already heavily criticized by others anyway. Software that is gratuit but not libre usually fuels a corporate addiction that is difficult to break; Microsoft and Apple are no different in this respect.

Conclusion

Again, the essence of the issue is not about software, or programming, or even about technology. It is about preserving the freedom to know what we are using, and the intellectual freedom of discovering new and better ways of doing things. The same underlying philosophy applies to science, politics, and other areas of civic life. With technology, however, one of the biggest problems is that “interest in the software is growing faster than awareness of the philosophy it is based on.” [1; p. 31] This can lead to dangerous addictions that are hard to recognized and acknowledge, let alone dealt with.

Having realized that we now have the possibility of being free from proprietary software, one might feel excited and keen on switching to a free system, thinking that the only work left is to help free others. Unfortunately, there are still many ways in which free software is threatened. We always run the risk of losing the ability of running free software. One of these ways is if hardware manufacturers keep their specifications secret (such as hardware made for Microsoft Vista). Regular users should therefore pay special attention to buying only hardware that is supported by free software. [1; p. 28]

Another danger lies at the political level: The patenting of the ideas of what software can do. A patent is very different from a copyright. “Copyrights cover copying only (…) A patent is an absolute monopoly on using an idea.” [1; p. 97] For example, the method for encoding and decoding mp3 files is patented and “in 1998, a free program to produce mp3 compressed audio was removed from distribution under threat of a patent suit.” [1; p.30] In such cases, users need encourage new (free) ways of doing things (like using the OGG compression algorithm [3] instead of the MP3 algorithm [4]). We should also be politically active and push for proper use of patents. In fact, “an Australian government study of the patent system in the 1980’s (…) concluded that aside from international pressure, there was no reason to have a patent system—it did no good for the public—and recommended abolishing it.” [1; p. 99]

“Switching to a free system” will be the subject of Part 3 of this blog series. Before we get to that, however, Part 2 will summarize Stallman’s argument of why these ideas are particularly important for schools.

Please feel free to comment, ask questions, propose solutions, about anything you read here…

Part 2 >>

References:

1. Stallman, Richard M. Free Software, Free Society: Selected Essays of Richard M. Stallman, Boston, MA USA: GNU Press, 2002. <
   http://www.gnu.org/doc/book13.html
   >
2. The Free Software Foundation Directory <
   http://directory.fsf.org/
   >
3. Vorbit <
   http://www.vorbis.com/
   >
4. Stallman, Richard M. Why Audio Format Matters.<
   http://www.gnu.org/philosophy/why-audio-format-matters.html
   >
5. Apple Hardware and Software Product Agreements <
   http://www.apple.com/legal/sla/
   >
6. Email from Richard Stallman received on May 20, 2008
7. DefectiveByDesign Home page <DefectiveByDesign.org>
8. Truchon, Patrick, Free Software (Part 2: In Schools), <
   http://ptruchon.wordpress.com/2008/05/24/free-software-part-2-in-schools/
   >

About these ads