Many people over the years have told me I am making my own life more difficult because I choose to use Linux, with the evidence that my computer is broken more often than not. While this is true, this is of my own choosing. I have decided to write up an exhaustive rant over why I use Linux, why I think you should be using free software, and how your preconditioned assumptions are all wrong.
First, let me address why my own computer is broken all the time: I am a developer. I enjoy breaking things. I enjoy fixing things. I constantly tinker with stuff to see what happens, in order to explore new things, which inevitably makes unexpected stuff happen. I do this as a way of learning about my computer. This is my own choice, and I could choose to have a working desktop instead if I wanted to. I have a few working desktop computers, and a few working servers, but when I play games or talk with friends, I am not using those computers. If I did, that'd be giving up my goal at the sign of any difficulty. I would rather struggle for a while than take the coward's way out.
In other words, I am not making my own life more difficult because of Linux, but rather because of my own silly non-standard experimentation.
I am going to split this document into two sections, each of which is written for a different groups. Many readers will not care about the second half, since that's mainly aimed for technical people, who make a living out of developing software. The first half is intended for everyone.
If you live in this third decade of the century, it is very likely you need to be using a computer. While a smartphone is also a computer, for the purpose of this debate I will not treat them as such. Society is demanding that we adapt to the newest changes, jumping onto trends that are given to us, and using the latest technologies. All this is necessary to find a job, to make friends, to take out a bank loan. As such, technology is a vital requirement in today's society.
I think this is a problem.
I don't think it's necessary to explain how hard it would be if one chose to live off-the-grid, and still participate in social events. While doable, it makes your life harder. You won't get the same engagement with people, since there is some form of protocol in how people interact with each other. People expect you to be online. People expect you to be on platforms x, y, z. Recruiters will look for potential employees on LinkedIn. Community events will be shared on Facebook. Dating occurs on Tinder. Friendship interactions happen on Whatsapp. The list goes on.
The point I'm trying to make here is that people have little choice in how they engage with society. There is no freedom in being stuck in a gridlocked society. Sure, you're surviving, and you might even live a comfortable life! I am not saying the tools themselves are bad, I am not saying they are ineffective. I am saying you don't have a choice, and that's awful.
How did we reach this situation? How did we become gridlocked like this? The answer, in short terms, is that human people are habitual creatures. We like things which don't change, and cry when something has shifted ever so slightly. We become accostumbrated to a certain set of ways of doing things, even if there are better ways of doing something. You'd rather take a longer route home, just because you're familiar with it, than a shortcut which you've never been on. We let external forces take care of things for us, and accept the fate which we're given.
«Break the chain, make a change». That's a sentence we often hear in situations of abuse. I think we can apply it here too. While a lack of freedom is not exactly the same as abuse, it is still an undesired condition. The only way we can break the paradigm in which we live, is by rejecting the traditional views of reality: habits, tools, assumptions.
Earlier I made it a point that I hadn't explicitly said the tools which we use are bad. That was because that wasn't the point then. But it is now. And I have plenty of reasons as of why.
If you jump your gun, you might say that the technology we're using today is making our lives easier, and that we wouldn't be able to survive if we just left them astray. And I'd agree. Tools are nice, they do an important job. But we can strive for better tools. Should we accept «good enough»? I say no.
Traditionally, software is deployed by someone, and we, as users, have no say in what changes are done to our programs and applications. The experts know best. There are mainly two problems with leaving it to them to do as they wish: The first one is that experts also make mistakes. Programmers are human too, they do oopsies all the time. They thought they had it right, but it turned out not. How often have you complained about some update breaking your workflow? How often have some feature you used a lot be stripped away suddenly? How often have your wishes been ignored? How often have stuff not worked, with no apparent explanation?
The other problem is that it's very common for experts to simply be following orders from their superiors... whom are generally more concerned with their own benefits —usually monetary, but also face value—, than the quality of the tools they provide. Capitalism sucks.
It is trivial to see that the second point made completely disappears when developers are dogfooding¹ the tools they are creating. If there is no superior making the rules, and they're doing the work because they want the tools themselves they are going to be doing their very best to make the best product for their own sake and sanity. The quality of the tools will directly represent their technical skills, so they want to pursue quality instead of a salary.
For the first point, things are a bit more complicated to explain, and something many seasoned self-proclaimed developers andor technical experts have fallen victim to. There is a cultural difference between how tools are developed in the FOSS community versus and in the corporate world. Developers of free software make some software they deem useful, publish it on some platforms, and often abandon them. Other times, they use it for a long time, and harness it for their own requirements. They don't necessarily consider shaping the software for anyone else, so they don't consider all the potential situations an end-user might be in. As many developers do this, we end up in a fragmented world, where all free software seems inferior to the corporate alternatives.
The last point seems like a depressing ending, where developers don't care about anyone else but themselves. Generally, this is not their intention, but just a result of lack of feedback from users and technical reviews. Reporting issues or making it known something is not intuitive to use is necessary for good development, and we require users to tell us about what they want or need to change in order to be able to fix the problems. Things won't magically turn better over time. Luckily, it's not hard to get in touch with most developers, as they are generally chronically online. This last point is not at all the case for corporate development. In that scenario, changes are led forward mostly through demands from other corporations, the advice of «experts», or silly requests from people who neither use the software nor know how technologies work.
Another important point to make is that if you want some software to become better, you need to show developers that you use and care about the software. The best way to do this is to show engagement with the software. Many people say that they are not supporting EvilCorp™ because they are downloading it for free, through piracy. In practice this still boosts their engagement, giving those companies free advertisment, and simultaneously leaving other alternatives rotting and abandoned... under the argument that «I will use the altnerative once it becomes equally good!». That won't ever happen, unless people start using those alternatives and provide constructive feedback.
First of all, stop and think about the software you use. Make a list of tools you currently use, want, and need. Do a quick search online to see which license they're using, who is developing said software, and consider if you agree with how they do things. The license used by a program is often a good pointer towards how much freedom a piece of software gives you, although reading the fine print of all the different licenses is a pain in the ass. Luckily, there are websites providing a summary of how different licenses vary. My personal summary is the following:
That said, licensing is not everything. Some corporate software might be entirely free and open source, but never listen to user feedback. Other times, the opposite might be the case. Doing this research is often hard, but luckily many FOSS enthusiasts have strong opinions, and are glad to spread their hot takes.
Now, if you realize you don't want to use some software, but need to anyway, congratulations! You're now in a position to make a change. Usually, there are alternative tools which are good enough for most use-cases, although they do require some minor or major workflow change. Finding these alternatives is often a matter of trial and error until you find some software which both feels good and also makes you productive. My go-to method for finding these things is doing an online search in the form of «foss alternative discord», checking AlternativeTo, or just asking some friends. Feel free to ask me, too.
The title of this article directly references Linux, and this is for good reason. I do not believe Microsoft Windows does anything good for the user's freedom. It seems like they make an effort to keep how the software works a secret from the rest of the world, probably because they believe that exposing the information about their internals would compromise their financial income, open plenty of rooms for exploiters to find vulnerabilities (which is a good thing, btw), expose their poor code quality, and make people steal their code for cheaper alternatives.
Furthermore, if you try to tinker with certain features of the operating system, you'll probably break something. If not right away, some update will break the system in one way or another because they never considered anyone would change some of their internal implementations. While this is entirely your own responsibility, you should still be allowed to change whatever you wanted without breaking your system. This should be a supported feature.
Linux, on the other hand, is entirely transparent in how things work. If you don't like something, you can swap it out for something you prefer. The only real limitation is your own capability, understanding of the system, and the dependencies laid out by other software you use. Tinker responsibly.
Try Linux. Seriously. We probably have whatever you might want from a computer system. There are a few things we do differently than what you're used to, but most of them are not hard to learn. On most distributions, we have a dedicated application we use to install software. The benefit of this is that everything you have installed on your system is maintained by your system, and you can guarantee the software you download is not a virus (assuming you trust your distribution's maintainers), and there is a single.
Another thing you might see from Linux is that we have plenty of options. Maybe too many, but that's a topic for another day. You might have a hard choosing which distribution to use, and which desktop environment to pick. To make it easy for you, I have compiled a tutorial on how to use Linux the smart way, and the required glossary. Find it here.
Last, I would like to say that FOSS developers, and Linux users in general are very friendly. We are used to meeting issues, and have thus developed a culture where we help each other, and asking for help is not too hard. The barrier between knowledgeable people and yourself is minimal. The only think we ask in return is that you ask the proper questions: more on «Smart Questions» by Eric Raymond on this other page.
If you're a developer, you may think Linux is a waste of time because you already have the tools you need to do your job. While that may be true, you are not at all involved with the betterment of those tools, and you often won't understand what actually happens when compiling software.
When you press the green compile button in your IDE, stuff happens. It compiles and runs your program. You probably don't know what exactly happens under the hood, or what steps are involved. You probably don't care either; and that's a bad thing. While we can't expect you or anyone to be an expert in all the levels of the stack, I believe it's fair to expect developers to at least understand which steps exist. If you're required to set up your own ecosystem, you will inevitably learn a lot more about the tools which are actually being used under the hood. Using minimal software grants you this privilege.
Related to the above point, watch this talk by Calin Leafshade: «Why even bother with Vim or Neovim in 2022?». To achieve mastery and expertice in a field, it seems to reason you should also master the tools of the trade.
The only way to become involved with the development of tools is to actually both consume AND understand the software you're using. A good developer will want to maximize their understanding of both the software they create, and the software they use. Understanding how other software works will let you reflect on which methods are better, and you can even fix bugs which annoy you or provide features you feel are missing.
To understand how software works, and participate in it, you must have the source code of the software easily available, and know how to debug your way through software you don't understand. Luckily, Linux is originally made by developers, for developers. This makes it the perfect tool to do these things. Use Linux-native tools, for bonus points. Drop your love for just-works IDEs. They are cheap shortcuts, and don't teach you anything.
Linux' ecosystem is crowdsourced. This means that we expect you to contribute, and make it better for everyone. Getting involved in things outside of your own field will make you a better developer, since you'll gain an extra experience. This may even lead you to getting a better job, or branch you off into another particular field you may enjoy more than what you had thought it would initially!
Using Linux as your daily driver, instead of just as a tool to deploy your servers on, will make you understand how to build and deploy packages for others, instead of relying on your own «it-works-on-my-machine» utopia. Furthermore, now you're responsible for delivering and maintaining the packages for your own software. Nobody wants to debug how your particular software is built. You shouldn't need to tell your users how to build it either, or which dependencies they may need. Just ready it for any package manager, and make our lives easier. After all, you already know how to build it.
I cannot stress enough how you should be delivering your packages through a distro's package manager. Stop telling end-users about build tools or dependencies. While at it, stop suggesting to install your software through pip, cargo or npm. Just stop. It pisses me off. Those tools should be used by your distro's package manager, if necessary.
¹: Using the very same tool they are developing, out of need. Often of worse quality