_ __ __ ___ (_)___/ /__ ___ ___ / / ___ _______ / _ \/ / __/ '_/(_-</ _ \/ _ \/ -_) __/ -_) /_//_/_/\__/_/\_\/___/ .__/_//_/\__/_/ \__/ /_/
In previous posts, I have mentioned a lot about free software versus proprietary software. But I have never dedicated a standalone post to free software, so I'm doing that now. While I find the history of free software fascinating, I'm not going to get into that in this post. This is more of a persuasive post. I want to convince you to use free software wherever possible rather than proprietary software. There is a lot to be said on the subject. This post is about why you should use free software, not why you should code it. There are plenty of incentives to code free software though. The reason I'm choosing to focus on the user is that there's already so much free software out there, but it's not getting anywhere near the usage it deserves.
The word "free" in "free software" means free as in freedom, not free as in price. Price isn't the issue with free software, freedom is. For software to be free, it must have the 4 essential freedoms:
0. The freedom to run the program for any purpose.
1. The freedom to study how the program works and modify it.
2. The freedom to redistribute copies of the program to others.
3. The freedom to distribute copies of modified versions of the program to others.
Why are the 4 freedoms important? The most relevant answer I can give for software users is that it boils down to social and economic control. The 4 freedoms prevent the developer of the software from wielding too much power over its users. I will start with freedom 0 and go one by one explaining how each freedom impacts the social system between developers and users.
Freedom 0 ensures that the user can use the program however they wish. Without freedom 0, the developer of the software can impose rules about how the program may or may not be used. If you use the program in a way that the developer doesn't approve of, then the developer may take legal action against you. This can be done with EULAs (End-user license agreements). Click-wrap licenses can even prevent users from knowing there are restrictions on the program's use until after starting the installation process. Users may be prevented from publishing performance information about the program to compare it to competitors, trying to reverse engineer the program for learning, developing plugins for the program, or any number of other legitimate uses of the program. Developers telling users what they can and can't do with programs on their own computer gives the developer tremendous control over the users. Freedom 0 prevents this by giving the user the right to do anything with the program that they are able to get it to do (within the bounds of other applicable laws).
Programs are made up of "source code". Source code is the developer-readable format of a program. Your average Joe could look at a program's source code and it would look like gibberish. But a sufficiently skilled programmer could read the source code and make sense of the program. With compiled languages, developers cannot run a program from its source code. It has to be compiled first. In summary, source code is the format the developer can understand the program and compiled code is the format the machine can actually run the program.
After the program is compiled, it's prohibitively difficult to make sense of the program even for developers. One strategy developers use to prevent other developers from reverse-engineering their program is to write the source code, then release only the compiled version of the program to the public. This way, only the developer can understand what the program really does and how it works. Not only that, but only they can make changes to the program. These programs are known as proprietary programs. It puts the developer in a position of power over the user and incentivizes the developer to add features that might hurt the user since the user is powerless to remove the bad features. This is also not conjecture. Proprietary programs often have malicious anti-features that benefit the developer and hurt the users such as DRM, surveillance, back doors, censorship, tethers and other tyrannical anti-features.
It's possible to reverse engineer a compiled program, but it's an extremely arduous process, especially for very large programs. Free software wants practical freedom to understand and change the program, not freedom in theory. Therefore, for Freedom 1 to be satisfied, the source code of the program must be distributed alongside the compiled version of the program. This ensures that anyone who uses the program has the opportunity to understand and modify it. This grants users individual control over the program. With Freedom 1, developers have less incentive to add malicious anti-features since other developers might notice them. This could cause people not to use programs made by that developer and for the developer to lose respect.
Freedom 1 is necessary but incomplete. The problem is not everyone is a programmer, so not everyone has the skills to understand and modify their programs to their liking. They are still stuck with whatever the developer gives them. The freedom to study and modify the program means nothing to non-programmers. This is why we need Freedoms 2 and 3.
Freedoms 2 and 3 together grant collective control over the program. Freedom 2 grants the freedom to distribute exact copies of the program. If you enjoy a program, you can share it free of charge with your friends. And they can share it with their friends. Anyone who finds it useful can share it with others. If you have freedoms 0 and 1 but not 2, then you can do whatever you want with the program including studying and modifying it, but others can't benefit because you're not allowed to share the program. What Freedom 2 prevents is the developer having power over the users via controlling program distribution. A developer can't do things to prevent others from sharing the program. This means the developer is not in sole control over the distribution of the program.
As an example, Windows 10 is a proprietary operating system. An operating system is just a program that acts as a middleman (abstraction layer) between the user and the hardware. It manages system resources. Only Microsoft is allowed to distribute the Windows 10 operating system. You may not distribute it yourself. Secondarily, in order to unlock all the features of Windows 10, you have to buy a Windows 10 license from Microsoft. Microsoft is in control of the distribution of the license keys as well. If I distributed license keys for Windows 10 to others, there could be legal ramifications for me. Microsoft punishes sharing. Freedom 2 protects sharing of software with the idea that sharing is generally a good thing and should be encouraged. Sharing software isn't like sharing physical goods. If 5 people share a pizza, everyone gets less pizza. But if 5 people use the same program, then all 5 get the full benefit of the program. The benefit I get out of using it is not degraded by sharing it with others. Software is not like a pizza. It's more like a pizza recipe.
Continuing with the pizza analogy, Freedom 1 gives you the right to change the "recipe". You can make improvements and benefit from them. Freedom 3 lets you share your modified recipe with others so they can also benefit from your improvements. You can imagine a situation in which Freedoms 0, 1, and 2 are granted, but not 3. This would mean users can use the program any way they wish, modify it, and share exact copies, but not share modified copies. This is disastrous for collective control over the program. It would mean only the developer could make updates. "Forks" couldn't be public. Everyone else is free to make changes, but non-programmers can't benefit from those changes.
As I said before, free software is about practical control over the program, not control in theory. In reality, non-programmers can't make changes they want to make to the program because they don't know how to code. Even among programmers, one programmer might not have the expertise to modify a program to their liking or they might not be familiar with the programming language used. So unequipped developers and users rely on other developers to make the changes they desire. Without Freedom 3, only the original developer or group of developers is allowed to distribute modified versions of the program. In other words, the original developers retain a monopoly on modifications. They could charge any price for a requested feature. If they decide to stop maintaining the project, then other developers will be powerless to continue program maintenance. Freedom 3 is necessary to enable a healthy ecosystem of forks to suit the needs of each type of user.
Since the original developer doesn't have a monopoly on modifications with Freedom 3, other developers can improve upon the code, add features they desire, remove features they don't desire, and collaboratively contribute to the program. This is just not possible without Freedom 3.
At the bare minimum of ethical standards for software, programs should be free software. Free software ensures that the social system around the software is just, that it doesn't automatically create unjust power differentials between developers and users and between developers and others developers that otherwise wouldn't be there. Obviously if developer A is more skilled than developer B, developer A will be better able to modify the program to their liking. And obviously if user A is wealthy and wants feature X and user B isn't wealthy and wants feature Y, then user A can pay developers to prioritize feature X over feature Y. Free software is not free from influence by corporate interests. The Mozilla Foundation wrote Firefox to use the Google search engine because Google funds Firefox development in return. Microsoft, the proprietary software giant, is on the Linux Foundation. Linus Torvalds has been responsible for big decisions in the mainline Linux kernel for decades. Free software doesn't even mean development of software is democratic in practice. Benevolent dictator for life is the title given to free software developers that get the final say in development decisions. Since the "dictator" has the majority of development inertia behind them, any developer that might think of forking the software upon a development dispute would think twice since the inertia for the project already lies behind the dictator's fork. Free software also doesn't have to be user friendly. It doesn't have to have accessibility for those that speak foreign languages or the disabled. It can even be socially harmful and still qualify as free software. Some free software may require expensive hardware that only the wealthy can afford. Accessibility is limited to the rich in that case. Free software doesn't solve everything.
Free software does not solve the problems I mentioned and it's not meant to. The problems I described can possibly be avoided, with great care. With proprietary software, they are downright unavoidable. Proprietary software automatically sets up an unjust social system around software. It's a non-starter. Doomed before it even starts. There is no way to create proprietary software and have it be as ethical as free software because it doesn't meet the basic requirements for a just social and economic system. It discourages understanding, sharing, and collaboration. It's no good. If you use proprietary software often, it becomes a habit. And when it becomes a habit, the developer of the software gains influence over you because they control the software you rely on.
Developers of proprietary software have a monetary incentive to mistreat their users. Anti-features can be very profitable. They have no reason not to add anti-features since others can't understand the compiled code and won't necessarily even know about the anti-features and couldn't do anything about them even if they did because they're not allowed to modify the program. Proprietary programs are instruments of unjust control over the users. Proprietary software should not exist. It should all be eradicated and replaced with free software instead. You shouldn't tolerate it if you can at all help it. The best way you can help with the liberation of cyberspace is by switching to using as much free software as possible instead of the proprietary software you might currently be using. Free software is how we stay in control of our own computing. Without it, our devices will cease to be our own. The code we run on our devices will be under the control of developers with incentives to do us harm. We want the developers writing our software to have incentives to write software that only benefits us. If we refuse to use proprietary software and use free software instead, developers will see they can't get away with not giving users their freedoms.
In the future I envision, developers will lose all incentive to write proprietary software knowing in advance no one will use it. It won't even cross their minds as a possibility. Right now, getting people to switch to free software is a struggle. Many proprietary programs benefit heavily from the network effect, keeping many people dependent. Free software is not even a well known social issue, yet. But with enough awareness and with enough people using free software, the network effect will work in favor of a liberated cyberspace, not a divided, controlled, proprietary one. Computers become more integral to our way of life every day. Our devices have become extensions of ourselves. This is why it's critical that they at least run free software. That's the only way we can hope to trust them. Use as much free software as you can and spread the word to others. We need to take back our computing.
Unless otherwise noted, the content of this site is licensed under CC BY-SA 4.0.
© 2019-2021 Nicholas Johnson