Tag: eekproblem

Power, the social cost we keep talking past in #FOSS

A post sparked Hacker News spouting of noise and smoke. It looks like “just fork it.” phrase in #FOSS culture provokes heat. So worth a second look, for some it’s the purest expression of freedom, to others, it’s a conversation-stopper that quietly protects power. What’s striking isn’t that one side is right and the other wrong, it’s that people are too often talking about entirely different things, while using overlapping words, thus the smoke and heat in the linked discussion above.

It’s worth a little time to look at this issue. The pro-fork view is about permissionless agency. From the classic #Geekproblem perspective, “just fork it” is not an insult or a dismissal, it’s a reminder of where power actually lies. The arguments, often bad-tempered, go like this: Open source removes the need for permission, maintainers are not obligated to implement anyone else’s ideas, if you want something different, you can do the work yourself, forks are non-hostile, temporary, and often merge back.

In this view, forking is not fragmentation, it’s pressure relief, to protects maintainers from entitlement, unpaid labour demands, and endless arguments over direction. It’s also what makes #FOSS resilient: even if a maintainer disappears or a project takes a turn you dislike, the code remains usable.

For libraries, tools, and infrastructure components, this works remarkably well. Many developers maintain private forks, carry patches for clients, or experiment freely without any intention of creating a new community. No drama, no schism, no ideology “mess”, just work. From this “native” angle, criticism of “just fork it” sounds like a demand for obligation where none exists.

The counterpoint is that forks aren’t free in social systems, the critique isn’t only about forking code, everyone agrees that’s normal, healthy, and foundational. The tension is when “just fork it” is applied to social platforms, protocols, and shared infrastructure, systems where the software is only a small part of the project.

Running a fork as a new public project isn’t only technical work, it needs: attracting users, building trust, maintaining governance, handling conflict, sustaining moderation and care and thus carrying long-term responsibility. This is where the phrase starts to feel different, in these contexts, “just fork it” is heard not as empowerment, but as exit over engagement, a way to avoid dealing with governance failures, power asymmetries, or unresolved social conflicts inside an existing social project.

From a social #OMN perspective, this isn’t neutral, forking risks: splitting attention, duplicating effort, losing shared history, weakening already fragile commons. Forking may preserve freedom, but it can still destroy value. Forks vs schisms is maybe a way to look at this:

  • forks – technical divergence
  • schisms – social rupture

You can fork without a schism, but every schism requires a fork. Many arguments talk past each other on this, because one side is defending the right to fork, while the other is warning about the cost of schisms. These are related, but not identical. Power, ownership, and stewardship, are fault lines about how people understand authority.

  • One view holds that open source projects are a #feudalistic kingship – benevolent or not – and contributors knowingly accept this. Maintainers owe nothing, forking is the safety valve.
  • The opposing view sees projects as commons built from collective labour where maintainers are stewards rather than owners, carrying responsibilities that go beyond “my repo, my rules.”

Neither position is imaginary, both exist in the wild. The conflict arises when a project quietly shifts from one model to the other without naming it.

Why this matters for OMN-style projects, they are explicitly social, federated, and historical, they depend on: continuity, shared narrative, visible governance, memory. In this context, common sense “just fork it” instincts unintentionally reinforce the problems #4open paths are meant to solve: fragmentation, invisibility of power, and loss of collective learning.

That doesn’t mean maintainers owe endless emotional labour It does mean that governance and mediation matter as much as code, and can’t be solved by technical exits alone. Two truths at once, the debate becomes clearer if we hold these two truths together:

  • No one owes you unpaid labour, forking is a legitimate, necessary protection for maintainers.
  • Social infrastructure is not just software, treating forks as cost-free exits erodes shared commons over time.

When people argue past each other, it’s usually because they’re defending one truth while denying the other. This creates mess, social mess. So to compost this mess, we need to understand better where this leaves us, “Just fork it” is neither a delusion nor a universal solution, it is:

  • healthy in libraries and tools
  • essential as a last resort
  • dangerous as a reflex
  • corrosive when used to silence governance questions

The real work – the hard, unglamorous part – is knowing which situation you’re in, and being honest about the social costs of the choices you make. That’s not a technical problem, it’s a cultural one, best not to be a prat about this.

This matters because we have social problems created by tech intolerances, #blocking culture. The #dotcons industry’s ability to pull the ladder up behind itself should not be underestimated.

We’ve created digital systems so complex, fragile, and professionally gated that an entire generation is being locked out of owning and understanding their own tools. Communities and people should be able to run their own services, control their own data, and participate meaningfully in digital culture, but few can, because we made everything unnecessarily controlled and complicated.

This wasn’t an accident, it’s a part of the #eekproblem, complexity concentrates power, it creates dependency on experts, platforms, and the corporations that have been quietly erasing the possibility of autonomy. What once required curiosity and modest effort now demands specialist knowledge, constant updates, and institutional backing. The result is a widening gap between those who can build and control systems, and those who are forced to rent/beg access to them.

This is why #KISS simplicity matters, why documentation matters and most importantly why social tooling matters as much as code. And why the #openweb was always about people, not only protocols. When we ignore this, we don’t just lose users, we lose a generation’s ability to imagine, agency, and collective control in the first place.

It’s a real mess we need to compost.

The stubborn few who show up with shovels, laptops, and trust

In the tech world of social change and challenge, we’re living with a strange imbalance. Too often, the spaces we use and try and build are crowded with useless, self-destructive prats – people more interested in ego, control, and clout than in making anything grow from the roots. And when they do very rearly act, their “help” is often poison: it blocks, slows, and derails.

At the same time, the number of people doing truly useful, collective, grounded work feels small. You can see this in every grassroots project, tech or activism, whether it’s, coding radical #FOSS projects, building alternative media, running servers, or planting food forests. The people who actually show up and keep things moving are always fewer than we need.

Then into this gap steps the parasites of #mainstreaming. Yes, they look like they’re helping. They reach out, they polish up the image, they “outreach” grassroots tech projects to wider audiences. But under the surface, this isn’t really helping. What they are doing, shifts focus away from what makes grassroots powerful – trust, messy collectives, stubborn autonomy – and towards something glossy and hollow.

Real help doesn’t come from smoothing out the rough edges for palatability. Real help is messy, reciprocal, and based in care. It’s, shipping working code, turning up to maintain the server, to keep the firewood dry, to cook food for the meeting, to argue about governance without walking away. It’s staying rooted when everything pulls you towards the easy path of compromise.

The good news? The work that does happen, when it’s done by those few stubborn and lovely souls who commit to it, is real and lasting. Every #fediverse instance that survives another year, every scrappy #openweb tool that stays online, every cooperative that resists collapse – these are proof that grassroots power is alive.

So yes, most of what gets labelled as “help” from outside is damage. But the grassroots path is still there. If we keep it simple – #KISS – and keep choosing trust over polish, collectives over branding, we can tip the balance back to where it needs to be.

Let’s look at some examples:

#Indymedia worked because it was built on trust, open publishing, and direct participation. But once the dogmatic #eekproblem, the NGOs and professional activists came sniffing, the energy shifted. Gradely the rough edges, the wild openness, became a “problem to be managed” instead of a strength. And with that, the vitality drained.

Or look at the #Fediverse. It thrives when it stays scrappy, with collectives running their own servers and shaping their own cultures. But already we see #Bluesky, #Threads, and NGO-backed “Fediverse Foundations” pushing. They’ll say they’re amplifying the movement. In reality, they’re clipping its wings, taming it for the same #mainstreaming logic that gutted Indymedia.

The #OMN (Open Media Network) was always an attempt to resist this drift. Instead of begging for a seat at the mainstream table, it builds trust networks from the ground up. No gatekeeping, no branding games – just collectives #4opens sharing content, tools, and governance in open, federated ways. It’s not sexy. It doesn’t polish well for a TED talk. But it works, because it stays close to where publishing and power actually happen: at the grassroots.

I’ve seen this first-hand in my own work. On the boats at Rummelsburger Bucht, in affinity groups fighting #climatechaos, and in rebuilding #indymediaback, the same pattern repeats. The parasite #mainstreaming arrive smiling, but what matters is the stubborn few who show up with shovels, laptops, and trust. Those are the people who keep the fire burning. The #KISS truth, it doesn’t take everyone. It just takes enough of us who refuse to give in.

While it’s easy (and justified) to call out the parasitic #mainstreaming types, it’s harder (and more important) to think about how to bridge to them without being captured or co-opted.

1. Meet them on fluffy values, not hard projects. Most #mainstreaming people say they care about openness, creativity, and inclusion. Use those as starting points. Instead of hitting them with #4opens or #OGB right away, talk in simple, human terms: trust, care, mutual aid, freedom. Then show how the OMN already embodies those values with examples like: When talking about #indymedia reboot, don’t begin with federation protocols; begin with “this is a people’s newswire where communities publish, and no single organisation can control it.” Then connect that to the tech.

2. Frame the commons as abundance, not scarcity. Mainstreaming comes with a scarcity mindset (“we need funding,” “we need gatekeepers”). We counter with an abundance story: the #openweb grows by sharing, remixing, and federating. Emphasise that our strength isn’t owning the pie but baking more pies together. An example might be: OMN flows content between blogs, small sites, and #fediverse projects. This isn’t competing with “platforms,” it’s weaving a bigger web where everyone benefits.

3. Offer them low-stakes ways to join. Not everyone is ready to dive headfirst into spiky, fluffy, grassroots culture. Make lightweight on-ramps: federated publishing plugins, easy “flows not silos” demos, or spaces where they can share without having to fully sign up.

4. Keep the tone sometimes fluffy, sometimes spiky. People new to grassroots tech often get scared off by the first bit of conflict. Fluffy spaces – campfires, storytelling, art – can bring them in. The spiky edges – calling out parasitism, blocking #NGO capture – should remain, but not be the only door in.

5. Make co-creation visible. Show them that grassroots projects don’t just “talk” about collaboration – we live it. When people see decision-making without bosses, publishing without gatekeepers, and coding without silos, they realise it’s possible. An example of this can be found in #OMN wiki pages on Unite Forge which are messy, open, and collective. That’s not a bug, it’s a living record of co-creation. Point to that messiness as proof of trust-based work that they can make more “tidy”, this is work as gift.

The #bridgeing isn’t about diluting grassroots culture into “NGO-speak.” It’s about keeping our paths, our politics sharp, while offering ways for curious people to join with less fear. Some will drop off (parasites always will), but others might step over the bridge and become part of the messy, hopeful commons.

#KISS