FOSS isn’t capitalism
It’s storytime children. Once upon a time there were no personal computers. All the electronic computers (going forward simply “computers”) were big and expensive and as such were owned by corporations, universities or the government. If you wanted to use one, you had to get permission and share. That changed around 1970 with the invention of the microprocessor. Intended for use in calculators, some creative hackers used them to build programmable “microcomputers” for a fraction of the cost of any existing “real” computer. Having an entire computer to yourself (even if it wasn’t very powerful) made it a lot easier to learn how to use it. Back then “using” a computer meant programming it first, so these early hackers started building tools to make programming easier and shared the programs they wrote with one another. Eventually this lead to most personal computers having the BASIC programming language built-in. As companies began to make and sell these microcomputers, people bought them with the expectation that they could program them to do whatever they needed them to do, and the programs they wrote in BASIC were more-or-less portable between machines even if they were made by different companies and used different hardware. This is the era in which I learned to program. It was a very exciting time because for me, software was the first thing I could build that didn’t require consumable (and therefore costly) supplies. The versatility of a general-purpose computer that you had all to yourself seemed infinite, and I learned everything I could about my machine. At the same time there were plenty of people who were writing software who wouldn’t consider themselves programmers. These were people who ran small businesses, hotels, cleaning services, automobile service garages, etc. who for one reason or another saw how they might make their jobs easier or better by buying a computer and writing a program to automate their work. You still come across these machines occasionally in the wild and in most cases they are plugging-away at whatever task their owners originally programmed them for. In those days I might have a conversation with one of these people (typically adults who were friends with my parents) about a program they were working on or to share something I was experimenting with. We could have a conversation about the technology in the context of what they actually were going to do with it as opposed to obscure details about the machine itself. In many public schools students were required to take computer classes and learn how to program as an introductory course. However something went very wrong shortly after this. The generation who grew-up programming their own computers figured out that they could sell the software they wrote, and the harder it was to write the software, the more money they could make selling it. So instead of finding ways to make it easier for regular people to write their own software, they made it harder. This disenfranchised so many people that eventually personal computers stopped shipping with any programming languages at all, and users came to accept their role as consumers of software written by “programmers” who were of course very smart and knew much more than the users did. I would argue that this was a “dark ages”-level event. The potential I saw in computers wasn’t that it could make another stripe of “experts” rich, it was that with the advent of the personal computer the power of writing software could be experienced by everyone, and as such new and exciting applications for computers would spring-up all over the place. As the 1980’s drew to a close the diversity of applications for personal computers shrank, only occasionally expanding when some new threshold of hardware performance was reached. There were of course some who operated outside of this mainstream and who saw the potential for the personal computer being squandered. These individuals, these “hackers” are where free and open source software (FOSS) emerged which was seen by people like me as a path back to a time when the power of personal computers was in the hands of their owners. But we didn’t quite make it back. By the time that usable open-source systems became available, most users had been convinced that you had to be a professional programmer to write software for a computer. To a degree this was correct, because the tools and languages used by open-source developers had become specialized and nothing as accessible as the BASIC of old existed any longer. So while FOSS made it theoretically possible for users to create and modify their own software, there was both a psychological and skills gap that make this impractical for most users. When the web came along there was a brief moment of hope that this new platform might be as accessible and compatible as the microcomputer of old, but it was quickly comoditized by commercial interests and followed the same path as all previous software, devolving into a labyrinth of specialists tools and “languages” in an endless parade of “fashionable” platforms, frameworks, etc. Now we find ourselves in a state where criticisms of FOSS are trying to convince users they are better served by commercial, proprietary software. This isn’t because of something inherent in FOSS itself, but due to the fact that we haven’t succeeded in making the FOSS solution accessible to all users. The implication is that this is something FOSS developers desire, to leverage their skill to wield power over the users of their software. I don’t think this is true in general, but I can see how it might appear that way. Most of the FOSS developers I’ve met are selfless and write the software that they want or need. If it proves useful to others they will accommodate those users requests within the limits of their resources and/or desire to continue working on the software. These developers are rarely paid for this work, and often do it at significant personal expense. I don’t think they are out to stick-it to users or capture and amass power as is the design of capitalism. That said I believe that we’ve failed to fulfill the freedoms afforded by free software by not finding ways to make creating and modifying the software more accessible. For this we deserve some condemnation. Some of us may not agree with this, but driving users back into the arms of proprietary software isn’t good for any of us, so it is in our best interest to address this problem, and I think the best way to do so is to pour some engineering skills into empowering everyone to write the software they need, without having to become a “programmer”.