Why FOSS?

2025-09-20

Today, we often discuss free software in terms of license. But licenses are only a tool. A mean to an end. So what is this all of that about? What is free software for?

We could start this history in the 19th century, with the first programmer, Ada Lovelace, writing and sending computer programs for the fictional “analytical engine” imagined by Babbage. All of that sent by letter and freely shared.

Free Software

But no. Let’s skip directly to Richard Stallman, the instigator of the GNU Public License (GPL). Stallman puts it simply: “If I like a program, I must be able to share it with other people who like it”.

Reading the GNU manifesto, published in 1985, you sense a feeling of betreyal, of a territory of collaboration and friendship taken over by greed and competition.

He describes software as a common good that needs a coordinated investment strategy. He describes paying for software being similar to paying for air, that we should have a say in how software is built through a tax and a publicly controlled investment fund¹.

Cute.

So Stallman helped lauch the GPL as a way to preserve a spirit of sharing and collaboration in programming. As someone who lived through open source collaboration, and then suffered through collaboration on closed source software. I can relate very deeply.

But “spirit of collaboration” is a bit vague, the free software philosophy has the “four freedoms”, which, in short are the ability to run, understand, share and modify the software.

As a relatively isolated developer, I take for granted the ability to modify software that I run. I run Linux, and use almost exclusively open source software. I use archlinux, because it’s dead easy to patch software I get from the central repository. On my phone, I only download apps from F-droid. On the web, I take for granted ad, cookie, and cookie banner blockers.

The ability to run software that I run is almost a truism. But I’m reminded of my hundred games Steam library that could be turned off tomorrow, because of various DRM restrictions.

The ability to understand software is nice. But I’ll expand on this later.

So really, the GPL (as a license) is not what the GNU project wants. What it wants is for people to get the four freedoms.

Open Source

I’ve started using “Open source” (OSS) without really introducing the word. “Open source” is an expression from 1998. It’s almost the same as Free software. In fact, the criteria to call a license “open source” is derived from the Debian “Social Contract”, which itself is derived from the four freedoms.

But on a cultural level, OSS tries to promote free licenses in themselves, rather than a mean to get the four freedoms. This allows OSS advocates to promote the collaboration model to large private companies. Why does that matter? Listen, if you go to Microsoft and pitch “the free sharing of software and a solidaristic union against private software companies”, you are welcome, but don’t expect the warmest reaction.

In my time working on software outside of private institutions, I only worked on OSS. Why? It’s not an ideological preference, but a practical one: I know rust, and most rust projects abide by OSS ideas rather than free software.

There is an historical reason for this: rust was made at Mozilla, which was born as a Netscape project. Netscape having a $10B market capitalization, it certainly wasn’t to keen on the “we need to fight software companies” discourse around free software.

There is more to it, and it relates to the questions of how to best organize a society. I wrote about it in another blog post.

So it’s worth repeating: the license, from starting as a mean for software freedom, became a goal in itself of Open Source. I’ve already said a few things about the danger of mixing goals and means.

How to collaborate on the internet?

Fostering collaboration and reciprocal sharing of ideas is the goal of both the OSS and Free software movements.

But what does that collaboration look like in practice?

As a reminder, the four freedoms are: the abilities to run, understand, modify, and share the software.

Let’s focus a bit more on understanding and modifying software.

Building software today is a very complicated matter. You have to familiarize yourself with a variety of tools and how they work. For Python, you need to interact with: a file system, an interpreter, bytecode, packaging dependencies, OSes, a text editor etc. And that’s only for a terminal app! What about a webserver? You have to understand what’s the internet, server daemon, the distinction between a server and a client etc.

It’s a shit ton of knowledge that goes as a given for someone with a few years of experience, but is a very painful and daunting mountain of unknowns for someone who is just starting. I still remember how confused I was when I first encountered async (what do you mean, you need a pool of threads?!). Now, it’s second nature.

A Free software license doesn’t magically inculcate people with the knowledge of how to modify the software.

If the end goal is self-governance, the ability for users to control the rules under which they interact, we need to take into account more than just the license.

There are two ways of approaching the matter:

1. Organizing the project around users as programmers (upstream-driven). Especially relevant for software libraries. The goal is to make the code base as accessible as possible to new developers, making heavy use of CI to manage processes they may not be familiar with, spaces where already proficient contributors can help newcomers, amazing documentation, etc.
2. Software as an empowering structure (modding). Emacs here is the model. There is a complex, minimized core, and the software is built as extensions. The shell is heavily documented, and can be modified trivially (even without development tools) by the end-users. Modifying the software is actually how you use the software. When you are satisfied with your modification, you can share it with the community, and maybe it can be integrated upstream. This can become an on-ramp to contribution to people who wouldn’t consider themselves programmers. It works both as a teaching tool to use computers in general, and a tool to do the useful work the software enables.

The truth is that (1) is an extension of (2) with more focus on human relationships. But (2) is such a beautiful and compelling picture of computing that I cannot discard it.

I personally believe that there is an inordinate amount of artificial complexity in software developments. That the barriers to entry are artificial and there is a world of computing out there where everybody naturally becomes a programmer. A world where software would be designed in such a way that people would naturally ramp up in competency as they use the computer. Probably I watched one too many Alan Kay keynote.

Those barriers in software grew out of the professionalization of software development. Since people were paid to work exclusively on coding, they could afford to add complex tools to their process, that requires a lot of ramp up to understand. Helplessness before a computer screen is not a fatality, it is the result of the contigency of history.

A more limited coding process, that has to rely more heavily on user collaboration would develop a completely different set of tools that gives much more power to users.

Existing governance of OSS projects

Now that you know my deep disatisfaction with software in general, and how we are missing an amazing world of complete user ownership of computers, let’s talk about how OSS projects work today.

An excellent entrypoint is the Foss & Craft episode on Open Source governance.

The Lemmer-Webbers describe the various resources required to make an OSS project work. It includes hardware, developers and money in general.

The source code is a freely accessible resource, and the project is an institution (a set of rules) which purpose is to sustain that resource, by creating relationships between people.

Free software and Open source give the wrong idea. The focus of a software project are the people who use and contribute to the software, and not the software itself. A software in itself is as useful as a lawnmower without someone to use it.

The health of a software project is entirely dependent on the institutions surrounding it. Take for example OpenOffice. This is a complex project with an history that link back to Sun Microsystems. But enough history for now.

OpenOffice, once bought by Oracle, stopped being developped. The maintainers stopped accepting new contributions. So what happens is a “fork”. Some people took the source code, rebranded everything as “LibreOffice” and created new institutions around the same code. They accepted new code contributions and fixed bugs.

Elinor Ostrom theorized the concept of Commons. She gave a few outlines about how a self-governed institution that work to keep a common resource sustainable can itself persist.

One of them is recognition by higher authorities. Indeed, as soon as you are illegal, you won’t be for long. Ostrom gives the example of self-managed fisheries in Atlantic Canada that got destroyed by the government. A Free license is the guarentee that a fork will always have a legal existance.

In fact, going down Ostrom’s rules for a healthy Common, I don’t see what else a license is good for for the health of an OSS project.

All the other “design principles” are addressed by a Code of Conduct and a good governance model (discuted in the Foss & Craft podcast I linked earlier).

Software is strictly about people. FOSS doesn’t understand what it wants to be about. Fundamentally, it’s about the right of people to have a say in the rules that affect them. It’s about self-governance, about democracy.

And a simple software license is neither necessary or sufficient to ensure a democratic control over software. We need a society that aknowledge the right of people to self-determination. We need the institutions around the software projects that give the users the power to change the instructions the machine runs, but also the rules of the institutions themselves.

We need computer users that are not mere spectators and passive reciever of the computer’s work, but are actors and creator of the systems the computer run.

Kant criticized a specialized society where as individual, you are a mere receiver of service: you go to the hair dresser, you go to the shoemaker. You are like a child surrounded by people that does the important work for you. We don’t want computers that treat us as children. We are adults, capable of taking part in the things that affect us. And if we want to live in a mature society of responsible adults, we need to give people the power to affect computers.