Tag: geekproblem

The Tech “Empiricism” Problem

A recent essay on deadSimpleTech makes a point the #openweb community should hear: the biggest problem in technology is not only the tools, it’s also the culture behind them. For years the tech world has operated under a form of narrow “tech empiricism”: the belief that if something produces results quickly, then it must be working well. In this mindset, success is measured by novelty, speed of production, and the ability to create something new. The heroes of this culture are disruptors and iconoclasts who ship fast and build shiny things that capture #fashionista attention.

But this basic #geekproblem ignores a simple #KISS truth: technology only has meaning inside the culture that builds and maintains it. And this is where the real problem begins. In the dominant tech worldview, the culture rewards novelty, disruption, rapid production, and personal prestige. Inside this environment of #deathcult worship, producing new code becomes a way to gain status among peers. Shipping quickly matters more than maintaining systems or improving what already exists.

But there is another culture that exists alongside this, the culture of engineering and maintenance. In fields like civil engineering or infrastructure design, the heroes are not disruptors. They are the people who quietly maintain systems, improve reliability, and prevent failures. The emphasis is on responsibility, long-term stability, and care for systems people depend on. This difference in culture matters enormously. Because what counts as something working “well” depends entirely on what the culture values.

From the perspective of blinded tech culture, a tool that generates lots of new code and features appears incredibly successful. But from the perspective of infrastructure and engineering culture, that same tool may look deeply flawed – even dangerous. Real systems require debugging, maintenance, testing, and institutional memory. Most importantly, they require people who accept responsibility when things fail.

In mature systems, the first prototype is only the beginning. The real work comes later: years of maintenance, improvement, and adaptation. Yet this long-term work is largely invisible in tech culture and funding systems, which celebrate the person who creates something new but rarely honour the people who keep it running. This cultural blindness leads to fragile systems and recurring cycles of hype and #techshit to compost.

The same problem is in the #OpenWeb. Unfortunately, this problem is not limited to Silicon Valley, it also appears inside the #openweb, #NGO, and #FOSS ecosystems. Many conversations focus almost entirely on: code, protocols, scaling, features and UX. All of these are important, but without balance they are not enough to sustain a functioning ecosystem.

Without the native social culture that originally shaped the open web, open technology slowly drifts toward the dominant norms of the wider #dotcons tech industry of status competition, short-term innovation cycles, neglect of maintenance and eventual capture by institutions or corporations. This is one reason so many promising #openweb projects stagnate or collapse.

The technology works, but the social infrastructure fails. It’s in part why the #OMN exists as a project. This is the gap we need to address, not primarily as technical project. Most of the protocols and software already exist. What is missing is the social infrastructure that allows them to function as a public commons. Instead of focusing only on building new non-native platforms, the #OMN focuses on growing the wider ecosystem around what all ready works.

This means recognising that the real value of a network comes from the people who maintain it, moderate it and build communities around it – not just from the code itself.

From tech “empiricism” to social infrastructure, if we want the #openweb reboot to succeed, we need to move beyond the narrow mindset that treats technology as purely technical. The lesson from history is simple, code builds systems, culture makes them work. Without a healthy culture, even the best open technologies will eventually fail or be captured by more powerful institutions.

A deeper mess is “The End of Theory”, tech empiricism problem is really the #geekproblem amplified by ideas like this, the claim that massive data sets make traditional scientific thinking unnecessary. This idea, popularised by Chris Anderson, suggests that with enough data we no longer need theories, models, or human understanding. But this is a dangerously narrow view as large data models are epistemologically weaker than scientific theories. They can recognise patterns, but they do not understand them.

This becomes even more problematic in the age of opaque and unexplainable #AI systems. Deep learning models can be efficient at pattern recognition, but they lack human comprehension and produce opaque but believable outputs. At the same time, the increasing “datafication” of society means that communication and public life on the #dotcons platforms are moderated by these same algorithms. These systems prioritise engagement and behavioural prediction over needed values like: accuracy, truth, democratic deliberation. The result is a social environment driven by metrics rather than meaning.

It is past time to compost the mess as it is becoming easier and easier to see. But seeing the problem is only the first step. The next step is to compost it – to take the failures of the current system and use them as nutrients for something better. The future of the #openweb will not be decided by better code alone. It will be decided by whether we build the social infrastructure to support it. That is the work the #OMN is trying to grow.

If this work matters to you, help support it.

The #dotcons assume you want to be a techbro

One of the quiet assumptions built into almost every #dotcons platform is that the user secretly wants to become a #techbro. Not literally, of course, but culturally.

You are expected to optimise yourself by building your “personal brand” to track your metrics. Engage with algorithmic growth loops by understand platforms, feeds, APIs, monetisation tools, creator dashboards. You’re supposed to treat communication as a kind of performance engineering problem.

Most people never asked for this, they just wanted to talk to friends, share ideas, organise communities to publish things that matter. Instead, they got trapped inside systems designed around growth hacking and behavioural manipulation.

This is one of the reasons people are quietly, sometimes timidly, stepping away from the #dotcons, not always loudly, not always politically, but gradually. People feel something is wrong.

But when they look toward the #openweb, the path isn’t always easy either. Too often the tools we build assume something similar – just with a different flavour of geek culture. The user is expected to understand servers, protocols, instances, keys, forks, configuration files, federation quirks. In other words, the user is still expected to become a tech person.

This is the #geekproblem showing up again, if the #openweb is going to be a real alternative, we need to take this seriously. The vast majority of people do not want to be #techbros, sysadmins, protocol engineers or crypto specialists. They want tools that work socially, tools that support community rather than demanding narrow blind identity.

This doesn’t mean hiding the technology. The power of the #openweb comes from openness, the #4opens of open data, open source, open process and open standards. But openness should not mean unfriendly #UX.

The challenge for #FOSS and #openweb projects is to build tools with human-first design: Interfaces that feel welcoming rather than intimidating, workflows that reflect how communities actually organise with systems that support trust and relationships, not optimisation and metrics. We need onboarding that doesn’t require a technical worldview

In short: non-techbro #UX. This doesn’t mean dumbing things down, it means remembering what the web was originally good at, simple tools that let people publish, connect, and collaborate without needing permission or expertise.

Right now there is a real opportunity as people step away from the #dotcons, slowly, unevenly, sometimes reluctantly, but the shift is happening. If the #openweb meets them with only complicated tools and insider culture, they’ll drift back to the platforms they know. If we meet them with simple, social, welcoming infrastructure, the shift becomes something much bigger.

So the question for #FOSS developers is simple: Are we building tools for techbros? Or tools for people? If we want the #openweb to grow, the answer matters.

OMN: Broken Institutions, and the Need to Rebuild the Commons

For progressive and radical people, one of the central political questions of our time is simple to ask but hard to answer – Why is it so difficult to rebuild the institutions that were destroyed in our #deathcult worship of the 1980s and 1990s? And more importantly why does the impossibility of rebuilding them make it so hard to change the needed balance of power in society? These question matters for working on the future of the society and most importantly the grassroots part of this: #openweb, grassroots media, and projects like #OMN.

The hollowing out of institutions, in the 20th century, politics used to be deeply institutional. People didn’t just express opinions, they joined organisations. If you marched in a protest, we usually marched as a member of something: a trade union, a political party, a civil rights organisation or community association. These organisations formed the infrastructure of democracy, connecting everyday anger and hope to real power.

But beginning in the 1980s and 1990s, much of this infrastructure was deliberately dismantled. Union power was broken, mass political parties were hollowed out, and community organisations lost resources and influence. The result is the political landscape we inherit, a society with political anger but without any working political structures.

Today we live in what #fashionistas and academics call #hyperpolitics or what I call #stupidindividualism in the hashtag story. Yes, some people are more politically engaged than they were in the 1990s or early 2000s: More fluffy protests, #dotcons online political discussion. But this engagement is almost all unstructured in the old sense.

Millions may join a protest or share a political message in the #dotcons, yet very little, if any lasting organisation emerges from this. This surface engagement creates a strange paradox of huge drifting mobilisations leading to very little structural change. We can have the largest protests in history – yet the underlying power structures remain completely untouched.

Closed #dotcons social media lowered the cost of expression, but algorithmically shaped it into smoke and mirrors. Let’s take a moment to lift the lid on this #tecsit mess. The role of media in this is complex, on the positive side, #closedweb platforms drastically reduced the cost of political expression.

Forty years ago, if you wanted to express a political opinion publicly you needed a newspaper, radio station, a public meeting or to stand in a square shouting. Now you can reach thousands of people instantly. But there is a downside that #dotcons smoke and mirror online engagement replaces the slow work of institution-building. Posting, sharing, and reacting can feel like participation, but it has very little role in building the durable structures needed for any long-term change.

So why do the current hard right succeed without institutions? There is an uncomfortable asymmetry between left and right. The right can carry out its agenda without building mass organisations, because it relys on: existing elitist power structures, wealthy donors, state institutions and traditional corporate media.

The left cannot rely on these, historically the left needed mass organisations because its power came from collective action – workers, communities, movements. Without those structures, left politics becomes, mess, fragmented and reactive. This is why protest waves can be enormous but still fail to shift any real policy.

The #undeadleft problem is where vertical left respond to this crisis with nostalgia, there imagination stops at rebuilding the mass political parties and institutions of the 20th century. But this is to often like trying to animate a corpse, even if you could recreate it, the environment has changed so much that it wouldn’t survive.

At the same time, the opposite response – abandoning institutions entirely to relying purely on digital networks – also fails. Purely online movements often dissolve as quickly as they form. We need a #DIY hybrid path based on federated #4opens institutions like the tools we are building and rebooting with the #OMN projects.

Not rigid old institutions, not purely online networks, But something that seeds the in between. The goal is not to create another platform, it is to expand #federated #p2p infrastructure for collective media and collective politics. The original #openweb worked because it supported networks of communities, independent publishers and grassroots movements. The corporate #dotcons replaced this with extractive platforms designed for profit and control.

KISS rebuilding the commons means rebuilding the social infrastructure of media, not just tools, but institutions and practices that persist to allow collective voices to organise and persist.

The simple truth, if we want real political change, we cannot rely on viral posts, temporary movements or algorithmic attention. We need structures that last, connect people, that can turn energy into horizontal power. That work is slow, messy, and unfashionable, but like digging compost for a garden, it’s the only way anything grows.

A path to start to compost this #techshit is growing horizontal tools from the Fediverse for real change (#OMN).

If the problem of our time is political energy without institutions, then the opportunity is clear:
build new institutions native to the #openweb. Not simply recreate the rigid organisations of the 20th century, and not fall into the hollow performative politics of the #dotcons. Instead, we grow native horizontal digital tools to help people organise, coordinate, and act collectively. This is where the Fediverse and projects like #OMN matter.

The #Fediverse already proves that distributed infrastructure works. But right now it is mostly used for conversation. If we want meaningful change and challenge, we need to extend it into practical coordination and collective action. by build tools for organising, not just talking

Current social media tools are built for attention and engagement, not organisation. What we need to add to the mix is simple #4opens tools that help people form groups, coordinate action, share resources, document activity and most importantly maintain continuity over time (#makinghistory). The Fediverse already has #fashionista and #geekproblem pieces of this:

Mastodon / Pleroma → conversation

Mobilizon → events and gatherings

PeerTube → video publishing

PixelFed → visual storytelling

Lemmy / Kbin → community forums

These existing pieces can become seeds to be woven together into workflows for collective action. On this path we need to remember the goal is not more platforms, it’s practical ecosystems. For this to work a first step is rebuilding commons-based media. A core idea behind #OMN is returning to something like the #Indymedia publishing model, but rebuilt using modern federated tools. Instead of a single website, imagine distributed publishing nodes where local groups post reports, media is shared across networks, discussions happen across servers and archives remain accessible and most importantly meaningful.

This builds collective memory, something the algorithmic feeds of the #dotcons constantly destroy. Movements need memory to learn.

#makinghistory is the same code-base as this grassroots media project

One reason mass organisations collapsed is that participation became too heavy, people don’t want to “join a church” politically any more. So tools should allow different levels of engagement: casual participation, occasional contribution, active organising with core stewardship. The Fediverse naturally supports this because it allows loose affiliation rather than rigid membership. You don’t need permission from a central authority to participate.

Focus on infrastructure, not branding. A common #NGO trap in activist tech is building new branded platforms that compete with existing networks. That approach usually fails. The better path is infrastructure building based on protocols instead of platforms for #4opens interoperability instead of silos, tools that connect existing communities. This was the original power of the #openweb, protocols scale. Platforms capture.

Keep the tech simple (#KISS), as the biggest barrier to grassroots technology is complexity. Many promising projects fail because they become too technical for real communities to use. So the rule should always be KISS – Keep It Simple, Stupid. Tools should be installable easily, understandable by non-geeks and maintainable by small communities to grow resilience without large funding. If only developers can run the system, it will never become a movement infrastructure.

Compost the failures (#techshit). Another key idea is recognising that the tech world constantly churns useful waste. Old tools, failed platforms, abandoned code, all of this is #techshit that can be composted instead of chasing fashionable new tech, we reuse working ideas, simplify existing tools to combine proven approaches. The #openweb already solved many of these problems decades ago. Sometimes progress means going back to what worked.

Build trust networks, as the most important layer isn’t technical – it’s social. Horizontal networks only function when there is trust and shared culture. The Fediverse works because communities can federate with trusted peers, block hostile actors, build local norms. This allows networks to remain open but resilient. The challenge is nurturing communities of practice around the tools.

Grow slowly and organically, movements that scale too quickly often collapse. The better model is ecological growth with small nodes → connected networks → resilient ecosystems. Just like compost turning into soil. The goal is not explosive growth, its sustainable infrastructure for collective action.

The real challenge is the biggest obstacle isn’t technology, it’s the #geekproblem – the gap between technical culture and social reality. Too many tech projects assume that better tools automatically produce social change, but tools only matter when they are embedded in real communities and struggles. The work of projects like #OMN is bridging that gap.

Shovels, not silver bullets, we don’t need magic platforms, we need shovels, tools that help people dig, build, connect, and organise together on the native #openweb. If we can do that, the Fediverse becomes more than an alternative social network, it becomes infrastructure for democratic power.

What projects like #OMN can learn from history

A note to #FOSS funders

I’ve been working at the heart of this space for more than 30 years, funded and unfunded. In that time I’ve seen hundreds of alternative tech projects start with energy and good intentions. Most of them wither on the vine, a very small number flower.

After watching this cycle repeat for decades, one thing has become clear: the projects that survive and grow almost always follow a simple pattern. I call this the #4opens. Other people describe similar ideas as open source development, open governance, or commons-based development. The label doesn’t matter – the practice does.

If you want to know which projects will flower and which will wither, look at the ground, not the words. The #4opens ask four very simple questions:

  • Open data – can people access and reuse the information?
  • Open source – can people read, modify, and share the code?
  • Open process – can people see and participate in how decisions are made?
  • Open standards – can different systems interoperate and grow a wider ecosystem?

Projects that are open in all four of these ways tend to build living ecosystems. Projects that are only partially open tend to stall or collapse. The two repeating problems, over the years two patterns constantly undermine good projects.

#geekproblem – A teenage mix of arrogance and ignorance that is surprisingly universal in tech culture. Developers assume technical elegance (and complexity) will automatically solve social problems. They underestimate governance, community, and messy human reality.

#dotcons – The opposite pressure: corporate platforms pushing business models that prioritise extraction and growth over human need. They happily wrap themselves in the language of “open” while building fundamentally closed systems.

Both pressures distort funding decisions. Both lead to projects that sound open but aren’t. Money is a dangerous subject, yes, funding matters, but money inside infrastructure projects to often distorts them quickly. For #openweb work, a useful rule of thumb is: Keep the core simple. Focus funding on maintaining the #4opens infrastructure. Let many different organisations, businesses, and NGOs build external services and applications on top.

This keeps the core commons stable while allowing diversity and experimentation around it. It’s the #KISS principle applied to digital commons. When funding pushes too many external agendas into the core, projects become heavy, political, and fragile.

Some uncomfortable truths, over the last decade we’ve been told several stories about security and scale that simply don’t hold up. There is no security in CLOSED systems, security emerges from open scrutiny and shared responsibility:

  • There is no security in radical individualism, security emerges from community.
  • There is no security in “trustless” systems, real resilience grows from social trust.

These ideas have been obscured by hype cycles and by the influence of #dotcons and their shadow allies, the #encryptionists who push purely technical “trustless” thinking. Both camps wrap themselves in the language of openness, but their systems remain structurally closed. Words are wind, look at the ground: #4opens.

The unspoken scaling problem, there is also an unspoken #geekproblem around how we think about scaling. When many developers talk about #p2p, they imagine data-to-data scaling, systems optimised to move information as efficiently as possible. From that perspective, human friction looks like a problem.

But if you see #p2p as human-to-human, the picture changes. Human scaling limits – smaller communities, slower processes, local trust networks – are not bugs, they are virtues, creating resilience and accountability. The data-first model is the one favoured by the #dotcons.
The human-first model is the one the #openweb actually needs. Funders should be aware of which philosophy a project is building around.

A simple test If you want a quick filter when looking at proposals, ask:

  • Does this project genuinely follow the #4opens?
  • Does it build community and governance, not just code?
  • Is it resilient without permanent central funding?
  • Does it strengthen the commons, rather than a future platform?

Projects that pass these tests are the ones most likely to flower, everything else tends to wither. Food for thought.

#EU #NLnet #NGI #funding

Make some FOSS compost

Why good faith is a technical requirement for #FOSS

If you’ve spent years in #FOSS, you’ve likely developed a strong allergy to vague political language. You care about licenses, reproducibility, governance models, and whether something actually runs. Good. That discipline is why free software exists at all.

But here’s the uncomfortable question, what if the biggest blocker to the #openweb right now isn’t technical debt – but social debt? And what if “good faith” is not a moral nicety, but a core infrastructure requirement?

The problem is when activism meets the #geekproblem. Anyone who pushes for change – especially against #mainstreaming pressures – develops a recurring relationship with bad faith. You see this when:

  • Corporate actors adopt the language of openness while enclosing the commons.
  • Institutions celebrate “community” while centralizing control.
  • Projects technically comply with openness while culturally gatekeeping participation.

This isn’t new, but the scale is new, in the age of #dotcons, #NGO enclosure is polished, funded, and normalized. Resistance generally fragmented, exhausted, and defensive as years of platform manipulation and extractive models have left people burnt out and cynical. In that climate, good faith is fragile, yet without it, nothing decentralized works. Good faith is infrastructure, decentralized systems cannot rely on coercion at scale. They rely on:

  • Trust
  • Transparency
  • Shared norms

The assumption is that participants are not actively trying to sabotage the commons, as when bad faith dominates, decentralized governance collapses into:

  • Endless meta arguments
  • Capture by the loudest actors
  • Drift toward hierarchy “for efficiency”

Sound familiar? This is why good faith isn’t sentimental, it’s structural. If you’ve ever tried to maintain a FOSS project while navigating trolls, corporate opportunists, and purity politics, you already know this.

To help the #4opens is a practical test, not a vibe. The #4opens framework exists precisely to operationalize good faith. It asks four simple questions of any grassroots tech project:

  • Is the data open?
  • Is the source open?
  • Are the processes open?
  • Are the standards open?

This extends beyond traditional open data initiatives (often institutional, often cosmetic). It covers the entire ecosystem of a project, not just its outputs. The value is not ideological purity, it’s resilience. When data, code, process, and standards are open:

  • Capture becomes harder.
  • Forking remains possible.
  • Governance can be contested transparently.
  • Communities can leave without losing everything.

That’s not abstract politics, it’s survival architecture. Composting the current rot is why #OMN exists as a project. We are living in a digital environment thick with enclosure and manipulation. Years of bad faith, disempowerment, and algorithmic extraction have created social decay. The instinct of many geeks is to build a cleaner stack and hope people migrate. But the problem isn’t just software, it’s trust collapse.

If the #openweb is to mean anything beyond developer autonomy, it has to support collective storytelling and coordination, not just individual expression. #OMN is a shovel, not a cathedral. It’s a way to compost the mess rather than pretend it isn’t there.

The #OMN (Open Media Network) is not a shiny new protocol. It’s deliberately simple: Publish, Subscribe, Moderate, Rollback, Edit. That’s it, no engagement hacks, no growth funnels and no surveillance capitalism. It’s a #DIY, trust-based, human-moderated space. Messy, organic, built for communities, not only users.

This matters in the era of #climatechaos and social break down. As climate instability accelerates, centralized platforms will align with state and corporate power to prioritize “order” over dissent and optimize for profitability in shrinking margins.

To balance these communities will need coordination without permission, information flows that aren’t algorithmically distorted and infrastructure they can adapt locally, that’s a social demand. If #FOSS remains culturally optimized for the small minority who enjoy living inside the #geekproblem, it will not meet that demand at all.

We need to understand that the vast majority do not want to self-host, they do not want to debate licences, they do not want to live inside issue trackers. They want functioning, trustworthy spaces, if we can’t provide that, someone else will – and it won’t be #4opens.

The hard part is working with the empowered disempowered of our #fashionista class. We have a generation trained in #closed systems that reward performative critique over collective construction. On #dotcons platforms and strands of #NGO thinking, people are empowered to disempower others with common sense #blocking of call-out culture, optics over substance and branding over shared process. You get a strange anti-politics, egotistical, individualistic, allergic to long-term responsibility. A culture that critiques power while replicating it. Escaping this dynamic may be uncomfortable, it may get nasty before it stabilizes.

But here are some kinder strategies we can use:

  • Make contributions obvious and low-drama, clear process reduces ego battles.
  • Reward maintenance, not only innovation, culture follows incentives.
  • Default to transparency over suspicion, sunlight reduces paranoia looping.
  • Design for groups, not influencers, collective accounts, shared moderation, distributed ownership.
  • Keep it simple (#KISS), as complexity amplifies gatekeeping.

None of this eliminates conflict, but it shifts the terrain from personality warfare to shared work.

An invitation to the sceptics, you don’t need to buy the rhetoric, maybe ask instead does this increase forkability? Reduce capture risk? Does it lower dependence on extractive infrastructure to strengthen collective agency? If the answers are yes, they belong in the #FOSS conversation. The future of the #openweb will not be secured by better branding or cleverer stacks. It will be secured by projects that treat good faith as a design constraint and collective resilience as the goal.

This is not about purity, it’s about durability. We can keep polishing tools for the tiny minority who enjoy living inside the #geekproblem, but, we need to build infrastructure that ordinary communities can also use to navigate the storms ahead. The invitation stands, pick up a shovel, help compost the mess by build something that gives back more than it extracts.

#4opens #indymediaback #openweb #compostingthemess #KISS #makeinghistory #OMN

State Funding of #FOSS and Open Source: Is it a Good Idea or a Bad Idea?

#FOSS needs to take a social lead

This matters for #FOSS because as if it remains culturally trapped inside the #geekproblem, it becomes socially irrelevant at the exact historical moment it is most needed. Right now, most #FOSS energy still assumes that if you build complex tools, argue narrowly, and keep everything technically “open,” people will come. But only a tiny minority actually want to live the full-stack geek life: self-hosting, compiling, debating licenses, maintaining infra. That path selects for a personality type. It is not neutral.

The problem isn’t that this path exists, it’s that it quietly tries to define culture. The tension is that the #geekproblem tends to reduce political and social questions to technical architecture. It too often treats freedom as a property of code, rather than a property of relationships. But in an era of #climatechaos, people don’t need abstract freedom in protocol design. They need mutual aid to build trust networks and local resilience. They need collective agency in open spaces to coordinate without corporate capture. These are #KISS social demands.

If #openweb remains framed as a technical alternative to Big Tech, it will only attract geeks and edge cases. If it is framed as a public infrastructure for collective survival, it suddenly matters to everyone. This shift in focus is urgent as climate disruption accelerates: Centralized platforms will prioritize profit and state alignment, infrastructure failures will become normal, feeding political polarization. Authoritarian coordination models will look “efficient.” If #FOSS cannot step outside the geek subculture, it leaves the field open to #dotcons and state/corporate hybrids to define digital coordination. That’s not a tech failure. It’s a social failure.

So, what changes this frameing? To make #openweb meaningful to the majority, we need to shift from tools to practices. Don’t only ask people to install software, ask what they are trying to do with digital tools together. Then lower cultural barriers, not just technical ones, by building code for groups, not only individuals. The mainstream internet optimizes for #stupidindividualism, the alternative needs to be balancing this mess, by optimizing for collectives.

Accept messiness, social systems are not elegant, they compost, they fork culturally before they fork technically. Centre use in crisis, not only ideology, when floods hit, when heatwaves hit, when services fail – what does the #openweb enable that corporate #dotcons platforms cannot? If the answer is “we have a nicer licence,” it won’t matter. If the answer is “your community can coordinate and survive without asking permission,” it becomes essential.

The hard truth is only a minority want to be geeks, but almost everyone wants dignity, voice, belonging and some stability in chaos. If #FOSS and #openweb can’t translate into those terms, they remain culturally marginal. This is why the issue is urgent, not because the code is broken – but because the social imagination around it is too small for the scale of the social and ecological crisis. And in the age of #climatechaos, infrastructure that doesn’t scale socially (#fluffy) will be replaced by infrastructure that scales politically (#spiky) – whether we like it or not.

The question isn’t whether #openweb works, it’s whether it can grow beyond the #geekproblem long enough to matter.

Commons and the metaphor of “grow a backbone”

Age Verification Is Not a Technical Problem

If you think age verification is just an engineering challenge – better cryptography, better zero-knowledge proofs, better ID rails – you’re likely a part of the #geekproblem at best, or at worst the control culture we need to compost. We need to better balance this mess, as a technical problem and a political instrument of control.

Across multiple jurisdictions, “protecting children” is used as the framing device. But the mechanism being normalised is much broader:

  • mandatory identity gateways
  • infrastructure-level filtering
  • platform liability tied to speech
  • centralised verification intermediaries

The problem is that isn’t child protection infrastructure, it’s a population control infrastructure. Once identity verification becomes a prerequisite for accessing speech, publishing content, and browsing information, anonymity stops being a right and becomes an exception. And history is clear, when anonymity disappears, dissent becomes riskier.

The function of age verification systems are:

  • centralise power over who can access what
  • create databases of identity–behaviour linkage
  • raise barriers to entry for independent publishers
  • entrench large platforms that can afford compliance

They don’t in any way “solve a safety issue.” It’s clearly about restructure the public sphere, and this is done in ways that favour #dotcons, with surveillance-heavy models leading to state oversight of online life. This is why treating it as a neutral technical puzzle is very dangerous. You can build the most privacy-preserving age-gate imaginable, and still legitimise the idea that access to information requires credential checks. That’s the shift, it’s about control, not code.

Authoritarian governments are obvious examples, but even “liberal democracies” slide when given the tools to normalise identity-linked browsing, mandatory compliance filtering and speech conditioned on verification… we move from open networks to permissioned networks. That’s a structural change, and structural changes are hard to reverse.

The line is that “free speech” isn’t just about what you’re allowed to say, it’s about the conditions under which speech occurs:

  • Can you speak without being tracked?
  • Can you access information without registering?
  • Can minority or dissident voices reach people without identity clearance?

Age verification regimes chop away at those conditions, maybe gradually, reasonably, for safety. That’s how rights erode, not with dramatic bans, but with infrastructure.

The path is not something to “innovate around.” It’s something to resist at the policy level. If we accept the premise that identity checks are a legitimate precondition for access to online speech, we concede the foundation of an #openweb.

Age verification is being framed as technical hygiene, it is, in reality, a governance shift. And governance shifts of this scale shouldn’t be quietly accommodated, they need to be openly debated, and, where they undermine civil liberties, firmly opposed.

Who’s Building the #Openweb – and Who’s Just Feeding Off It

Almost all funding in the #openweb space gets absorbed by the mediation layer – the people and organisations who talk about, manage, and frame the work rather than doing it. Some money reaches (#geekproblem) developers. Some supports visible projects and #fashionista careers. But the pattern holds: funding flows to what institutions can understand, and institutions rarely understand messy, unglamorous, day-to-day grassroots work.

So resources pile up around reports, events, strategy documents, coordination roles, and polished narratives – while the people actually running infrastructure, holding small communities together, and doing the labour that sustains the #openweb go unfunded. That’s not usually corruption, it’s structural. Institutions fund what they can measure and present. What they can measure and present is almost never the soil layer.

The result is a widening gap between the #fashionista story of the #openweb and the lived reality of it. More funding grows blinded narratives faster than it grows anything real. The question isn’t just “more money”, it’s how do we get resources to the people actually doing the work?

That’s why strong words matter. Naming parasites gives people who are currently being parasitic a chance to stop. Naming #techshit gives people making it a chance to compost their own mess. If they take that chance, good – a kindness has been done. If they don’t, we compost the mess ourselves and grow something better. #KISS.

“Impossible” Is a Political Word

Slavery abolition was impossible. Universal suffrage was impossible. Worker self-organisation was impossible. An open global communications network outside state control was impossible. Until people acted as if it weren’t.

Calling something impossible is usually political – a way of narrowing imagination and disciplining ambition, keeping demands within what existing power structures can tolerate. Structural shifts rarely begin as reasonable proposals. They begin as overreach. Commons infrastructure, resisting enclosure, building beyond scarcity logic – none of this looks feasible from inside the incentive structures it’s trying to replace.

If we only aim for what seems immediately achievable, we are reinforce existing incentives. If we aim beyond them, we shift the terrain. We may not reach the impossible goal, but we change what becomes possible next. That’s not utopianism. Historically, it’s actually #KISS and it’s how boundaries move.

Open Spaces Attract Parasites. That’s Ecology.

The #openweb generates real value: code, trust, collaboration, legitimacy, cultural capital. None of it is stable without maintenance. When drift sets in, someone has to shovel. That work is messy, exhausting, unpaid, and constant – because digital commons produce nutrients, and institutional actors are trained to harvest nutrients. If nobody composts the shit, the project chokes.

The “parasite class” in tech isn’t made up of evil masterminds. They tend to be institutional, NGO-aligned, career-professional actors who attach themselves to commons projects and redirect energy toward grant cycles, brand positioning, and compliance governance. They don’t build the soil. They feed on it. And they usually don’t know they’re doing it.

The most common parasite logic is digital scarcity: “everyone should pay their way.” It sounds responsible. It sounds sustainable. It’s also a direct import from market ideology. Digital infrastructure is non-rivalrous – it can be shared at near-zero marginal cost. But scarcity gets reintroduced through subscriptions, premium tiers, paywalled features, SaaS dependency, and professional gatekeeping. That’s enclosure wearing a cardigan. It’s not building commons, it’s rebuilding #dotcons platforms with nicer vibes.

The #NGO layer brings its own infection: risk aversion softened by consensus theatre. Measurable outputs. Depoliticised language. Branding as reputational management. None of it is directly evil, but it’s structurally parasitic – because the moment legitimacy becomes more important than usefulness, you start designing for funders instead of participants. You optimise optics instead of flows, you protect the brand instead of the commons.

This keeps happening because commons produce surplus – trust, energy, attention, infrastructure – and institutional actors are trained to capture surplus. They don’t see themselves as parasites. They see themselves as stabilisers. But when their survival depends on controlling narratives, they can’t help bending the project toward those needs. That’s structural parasitism, not personal villainy.

So ask yourself honestly are you building soil or feeding off soil someone else built? Are you increasing abundance or reintroducing scarcity through “sustainable” monetisation? Are you materially decentralising power or just professionalising it? Commons infrastructure should reduce dependence on gatekeepers, not multiply them.

This is a traditional political view of these people

Pick Up the Shovel

Yes, there are parasites. Yes, there’s shit to shovel. No, pretending everything is collaborative harmony doesn’t help anyone. The work of #OMN and #4opens isn’t trend-chasing or #NGO alignment. It’s building resilient soil, designing against digital scarcity, and keeping governance open and genuinely messy. If that makes institutional actors uncomfortable – good. Composting always smells bad before it becomes fertile.

One last thing: stop burning out alone. The number of good people burning out right now is not accidental. It’s what happens when systemic problems get reframed as personal responsibility. Collective infrastructure is weak, crisis is constant, and nobody can carry that alone. Nobody should try. The solution isn’t heroic individual effort. It’s shared architecture. In #FOSS terms: if the system keeps crashing, stop blaming the users and redesign the stack.

That’s the composting we actually need to do.

The Meta-Mess of the “Open” Social Web

Most people sense that something is off

Meany people see the world degrading, enclosure accelerating. They see climate, politics, media all bending toward extraction. And even when they can see the trajectory, they feel powerless, so they cope by optimise their careers. They scroll. They argue. They consume. They retreat into irony. From birth, we’re trained into one core assumption: There Is No Alternative (#TINA).

Not because it’s true, but because every dominant institution reinforces it:

  • Schools train compliance.
  • Media normalises enclosure.
  • Platforms reward performance over substance.
  • Workplaces absorb our creative energy into extractive systems.

The message is subtle but constant:

  • “You can’t change anything.”
  • “Radicals just break things.”
  • “Be reasonable. Fit in.”

For builders, this message hits differently, because we know alternatives are possible, we’ve already built them. This is the #FOSS Paradox, as free and open source software proves collaboration without enclosure works, commons-based production works, open standards work and distributed governance can work. Yet somehow, the infrastructure we helped build keeps being enclosed.

The #openweb became the #dotcons, protocols became platforms and communities became markets. Not because we failed technically, but because we underestimated scale, incentives, and capture. And too often, we built tools without building parallel social power. The real trap isn’t rebellion – It’s drift – The #mainstreaming system doesn’t survive by crushing everyone loudly. It survives by absorbing alternatives, funding safe versions of dissent, steering energy into manageable channels and exhausting people with maintenance and precarity

Gatekeeping doesn’t always look like repression, more it looks like grants, partnerships, “best practices,” and institutional legitimacy. The result is that talented builders end up reinforcing the systems they once set out to replace. Not out of malice more from survival.

This Is where #OMN and #4opens come In, it isn’t only ranting about what’s broken, it’s about rebuilding missing layers:

  • Trust
  • Shared infrastructure
  • Media flows outside algorithmic capture
  • Governance rooted in actual participants

The #4opens are not branding, they are structural safeguards:

  • Open data
  • Open source
  • Open standards
  • Open process

Without all four, enclosure can creep back in, slowly, politely and inevitably.

This Is not about individual heroics, the myth of the lone hacker is part of the problem. What we need for the new “common sense” is that #stupidindividualism is a dead end. Few people escape extractive systems alone, no one builds durable alternatives alone. Collective infrastructure helps build counterweight to centralised power.

That’s what the #Fediverse gestures toward, what the #openweb once promised, and what needs strengthening now. A first step is to stop pretending we’re powerless. If you’re in #FOSS, you already have:

  • skills
  • networks
  • literacy in decentralised systems
  • experience with commons governance

What’s missing isn’t capability, it’s coordination and shared direction. The first step isn’t dramatic, it’s simple, reject the #NGO path to:

  • Find your people.
  • Support projects aligned with the #4opens.
  • Build flows, not just features.
  • Connect tools to real communities.
  • Refuse quite capture.

Do something – anything – that strengthens commons infrastructure instead of platform enclosure. The biggest lie Is that there’s no choice, when we keep repeating “this is just how things are,” eventually it becomes self-fulfilling. But history says otherwise, every dominant system looks permanent, until it isn’t.

The real outsiders aren’t the loudest rebels, they’re the ones who quietly stop reinforcing broken systems and start building viable alternatives. That’s what this moment asks of the #FOSS community is not #blocking outrage, not purity and not only collapse fantasies.

So, please stop waiting for permission, build systems that align with human autonomy and biophysical reality by strengthening commons before they’re erased. Because alternatives don’t appear, they’re built, and if we don’t build them, enclosure wins by default.

#KISS #openweb #4opens #nothingnew #geekproblem

Scale changes everything

This message is a shovel

Ten years ago – and honestly long before that – there were endless conversations on #failbook about how useful it was for campaigning. The dominant view back then was simple: it’s just cat memes, it’s just tooling, it isn’t political so we can use it harmlessly. Before Snowden, this wasn’t a fringe view – it was probably a 90% consensus, especially among activists, and #fashionista tech communities. I’m not pointing fingers here, as this was normal. Many of us – including friends and collaborators – believed this.

And that’s exactly why we need to remember it. If we forget, we repeat, if we scapegoat, we learn nothing and become no better than the trolls. The problem isn’t individuals – it’s collective amnesia. The is an issue of responsibility and historical memory, that when people deny their own history of responsibility, they disconnect from reality. That’s how too meany people drift into the same “post-truth” space we criticise in figures like Trump or Stammer, where inconvenient past positions are quietly erased.

The uncomfortable truth is that many of us argued that #dotcons were neutral platforms, engagement was empowerment, memes were harmless cultural glue. Meanwhile, our healthier #openweb tools were neglected and dismantled, community infrastructure withered, while the #closedweb platform economy consolidated power. Looking back isn’t about blame. It’s about understanding how we arrived at this mess.

The campaigning trap? Ironically, many tech-minded activists used to run workshops teaching people how to campaign on #dotcons – even as we recognise that these platforms structurally undermine autonomy, community governance, and sustainable organising. This didn’t only happen because people were stupid or malicious. It happened because convenience replaced infrastructure building, the #geekproblem undervalued usability and social design and short-term reach trumped long-term resilience. The result is a paradox: we built our movements inside systems that weakened them.

But spreading more shit without composting it – just makes alternative spaces smell worse and drives people away. This mess is not history, it’s now. This conversation isn’t nostalgia or score-settling. It’s about the present and future. Looking back is how we understand structural mistakes to rebuild shared memory and #KISS avoid repeating cycles of platform capture.

The compost metaphor is useful, #OMN is a spade not a weapon – a tool. A spade digs, turns soil to compost what came before. The mess we helped create – the attention traps, the algorithmic silos, the dependency on corporate platforms – isn’t something to deny or hide, it’s material to compost into something better.

The choices we made then still shape the terrain we stand on today. It’s the #fashernista problem, one of the biggest blocks to building real alternatives is this #fashernista dynamic – activism as aesthetic performance rather than infrastructure building. It looks radical, It feels good, but it rarely produces durable tools or collective power. Real alternatives require slower, less glamorous work of maintaining systems, building trust networks to support messy grassroots processes and designing for longevity rather than attention spikes.

A bridge forward? As I keep saying, this isn’t about shame or purity politics. Almost everyone followed the same path because the incentives pointed that way. The real question is that now that we know better, what do we build next?

#OMN isn’t nostalgia for a lost web – it’s an attempt to learn from past failures and construct a media infrastructure that remembers history to support collective agency and avoids repeating the mistakes that led to the current #dotcons landscape.

This message is a shovel. The question is whether we use it to dig trenches against each other – or to prepare soil where something better can grow.

Funding Proposal: Open Media Network (#OMN) – Building Portable, Human-Centred Digital Commons

The #openweb is the soil, #OMN the seeds

We are feeling a cultural current many of us recognise but rarely name clearly. A feeling that something fundamental has gone wrong, not just politically or economically, but culturally. An experience that imagination has narrowed, participation has thinned, and people are increasingly pushed into the role of spectators rather than participants in shaping the world.

This didn’t appear overnight. It grew out of decades of #neoliberal restructuring that reshaped culture, technology, and social life. Collective institutions were hollowed out, public spaces became marketplaces, creativity became branding and community became “audience”. Instead of shared projects, we were offered platforms, instead of commons, we were given services, instead of any participation, metrics.

This cultural shift produced a generation who feel the weight of a system that seems unavoidable – a reality that presents itself as permanent even as it fails to meet human needs. People sense the limits, but struggle to imagine alternatives because the cultural language for collective agency has been systematically eroded.

This is the environment the #dotcons thrive in, where the #closedweb turns culture into extraction and participation becomes only more engagement metrics. Community, user base, conversation content streams are where cooperation is #blocked due to competition for visibility.

And over time, this reshapes what people think about organising itself. Grassroots action begins to look unrealistic, messy, and inefficient compared to polished controlled platform experiences. Then trust disappears, replaced by algorithmic mediation and institutional management.

Yet beneath this dominant culture, another current has always existed, the #openweb culture, rooted in collaboration, experimentation, shared stewardship, and imperfect but real participation. IP protocol stack built on mailing lists, wikis, federated systems, grassroots media, DIY infrastructures, spaces where people build together rather than consume.

This culture never fully disappeared, as it was needed by the mainstreaming, it was just pushed to the margins. The #OMN project grows from this undercurrent, not as a reaction against technology, as a continuation of the parts of internet culture that treated technology as commons rather than a commodity. It #KISS recognises that infrastructure shapes social behaviour, and that rebuilding a healthier culture requires rebuilding the spaces where people meet, publish, and organise.

The difference is social logic, from social platform ownership grows to shared protocols, from central moderation to community mediation, from passive users to active participants. It’s the change from scale-as-growth to scale-as-federation.

Importantly, this isn’t nostalgia or any path to purity politics. The culture that produces #OMN understands that systems are messy. Grassroots projects fail, fork, and struggle. But instead of seeing this as weakness, it treats messiness as the natural process of collective growth. Composting rather than perfection.

The mistake of both corporate platforms and #NGO approaches is trying to engineer clean solutions to fundamentally social problems. The #geekproblem looks for perfect systems; the grassroots path builds resilient ones through ongoing practice.

This is why affinity groups, federated networks, and the #4opens matter. They create structures where trust emerges from shared action rather than imposed authority. The culture behind #OMN is not defined by ideology alone, it is defined by lived practice of people who build together and communities that govern themselves, to remain open to change

In a world that tells us “there is no alternative,” the simple act of building functioning alternatives becomes quietly radical. And when enough small, federated efforts connect, what once felt impossible begins to look normal again. That is how cultural change happens, not through grand declarations, but through many small working examples growing from shared soil.

The #openweb is that soil, #OMN is the seeds.

For sceptical #FOSS engineers, this isn’t an argument for abandoning structure, security, or technical rigour, it’s the opposite. The lesson from decades of open-source development is that trust does not mean naïveté; it means building systems where failure modes are expected and mitigated through transparency, modularity, and federation. #OMN applies these same engineering principles socially: small loosely-coupled groups instead of monoliths, open protocols instead of platform lock-in, observable processes instead of hidden governance.

If “pure trust” sounds unrealistic, think instead of reproducible builds, version control, and peer review, trust emerges from verifiable processes and shared ownership. The goal isn’t utopian social engineering; it’s creating resilient sociotechnical systems where collaboration scales horizontally because no single node becomes a point of failure or control.

#KISS

An affinity group is not just “a group of people who agree”

Nobody said it would be easy

If we want meaningful change rather than internal noise, it helps to talk less about individual personalities and more about roles, structures, and class. Individuals come and go, but the patterns they operate within repeat. Shifting focus this way isn’t about avoiding accountability, it’s about understanding the dynamics that shape behaviour across projects and communities.

When we centre individuals, discussions drift into blame or hero narratives, which generates more temporary heat than permanent light. When we look more at structural incentives, cultural habits, and class dynamics, we start to see why the same problems reappear across different spaces – from grassroots projects to NGOs to #FOSS communities.

This is a signal-to-noise issue. A native #KISS path helps keep analysis simple, structural, and grounded in shared experience. By reducing personalisation and increasing systemic understanding, we create more room for collaboration, learning, and mediation, which is important when building sustainable paths like the #openweb and #OMN.

What we then need to compost. It’s a normal mainstreaming augment that systems built primarily on trust will inevitably rot, decay, and collapse. That concern is understandable. Many people’s lived experience tells them that without strong control structures, things fall apart. And honestly – sometimes they do.

But the story is more complicated than that. First, there are long-term examples of trust-based or grassroots systems working, though they rarely look neat or institutional enough to be recognised as “successful” by mainstream standards. The difficulty is that these systems are best understood through participation rather than observation. They are lived processes, not static models. I document some of this history on this site, but reading alone rarely communicates the full reality, experience does.

Second, yes, grassroots projects can be damaged by well-meaning people. That isn’t paranoia; it’s everyday reality. Social dynamics, unconscious habits from institutional culture, and imported control patterns all create friction. The #OMN approach accepts this and builds mediation strategies directly into projects. These strategies are imperfect, we often get things wrong, but acknowledging the problem openly is part of making the work sustainable.

And to the harder question: if good intentions can cause disruption, what happens when bad actors show up? The answer is that no system is immune. Control-heavy systems fail too – sometimes more dramatically because their rigidity hides problems until they become catastrophic. The goal isn’t to create a perfect system (the classic #geekproblem), but to build a more humane messy system that can adapt, respond, and recover.

All functioning social systems are messy. Trying to eliminate that mess usually creates more fragility, not less. Instead, the path forward is to embrace smaller, resilient units that federate horizontally, many small experiments linked together rather than one central structure trying to manage everything. This is where the #fediverse and projects like #OMN become interesting: we now have technologies that allow small-scale trust networks to interconnect without collapsing into centralized control.

Will people try to take control or undermine these spaces? Of course. That’s part of reality. The work is to build cultures and processes that mediate this continuously, rather than pretending it can be eliminated.

What we maybe need to convince sceptical engineers is not ideology but demonstrated failure modes and working counter-patterns. Trust-based systems are not naive if they are designed with clear threat models, transparent processes, and layered social/technical safeguards. The question is not “can grassroots projects fail?” – all systems fail – but whether they fail visibly, recover ably, and without capture.

Long-lived commons like Wikipedia moderation structures, Debian governance, early Apache development, and parts of the Fediverse show that in tech messy, trust-anchored collaboration can operate for decades when legitimacy is distributed and process is open.

#OMN is not proposing blind trust; it proposes observable trust – where actions, history, and reputation are legible through open process (#4opens), allowing engineers to audit the social layer much like they audit code.

The real engineering challenge is not eliminating messiness (a classic #geekproblem trap), but designing systems where messiness becomes resilient rather than brittle. Nobody said it would be easy, but difficulty doesn’t mean impossibility. It means the work is social as much as technical.

None of this new – as Bakunin put it, “The peoples’ revolution will arrange its revolutionary organization from the bottom up and from the periphery to the centre, in keeping with the principle of liberty.” Whether or not we use the language of revolution, the underlying insight is practical rather than ideological: durable systems grow from lived participation outward, not from abstract design imposed from above.

In #openweb and #OMN thinking, this means building structures that enable agency at the edges while allowing coordination to emerge through federation and shared practice. The goal isn’t purity or perfection, but resilient networks where trust, mediation, and collective responsibility evolve through use – messy, iterative, and grounded in real communities rather than centralized control.

#KISS

The uncomfortable path