Since 1983, the Free Software Movement has campaigned for computer users’ freedom—for users to control the software they use, rather than vice versa. When a program respects users’ freedom and community, we call it “free software.”
We also sometimes call it “libre software” to emphasize that we’re talking about liberty, not price. Some proprietary (nonfree) programs, such as Photoshop, are very expensive; others, such as the Uber app, are available gratis—but that’s a minor detail. Either way, they give the program’s developer power over the users, power that no one should have.
Those two nonfree programs have something else in common: they are both malware. That is, both have functionalities designed to mistreat the user. Proprietary software nowadays is often malware because the developers’ power corrupts them. That directory lists around 550 different malicious functionalities (as of November, 2021), but it is surely just the tip of the iceberg.
With free software, the users control the program, both individually and collectively. So they control what their computers do (assuming those computers are loyal and do what the users’ programs tell them to do).
With proprietary software, the program controls the users, and some other entity (the developer or “owner”) controls the program. So the proprietary program gives its developer power over its users. That is unjust in itself; moreover, it tempts the developer to mistreat the users in other ways.
Even when proprietary software isn’t downright malicious, its developers have an incentive to make it addictive, controlling and manipulative. You can say, as does the author of that article, that the developers have an ethical obligation not to do that, but generally they follow their interests. If you want this not to happen, make sure the program is controlled by its users.
Freedom means having control over your own life. If you use a program to carry out activities in your life, your freedom depends on your having control over the program. You deserve to have control over the programs you use, and all the more so when you use them for something important in your life.
The first two freedoms mean each user can exercise individual control over the program. With the other two freedoms, any group of users can together exercise collective control over the program. With all four freedoms, the users fully control the program. If any of them is missing or inadequate, the program is proprietary (nonfree), and unjust.
Other kinds of works are also used for practical activities, including recipes for cooking, educational works such as textbooks, reference works such as dictionaries and encyclopedias, fonts for displaying paragraphs of text, circuit diagrams for hardware for people to build, and patterns for making useful (not merely decorative) objects with a 3D printer. Since these are not software, the free software movement strictly speaking doesn’t cover them; but the same reasoning applies and leads to the same conclusion: these works should carry the four freedoms.
A free program allows you to tinker with it to make it do what you want (or cease to do something you dislike). Tinkering with software may sound ridiculous if you are accustomed to proprietary software as a sealed box, but in the Free World it’s a common thing to do, and a good way to learn programming. Even the traditional American pastime of tinkering with cars is obstructed because cars now contain nonfree software.
The Injustice of Proprietariness
If the users don’t control the program, the program controls the users. With proprietary software, there is always some entity, the developer or “owner” of the program, that controls the program—and through it, exercises power over its users. A nonfree program is a yoke, an instrument of unjust power.
In outrageous cases (though this outrage has become quite usual) proprietary programs are designed to spy on the users, restrict them, censor them, and abuse them. For instance, the operating system of Apple iThings does all of these, and so does Windows on mobile devices with ARM chips. Windows, mobile phone firmware, and Google Chrome for Windows include a universal back door that allows some company to change the program remotely without asking permission. The Amazon Kindle has a back door that can erase books.
The use of nonfree software in the “internet of things” would turn it into the “internet of telemarketers” as well as the “internet of snoopers.”
With the goal of ending the injustice of nonfree software, the free software movement develops free programs so users can free themselves. We began in 1984 by developing the free operating system GNU. Today, millions of computers run GNU, mainly in the GNU/Linux combination.
Distributing a program to users without freedom mistreats those users; however, choosing not to distribute the program does not mistreat anyone. If you write a program and use it privately, that does no wrong to others. (You do miss an opportunity to do good, but that’s not the same as doing wrong.) Thus, when we say all software must be free, we mean that every copy must come with the four freedoms, but we don’t mean that someone has an obligation to offer you a copy.
Nonfree Software and SaaSS
Nonfree software was the first way for companies to take control of people’s computing. Nowadays, there is another way, called Service as a Software Substitute, or SaaSS. That means letting someone else’s server do your own computing tasks.
SaaSS doesn’t mean the programs on the server are nonfree (though they often are). Rather, using SaaSS causes the same injustices as using a nonfree program: they are two paths to the same bad place. Take the example of a SaaSS translation service: The user sends text to the server, and the server translates it (from English to Spanish, say) and sends the translation back to the user. Now the job of translating is under the control of the server operator rather than the user.
If you use SaaSS, the server operator controls your computing. It requires entrusting all the pertinent data to the server operator, which will be forced to show it to the state as well—who does that server really serve, after all?
Primary And Secondary Injustices
When you use proprietary programs or SaaSS, first of all you do wrong to yourself, because it gives some entity unjust power over you. For your own sake, you should escape. It also wrongs others if you make a promise not to share. It is evil to keep such a promise, and a lesser evil to break it; to be truly upright, you should not make the promise at all.
There are cases where using nonfree software puts pressure directly on others to do likewise. Skype is a clear example: when one person uses the nonfree Skype client software, it requires another person to use that software too—thus both surrender their freedom. (Google Hangouts have the same problem.) It is wrong even to suggest using such programs. We should refuse to use them even briefly, even on someone else’s computer.
Another harm of using nonfree programs and SaaSS is that it rewards the perpetrator, encouraging further development of that program or “service,” leading in turn to even more people falling under the company’s thumb.
All the forms of indirect harm are magnified when the user is a public entity or a school.
Free Software and the State
Public agencies exist for the people, not for themselves. When they do computing, they do it for the people. They have a duty to maintain full control over that computing so that they can assure it is done properly for the people. (This constitutes the computational sovereignty of the state.) They must never allow control over the state’s computing to fall into private hands.
To maintain control of the people’s computing, public agencies must not do it with proprietary software (software under the control of an entity other than the state). And they must not entrust it to a service programmed and run by an entity other than the state, since this would be SaaSS.
Proprietary software has no security at all in one crucial case—against its developer. And the developer may help others attack. Microsoft shows Windows bugs to the NSA (the US government digital spying agency) before fixing them. We do not know whether Apple does likewise, but it is under the same government pressure as Microsoft. If the government of any other country uses such software, it endangers national security. Do you want the NSA to break into your government’s computers? See our suggested policies for governments to promote free software.
Free Software and Education
Schools (and this includes all educational activities) influence the future of society through what they teach. They should teach exclusively free software, so as to use their influence for the good. To teach a proprietary program is to implant dependence, which goes against the mission of education. By training in use of free software, schools will direct society’s future towards freedom, and help talented programmers master the craft.
They will also teach students the habit of cooperating, helping other people. Each class should have this rule: “Students, this class is a place where we share our knowledge. If you bring software to class, you may not keep it for yourself. Rather, you must share copies with the rest of the class—including the program’s source code, in case someone else wants to learn. Therefore, bringing proprietary software to class is not permitted except to reverse engineer it.”
Proprietary developers would have us punish students who are good enough at heart to share software and thwart those curious enough to want to change it. This means a bad education. See more discussion about the use of free software in schools.
Free Software: More Than “Advantages”
I’m often asked to describe the “advantages” of free software. But the word “advantages” is too weak when it comes to freedom. Life without freedom is oppression, and that applies to computing as well as every other activity in our lives. We must refuse to give the developers of the programs or computing services control over the computing we do. This is the right thing to do, for selfish reasons; but not solely for selfish reasons.
Freedom includes the freedom to cooperate with others. Denying people that freedom means keeping them divided, which is the start of a scheme to oppress them. In the free software community, we are very much aware of the importance of the freedom to cooperate because our work consists of organized cooperation. If your friend comes to visit and sees you use a program, she might ask for a copy. A program which stops you from redistributing it, or says you’re “not supposed to,” is antisocial.
In computing, cooperation includes redistributing exact copies of a program to other users. It also includes distributing your changed versions to them. Free software encourages these forms of cooperation, while proprietary software forbids them. It forbids redistribution of copies, and by denying users the source code, it blocks them from making changes. SaaSS has the same effects: if your computing is done over the web in someone else’s server, by someone else’s copy of a program, you can’t see it or touch the software that does your computing, so you can’t redistribute it or change it.[“source=gnu”]