Freedom in Open Source

I've watched the open source world from a bit of a distance over the last 20 years while learning to code and getting paid doing it (the first project I put out there, BackuPod, was uploaded to SourceForge in 2007, I was a novice Python programmer.)

To me it seemed like the conversation at the time was dominated by people like Richard Stallman and his ideas about software freedom. It was all about the developer's freedom to see the code, change it, and share it. It was a powerful statement against proprietary software, supportive of hackerdom and the natural urge to tinker with things. Then you had Eric S. Raymond talking about the "bazaar" model, where all these individual developers working on their own things would somehow create something amazing. I didn't really understand all this exactly back then, but what drew me to the idea was this focus on the creator's liberty and ability (or even expectation) on the user to know what they're using well enough and to be able to adjust it if they want, even if in a minimal way. The freedom was for the developer to build what they wanted, not necessarily to serve a massive userbase, but also for the userbase to feel like they're not stuck using whatever the developer wanted them to use or do on their machines.

But as I progressed and learned more, open source appeared like an exclusive club with its own language and rules, and I never really broke in. I've contributed a patch here and there, felt happy about getting praised publically, used countless libraries of course, and dontated money to support those I used most, but I never became a "maintainer" or a core part of any project, and non of my open source projects drew a lot of attention. And honestly, looking at the state of things today, I'm pretty happy that things turned out this way.

The whole dynamic between the freedom of the creator and the duty to the user has become a real mess. This individualistic spirit is still there in a lot of projects but it's getting crushed under the weight of modern expectations.

It might seem strange but I think what happened (and sort of the origin of the problem) is that open source won. It's not a niche hobby anymore. It's a fundamental infrastructure piece of the entire global tech economy. The Linux kernel, Apache, Python, and a random JavaScript library you've never heard of power a million websites. Corporations, governments, everyone depends on this stuff. And that dependency has created a strange shift in perception. Users start to see these projects not as a gift from a stranger but as a product. They treat it like commercial software and expect commercial-level support, reliability, and a roadmap that suits their needs. This created a perceived obligation to serve, which was never part of the original deal as I see it.

The first thing this directly led to is the maintainer's burden. Most of these projects are run by one person (or a tiny team) in their spare time. They're not getting paid, or if they are it's not much. They carry the costs, the time spent debugging, the mental energy of planning new features, and the emotional toll of dealing with the public (good or bad comments). I've seen issue trackers that would make your skin crawl. The constant stream of demands, the entitlement, the pressure to add some feature that only one company needs. I personally can't imagine dealing with large projects like this without burning out. And when a maintainer finally puts their foot down and says "no", they get backlash. They're called rude, or a gatekeeper for simply exercising the very autonomy that open source was supposed to be about. I think those who do maintain large projects and still seem sane have somehow managed to luck out into walking the fine line, but who knows maybe there are a few with a secret process that worked for them.

Part of the problem is this myth of the "community". We talk about the open source community as if it's some kind of democracy where everyone gets a vote, some utopia where people are somehow friends just because they both use Rust or Python. Back when I was doing a lot of Python on daily basis, I never felt part of the community and it always rubbed me the wrong way when I see people talk about it online. Most projects are a benevolent dictatorship or an oligarchy. One person or a small group makes the final call. But the collaborative rhetoric, all the talk about "getting involved" and "contributions welcome", gives users a sense of entitlement I think. They feel if they open an issue they deserve a dialogue, that their feature request should be seriously debated. They don't see the hundred other users making competing demands, or the fact that the maintainer's vision for the project might just be different from theirs, or that they could just be wrong (this topic might deserve a post on its own). And now of course with AI and LLM-generated code, there's an increasing number of patches and security-reports that are all fake or entirely LLM generated, wasting maintainers time, and there's also a decent amount of new "projects" that are: open source, from afar seem like they're something decent and useful, have nice READMEs and CI badges, 100% test coverage, etc... but are actually just junk and half-assed ideas someone auto generated to flex some muscle. The world of open source development and programming also suffered the popularity of attention economy, people treating themselves as brands and trying to get their name out their any way they can to carve themselves a slice of attention people give to things online, with zero fucks given about the quality of what they're doing.

Of course there's a whole spectrum of governance models trying to deal with this. You have the classic benevolent dictator for life like Linus Torvalds with the kernel, and then you have more consensus-driven projects like Debian. Some new ones will probably be needed for the LLM era (if it lasts). But for the vast majority of small or medium sized projects there is no formal governance. The decisions will be made on the fly, which will just lead to more conflict. Some projects try to manage this with strict contributor guidelines, but the attempt to reach a balance feels like we've already given up on the original meaning of open-source imho.

Not to be too negative, but I don't think there's a fix here really. The way things are going, I think we'll inevitably see a more fragile software supply chain, where progress is dictated by corporate funding and not individual creativity, which is sad because it'll push the ecosystem back towards a more centralized, commercially-controlled model that the free software movement originally fought against, but who knows.