If you look at contemporary programming, I don’t think we have properly understood the social damage that our coding culture has already done, and is still doing. We have built enormous parts of modern life out of software, while pretending that software is somehow separate from society. It isn’t, code structures how we communicate, what we can see, who can participate, what gets remembered, what gets deleted, who gets heard and who gets ignored. And much of contemporary programming culture has a deeply contradictory relationship with this power.
In theory, the culture talks like anarchism: decentralisation, freedom, hacking, autonomy, permissionless innovation, open protocols. In practice, the resulting infrastructure feels closer to an authoritarian bureaucracy: rigid hierarchies, centralised control, surveillance, locked-down permissions, opaque decision-making and an almost obsessive belief that more control and more security will produce a safer society. This is part of the #geekproblem.
Closed systems hide power – in a #closed system, the monsters can operate without being easily seen. They can plot, manipulate, divide and control because the surrounding community cannot properly see what is happening. There is no shared social process for checking the claims being made or comparing them against what everyone else can see.
You cannot easily create social “truth” inside a closed system, you can have an official truth, corporate truth, an algorithmically manufactured truth. You can have whatever the people controlling the system want you to believe. But social truth is different, it emerges from people being able to see, question, compare, remember and challenge what is happening, that is one of the powerful things about #open. With genuinely open systems, the monster becomes more obvious. It becomes easier to see the relationships, the decisions, the contradictions and the consequences.
It becomes easier for other people to say – hang on, that’s not what happened – open systems don’t magically prevent abuse, they don’t make people good, but they make some forms of abuse harder to hide. Closed breeds monsters. Open pushes them out of the shadows where they can be seen.
The security paradox – this is where programming culture gets particularly strange. The demand for control and security is to often presented as neutral engineering. We are told that systems need permissions, authentication, central administration, surveillance and increasingly complex layers of security because the world is dangerous.
Of course some security is necessary, but when security becomes the organising principle of the whole system, something changes, the technology begins to reproduce the social assumptions of its creators. People become permissions, communities become accounts, relationships become access-control lists, trust becomes authentication and thus social problems become technical problems. Uncertainty becomes something that must be eliminated rather than something that society needs to learn to live with – this produces systems that are technically impressive but socially impoverished.
The fantasy of perfect control is a deeper problem here. We keep trying to build technology that removes mess, but human society is messy. People disagree, misunderstand each other, change their minds. Communities develop traditions as different groups have different needs. Sometimes things fail or somebody has a better idea, that isn’t necessarily a bug, it is social life. The #geekproblem treats this mess as something that technology should solve. The result, an endless attempt to build cleaner abstractions over increasingly complicated social realities. But the cleaner the technical abstraction becomes, the more human reality gets pushed outside the closeing system.
Then the system becomes brittle, and when it breaks, everyone is surprised. Code should be allowed to be messy – this doesn’t mean writing bad code. It means recognising that good social technology cannot be based on the fantasy of perfect control. We need systems that accommodate disagreement, forks, experiments, mistakes, local variation, negotiation and repair. In that sense, code should be a little bit messy, because society is messy. The goal isn’t to eliminate the mess, it is to create structures that help us live with it. That is different from the programming culture of trying to close every possible hole, define every possible behaviour and control every possible interaction.
#OPEN is a direction, not an endpoint – there is also a danger in treating #open as another purity project. Yes, the #openweb isn’t automatically good as open systems can contain abuse, misinformation, exclusion and power games. The #openweb itself contains plenty of contradictions. The #dotcons have their own versions of “openness”, often while retaining enormous concentrations of corporate power. So this isn’t a simple story of good open people versus bad closed people, more a balancing process.
#OPEN is a way to step away from #CLOSED – it creates space for transparency, plurality, experimentation and social accountability, gives communities more opportunities to see what is happening and to build alternatives. And that matters because we are currently living inside an enormous pile of inherited closed #techshit – closed platforms, closed data, closed algorithms, closed governance, closed infrastructures and assumptions about what technology is supposed to do. As a first step we need to compost a lot of this closed crap.
The mistake, we make to often today, is that we believe that we can build the perfect open system and finally end the struggle, we can’t, and we shouldn’t. There is no final technical architecture for society. There is no perfect governance model, no moment when we finally solve disagreement, power or human contradiction. Anyone promising that is either selling something, hiding something, or has fallen deeply into the #geekproblem.
The point is not to end the mess, it is to keep the mess visible, social and negotiable. We need technology that leaves room for people to challenge each other, organise, experiment, repair and move in different directions. That is why the #OMN work matters – to build practical #openweb infrastructure where media, metadata, moderation, governance and community relationships can remain visible, shared and contestable.
To make this happen we need #4opens starting points, #OGB experiments with governance, #MakingHistory to keep collective memory alive and #IndymediaBack to remember what grassroots media learned before the current wave of #dotcons.
