Some of you might have heard the phrase “corporations don’t want to make money, they want to make all the money” (I think I heard it first from James Stephanie Sterling talking about video game publishers). This thinking is a bit of a companion thought to the delusion that within a limited system such as this planet infinite (economic) growth is possible. Especially when applied to digital systems those two thoughts combine into a weird idea, nay ideology of scale: Everything needs to become a Unicorn (a startup valued over a billion USD), everything needs to go global scale, or at least aim to go global scale.
The Engineer
Some of you might know that I am formally an engineer (in Germany computer science is seen as an engineering discipline and a lot of the teaching leans on ideas from other parts of engineering). Good engineers – and I am not claiming to be a good engineer – have a some very admirable abilities: The ability to really drill down on a problem to understand its core properties, the actual issues that need solving and the ability to put those requirements and goals into writing for other engineers to evaluate, criticise and improve. A good engineer is well informed about what’s out there or is capable to do effective research trying to find existing solutions that either solve the whole or at least significant parts of the problem at hand. Because a good engineer is lazy: You don’t build something yourself if a good and well tested solution exists that fullfills your requirements. You take that thing and just add what’s still needed.
But engineering also has this drive to formalize, standardize and “do things proper”: The term “overengineered” is sometimes used for systems where the amount of work that the engineers put into the design and test, and maybe even the complexity of the system itself don’t seem – from the outside – appropriate for the issue at hand. The engineers in question will 100% be able to explain to you why they made those decisions but from the outside it might still look a bit over the top: “This piece will stay in shape at 250°C” is cool but it’s a thing to boil water in so maybe going for 110°C would be fine? (For my US readers: Water boils at 100°C)
We’ve gained a lot of knowledge, best practices and software libraries and tools to build increasingly big software and hardware systems in the last decades. Even early startups often have to deal with tens, if not hundreds of thousands of users and that’s not going into the truly global scale that some IT giants have: Google/Alphabet, Meta/Facebook/Instagram have literally millions of people trying to use their services at the same time. That scale brings with it massive challenges and we’ve had a lot of engineering going into that (also some random hacking, but let’s not be nitpicky here): Engineers have learned how to do scale.
Scaling up
As the introduction has already shown, in our current system this makes total sense: Because you need to become the one company for a thing. The central social media platform, the shopping platform, the whatever. Even startups adopt the practices and methods of bigger cooperation – because that’s their aspiration: Becoming the next Goomazonbook.
That’s how their engineers are trained, that’s what the zoo of freely available training materials are teaching: This is how to build for scale, this is what the 6 figure tech job will require from you.
Now I care more about the people working on FLOSS (free, libre, open source software) because that is where I am looking for our future infrastructures: Not to companies whose leader bend the knee to fascists cause they don’t want to pay taxes but to projects that might help us as individuals but more importantly as groups and communities to create digital infrastructures and spaces beyond capitalist exploitation. But the people building FLOSS are often the same people who either work or worked in big tech: Highly skilled, well versed in all kinds of complex technologies and infrastructures. The got scale in their bones.
Scale has a tendency to bleed into all aspects of a system you design. Many things that have very simple solutions on first glance become massively complex when scaling up: Just think about the switch from one database server to a cluster of databases. Having one server you know it has “your truth”, it is the materialisation of your data. But if you have a cluster of servers talking to one another issues emerge: They might not be fully synchronized yet so one server has a different set of data than the others, getting a data write propagated everywhere can be expensive, etc. We know how to scale but it’s often way more complex than people who don’t build software think. Because a lot of the issues you run into have nothing to do with the thing you actually want to do but with nasty things like physics and time.
And we see that in many FLOSS projects. The idea of “potentially scaling up” is so deeply embedded in “engineering thinking” that it’s hard to break with. And sometimes it is important, sometimes scaling is the requirement (think database servers or a lot of other infrastructure work).
But scale comes with costs.
Rigid dynamism
In order to build things that scale you inherently create increased complexity: You system needs to deal with potentially running certain system aspects on different machines for example and taking care of the required synchronization etc. This makes systems often a lot less malleable, a lot harder to work on and change.
Because everyone who wants to experiment with a new feature, wants to add something has to interact with all the complexity, has to deal with things that are easy in a small prototype becoming very hard in a bigger system.
Which is in a bit of a conflict with the way we build scalable systems these days: All the complexity is supposed to allow you do dynamically add or remove resources as needed. Just automatically add another server instance of the load goes up, power them down when things calm down. It’s how Amazon and Google do it™. How the professionals do it.
And you need that professionalism to scale.
But increasingly I feel how that locks us into logics that are not very humane. We are throwing out requirements in favor of scale.
The global village
The global village is one of the myths stemming from the beginning of the mainstream Internet age. The idea is that by connecting everyone we’d all live together in one digitally mediated space or as the Declaration of the Independence of Cyberspace says “the new home of the mind”. Scale looks like a thing required for the global village: If you want to build something everyone is on, you can either do a Facebook (everyone on one platform) or you do a distributed thing (think email, federated social media, etc.). But if you do in distributedly, you need to establish standards so the data stays compatible: All systems speak the same language, use the same (using Bluesky’s ATproto term) lexicon.
But I don’t think the people who propose this kind of thinking know how villages work. Having grown up in them things look off: A core part of villages is having a community (even if it is forced upon you by living in proximity of one another) of people who know each other. Of course not everyone knows everyone but there is a high degree of familiarity by being in the same church or club or seeing one another at the local shop. There are conflicts and differences of opinion within villages but there also is a degree of shared interest (in having certain infrastructures for example). Is that true for the global village?
Like you can’t know too many people. Something between 100 and 250 probably. While that allows a village some cohesion applying that to a few billion – heck even just a few hundred thousand doesn’t scale up well.
Also you don’t have too many shared political/social goals because you lived reality is very different. The global village ends up being a huge place where nobody knows anyone and it’s really a lot of yelling about shit that doesn’t make sense to others.
Finally, when people propose the global village they never say where that village is (as in which legislation applies): Is in in China? In the EU? In the US? In Egypt? Russia? (Of course that question isn’t asked because a lot of our theories and thinking about the digital is deeply libertarian and anti-state but that’s another post.) Who gets to decide what’s allowed in the global village? And who make that decision? I surely wasn’t asked.
Everyone looks the same!
I help running a small mastodon server. It’s a place where you cannot just get an account: The server has a certain leaning, it’s for people somewhere in the space between internet theory and media art with a bit of an activist bend. This is intentional.
Because we are trying to create a place that has a certain set of shared interests and values. Something where even if you might not know everyone you can quickly connect with them on certain topics. Calling it a community might be a bit of a strong word but it could become one.
The server isn’t locked down, we can talk to the whole world but the server itself has its policies and rules and practices. And this experience has made me think about another consequence of the ideology of scale: Homogenity.
I just described how our Mastodon server has a degree of shared interest and maybe even values which also has a bit of a homogenizing effect: People tend to be a bit academic, a bit interested in tech and (and I mean that in a positive way) a bit weird. But that’s not the homogenity I mean.
Scaling a network of Mastodon instances up is easier than getting a bunch of different pieces of software to play well together. The Fediverse is build upon a bunch of different software projects but they all stick to the same protocol and – especially with Mastodon being the Gorilla in the room – kinda adapt to each other’s ideosyncracies. Which is annoying and takes a lot of work but it’s what you need to do to make things work well, reduce friction. Scale the whole network up.
But are we the same? Are our communities that similar? Our needs and wants? While protocols are great for building robust and scalable systems, they also make it a lot harder to play. To use the digital as a plastic material that you can shape around what your specific community wants and needs.
Building weird shit
I am very old. So I still know the time when people were running PHPBB forum instances a lot. For their gamer clan, their association, their community. And there was a vibrant culture of just adding little pieces of code to your instance (often times some code you just copied from somewhere without fully understanding it) that changed something. Often in very ridiculous ways. Adding bogus icons to people’s names because of a thing they did at some point. Getting their mostly used word from the database and displaying that. Weird things. Dumb things. Beautiful things.
Now that’s not how to run very secure platforms and surely PHPBB is not (it might be today, no idea) part of a decentralized network building the Forumiverse or whatever. But I think that there is still something we lost in our attempts to build professional, scaling solutions.
I do think it’s sad that every Mastodon server looks basically the same. Sure, different team, different logo, different rules but all works “like Twitter used to”. There’s very little experimentation with weird stuff (sure, there are some forks adding stuff like glitch-soc for example) with communities actually making things their own. And that does come I think a bit from the idea of scaling: You can’t do weird stuff to your posts, it might look weird on other instances. It’s hard to add features to a Mastodon server because it’s built to run huge servers like mastodon.social with all the tradeoffs that brings.
(I’m not hating on Mastodon here, it works for the goals the project has. I just think that as people who think that the Internet, our digital lives are important “copying some commercial service 100% but this time in open source” isn’t always in our best interest.)
Anti-Scale
As people interested in a vibrant, humane, life-affirming social web I think we need to break the rut. And our very well built solutions are tying us down a bit too much I fear. When building for others we need to think less about “building the one right solution that everyone can use” but about building a thing that works for a specific set of people or that allows a community to actually change things in structural ways to serve their needs and wants, their practices and in-jokes.
I think we should think less about scaling our systems up perfectly and as frictionless as possible but about making the digital space more heterogenous, more weird. We shouldn’t try to pretend “this is Facebook but better for reasons you don’t care about” but build something that’s more of a “yeah Facebook wouldn’t allow this but we build this weird community where you can only post by using at least 3 swear words and a donkey image”.
The smooth, perfect, global village-implementing platforms of the global corporations are just malls, non-places not build for humans but for advertising space and AI bots talking to one another.
Liberation doesn’t just come from opening up source codes and putting open licenses on stuff. It comes from the belief that the Internet should be as weird as we all are. Because you all are fucking maniacs. And I love it.
Liked it? Take a second to support tante on Patreon!
This work is licensed under a Creative Commons Attribution-ShareAlike 4.0 International License.