Yesterday I had spent a few hours trying to fix a broken update of Discourse on a VM controlled by our Hackerspace. What was meant to be a five-minutes update turned out involve rolling back, restoring updates and feeling as powerless and pissed off as one can feel when exposed to unintuitive software. It was actually so bad that we felt like breaking our rule of not self-hosting as much as possible and just paying up the developers their single-time $150 fee for hosting. And then I had the epiphany… if we did that, it would be less of a free software. I guess that means that the incentives are somewhat broken.
Hacker culture is a gift culture. You join it feeling overwhelmed with gratitude and slowly learn to pay at least a bit of the goodness forward. Criticizing things has always been pretty tough and in a gift culture, people are often taught to prefer praise over it. Obviously, hackers also love shiny things and those two things combined lead us to a constant chase of whatever seems to promise an improvement, even if it’s not self-evident. While many projects are an actual step forward, sometimes I feel that we take an unconscious step back by fixing on things that are “good enough” and not using our full potential. After all, it IS some improvement, right?
I’m afraid of large projects. While appreciate the great software I’m currently using – writing this post through a Firefox browser to a WordPress blog, all that hosted by Linux on both ends – I know that I might never get into the mindset of whoever maintains those things. I understand that complexity is impossible to avoid, it’s just that I’m afraid that it might be impossible to continue those projects over when people like Linus Torvalds die. And if there’s a serious FLOSS contender in that space, it’ll just means that it will be taken over, but if not – it will be a slow deterioration of the project caused by lack of proper maintenance, as used to be the case with Firefox back before Servo revolution. Market is then lost and proprietary (or semi-proprietary, like Google Chrome) solutions take over. I see that as a net loss.
This is why even though some aspects of a given project might be more important than others, I have this intuition that severely neglecting any of them can make the project deteriorate. Let’s come back to Discourse as an example. It’s an open source bulletin board engine with UX much better than any FLOSS alternative I could see. Thing is, it broke in our case. When it did, I realized that it was hosted in a way that’s not supported and the reason why we did it that way was that the official way was, to put it lightly, batshit insane. Then I dug around for the reasons for this insanity and found a post predating docker-compose era, which explained the reasoning. I do understand that technical debt sometimes needs to be incurred, but a few years passed and the only actual solutions are unsupported. Which leads me to my point: if the maintainers collect money for development thanks to the complexity of self-hosting, what incentives do they have to pay up that debt? And if they won’t, can we still call it free software?
I’d like to use this rant as a pretext for a discussion on large, impossible-to-fork monoliths. We lose hacker brainpower to re-fixing the same problems all over again, if we can’t collaborate on improving deployment of our discussion boards. Back when Github appeared, hosting all our projects, we felt like it was a gift. Now I feel that it’s a bit of a trojan horse, where “forking” actually means “a clean slate with the source code copied”, not “you’re your own maintainer now”. My idea of a solution would be adapting something like Gentoo’s ebuilds, with a quick way of switching Git repositories and still being able to build the thing with its dependencies. Forking projects in a way that copies issues and pull/merge requests, so that an average Joe can faster try out other people’s patches. Democratizing development a bit more, instead of favoring opinionated leaders.
And what do you think? Do you agree that there’s a problem and I identified it correctly? Do you think that the solution would actually be a step in the good direction? And regardless, how could we slowly start migrating into a future where it’s us that pick the features, not the multi-billion VCs that currently depend on us to grow? Let’s discuss this on a Hacker News thread, so that most of the discussion happens in one place.