Chapter 17 The Infrastructure of the World (circa 2022-Present) (c. 2022)

By 2022, the stewardship chronicled in the previous chapter had completed its final translation into pure infrastructure: the compliance scanners GitHub now bundled into every repository, the Inner Source playbooks Google and Microsoft had institutionalized behind their firewalls, the automated license checkpoints standing sentry over each commit—all of it ran as silent plumbing rather than argued conviction. Consider two facts. The first is a scale beyond human comprehension: on any given day, the central registries for the world’s software dependencies—npm for JavaScript, PyPI for Python, Maven Central for Java—process millions of automated update requests. These are not decisions made by developers weighing philosophical commitments; they are transactions executed by build scripts and continuous integration pipelines, a ceaseless, unconscious circulation of code modules that keeps the digital world’s heart beating. The second fact is a shard of historical consciousness, preserved in the digital amber of a mailing list archive.

It is a line from a debate in the mid-1990s, a moment when the future was still being argued into existence. A participant, their identity now often obscured by the flattening of archives, wrote with palpable urgency about the stakes of “free software,” framing it not as a development methodology but as a fundamental right, a necessary condition for a just society. The chasm between these two facts—the visceral, human debate and the vast, impersonal operation—is the territory this chapter occupies. It is the space where a moral crusade completed its final metamorphosis into the infrastructure of the world. The translation was total. To use a computer, a smartphone, a modern automobile, or a home appliance in the third decade of the twenty-first century was, with statistical inevitability, to interact with a stack of technology built upon open source software. The Linux kernel resided not just in servers and supercomputers, but in every Android device, in televisions, in networking gear, forming an invisible, ubiquitous base layer.

Its proliferation traced a path from Linus Torvalds’s 1991 newsgroup post through the server wars of the early 2000s and into the pockets of billions. It was no longer a symbol of an alternative; it was the geology of the digital landscape. The containerized applications orchestrating global commerce and communication—managed by Kubernetes clusters that were themselves open source—were assembled from millions of lines of collaboratively written code, drawn from repositories whose licenses had been vetted not by ideologues but by corporate legal departments. The build process for a single modern application could pull in hundreds of these dependencies automatically, a cascade of code from thousands of authors, integrated and deployed without a single human ever reading the majority of the lines now executing in production. This was the operational reality: a vast, automated factory floor where the once-radical act of sharing source code had become the mundane intake valve for a global assembly line. In the boardrooms of the corporations that operated this factory floor, the strategic debates of the previous decades had concluded.

“Open source” was no longer a question of “if” or “why,” but of “how much.” It appeared on balance sheets as a cost-of-doing-business line item, managed through foundation memberships, compliance tooling, and dedicated teams whose mandate was risk mitigation, not ideological advancement. The revolutionary energy of the bazaar had been captured, neutered, and distributed across the vast, humming grid of normal operation. The historical shift was profound. Where once a company might have convened high-level meetings to decide whether to adopt an open source strategy, now the default was to build upon it. The question was one of management: how to comply with its licenses, how to secure its supply chain, how to leverage it without incurring legal or reputational damage. Open source had moved from the realm of corporate strategy, where it was a disruptive force to be evaluated, to the realm of corporate operations, where it was a condition to be administered. This administrative turn represented the final stage of institutionalization.

The idea had been stripped of its prophetic clothing and dressed in the grey flannel suit of governance, audit, and compliance. This operational reality was characterized by its silence. The ferocious mailing-list wars over licensing, governance, and freedom were archival curiosities, echoes from a time when the shape of the future seemed malleable. The new battles were procedural, fought not with rhetoric but with pull requests and automated security scans. The primary relationship of most developers to the open source commons was not one of community membership, but of consumption. They relied on a sprawling, interdependent supply chain of software components, the integrity and maintenance of which were often opaque. This opacity, born of the very success and complexity of the ecosystem, gave rise to a new domain of institutional management: the Software Bill of Materials, or SBOM. Born of regulatory pressure and acute security concerns following a series of high-profile supply-chain attacks, the SBOM was a formal, bureaucratic declaration of the ingredients within a software artifact, a list of components and their licenses and versions.

It represented the final, logical capitulation of the open source idea to the iron logic of industrial supply-chain management. The code was no longer primarily a vessel for freedom or a token of community; it was a part, with a version number, a provenance, and a list of known vulnerabilities. The dream of a transparent, participatory agora had yielded to the reality of a global just-in-time logistics network for bits, complete with its own manifests, customs inspections, and liability disclaimers. The original philosophical distinctions, so fiercely defended in those early, vociferous debates, became functionally irrelevant at this scale of automated integration. The choice between the GNU General Public License, with its protective “copyleft” clauses, and the more permissive MIT or Apache licenses was still a legal necessity, but its ideological weight had dissipated into the procedural ether. Companies constructed elaborate license-compatibility matrices and deployed scanning software, treating the GPL not as a social contract but as an engineering constraint, a component that might be incompatible with other business objectives.

The original philosophical distinctions, so fiercely defended in those early, vociferous debates, became functionally irrelevant at this scale of automated integration. The choice between the GNU General Public License, with its protective “copyleft” clauses, and the more permissive MIT or Apache licenses was still a legal necessity, but its ideological weight had dissipated into the procedural ether. Companies constructed elaborate license-compatibility matrices and deployed scanning software, treating the GPL not as a social contract but as an engineering constraint, a component that might be incompatible with other business objectives. The license had become, in the trenchant phrasing of one observer from a competing camp, a tool in a commercial arsenal. According to Richard Stallman, the major change in version 2 of the GPL was the “Liberty or Death” clause—Section 7. The section stated that licensees may distribute a GPL-covered work only if they can satisfy all of the license’s obligations, despite any other agreements that might conflict. This was designed as a bulwark against compromise, a principled line in the sand. Yet, decades later, in the context of its own overwhelming success, that same clause was parsed by corporate legal teams not for its ethical imperative but for its contractual loopholes and integration challenges. The weaponization was possible precisely because the license was effective; its success had drained its revolutionary intent, repurposing its legal machinery for market consolidation. The FreeBSD project has stated that “a less publicized and unintended use of the GPL is that it is very favorable to large companies that want to undercut software companies. In other words, the GPL is well suited for use as a marketing weapon, potentially reducing competition.” This was not a critique of the license’s internal logic, but a cold, post-ideological assessment of its utility in a landscape where the moral framework of its authors was a secondary consideration, a historical footnote to the main text of commercial execution.

This shift from ideology to utility was mirrored in the end-user experience, which was one of complete, blissful ignorance. Billions touched the products of this collaborative universe without a flicker of awareness, without needing any. They streamed videos served from Linux-powered datacenters, using browsers built on open source rendering engines, over networks routed by open source firmware. They benefited from the improved accessibility, lower costs, and rapid innovation this model enabled, while remaining utterly disconnected from its origins and its ongoing political economy. The “openness” was now a backstage factory detail, not a user-facing feature. For the vast majority, the software freedom that Richard Stallman had argued was as essential as air—the freedom to share with neighbors, to study, and to make changes—was an abstraction with no bearing on daily life. The infrastructure worked. It was reliable, cheap, and constantly updated. The fact that its keystone components were the product of a worldwide, often unpaid or undercompensated, collective of programmers was a curious footnote, a piece of trivia with no more practical relevance to the user than the mineral composition of the silicon in the chip. The moral crusade had achieved its ultimate, pyrrhic victory: it had made itself mundane, invisible, and expected.

For the vast majority, the software freedom that Richard Stallman had argued was as essential as air—the freedom to share with neighbors, to study, and to make changes—was an abstraction with no bearing on daily life. The infrastructure worked. It was reliable, cheap, and constantly updated. The fact that its keystone components were the product of a worldwide, often unpaid or undercompensated, collective of programmers was a curious footnote, a piece of trivia with no more practical relevance to the user than the mineral composition of the silicon in the chip. The moral crusade had achieved its ultimate, pyrrhic victory: it had made itself mundane, invisible, and expected. This mundanity was the historical terminus. Open source had not been defeated by its old adversary, the proprietary cathedral. Nor had it achieved a clean, ideological victory where its principles governed all software. Instead, it had become the environment itself, the substrate upon which both cathedral and bazaar now equally depended, the very ground of their being.

Microsoft, once the archetypal foe whose products and practices had catalyzed the free software movement’s formation, now owned GitHub, the primary platform and public square for open collaboration. Google, Apple, Amazon, and Facebook all built their empires upon and contributed back to the open source base, not as adherents to a cause but as stakeholders in a critical resource. Their stewardship was not benign; it was pragmatic. They managed critical projects not out of fealty to the four freedoms, but because it was the most efficient way to maintain the infrastructure their businesses required. The revolutionary fervor was gone, evacuated by its own ubiquitous success, and what remained was the steady, administrative work of maintenance—the curation of package registries, the funding of foundations, the patching of security vulnerabilities. The passion of the early debates had been transformed into the quiet efficiency of the landscape gardener, tending to a forest that had grown so vast it could no longer be seen in its entirety, a forest that now simply was.

The logistical reality of this infrastructure had become so granular and hierarchical that it mirrored the very supply-chain capitalism it had once sought to circumvent. The flow of code was governed not by philosophical affinity but by the cold calculus of maintenance and liability. A developer in a startup or a corporate team, facing a deadline, would select a library from a public registry based on a handful of metrics: the number of weekly downloads, the date of the last commit, the absence of critical security flags in automated scans. The vibrant, human history of the project—the impassioned discussions in its issue tracker, the personality conflicts behind contentious forks, the ideological rationale for its licensing choice—was compressed into metadata. This metadata was the new lingua franca, a dialect of risk assessment that translated the once-rich tapestry of communal creation into actionable business intelligence. The developer’s relationship to the open source commons was, in this light, functionally identical to a procurement officer’s relationship to a parts catalog. They sourced components with specific technical specifications and contractual guarantees (the license), weighing them against the overhead of potential future maintenance. The profound act of sharing, which had been the movement’s beating heart, was now a pre-condition so deeply assumed it was scarcely an act at all; it was the ambient medium in which all software development inevitably swam.

This normalization bred a peculiar form of alienation, even among those who directly contributed to the ecosystem. The individual contributor, filing a bug report or submitting a modest pull request to a massive project like the Linux kernel or React, was participating in a system of such immense scale and institutional mediation that their agency felt both amplified and hollowed out. Their contribution would be vetted by automated linters, reviewed by a bot checking for signed-off-by lines, and ultimately merged by a maintainer employed by a major tech corporation. The resulting code change would then cascade out into the global dependency graph, becoming part of the foundation for countless other systems. The contributor might feel the satisfaction of solving a technical problem, but the connection to any broader social or ethical mission—to the ‘free software’ ideal of empowering users—was tenuous, abstracted away by layers of process and corporate stewardship. The movement had successfully built the machinery for massive collaboration, but in doing so, it had rendered the collaborative act itself a routine, depersonalized input to the machine. The moral charge of sharing had been replaced by the professional etiquette of effective participation.

The administrative burden of managing this sprawling, critical infrastructure fell increasingly to a professi

The professionalization of this maintenance was the ultimate symptom of the movement’s absorption. What had once been a voluntary, collective endeavor driven by shared belief was now a sector of the technology job market. Titles like “Open Source Program Office Lead” or “Developer Relations Engineer” signaled a formalized, corporate-sanctioned role whose primary function was to manage the relationship between a for-profit entity and the commons it relied upon. These professionals were the new stewards, but their stewardship was measured in key performance indicators: the number of critical vulnerabilities mitigated, the reduction in license compliance incidents, the efficiency of the inner-source initiative. Their work ensured the smooth flow of code into the corporate machinery, a flow that had to be both abundant and risk-managed. This cadre of experts constituted a priesthood of the practical, fluent in the arcane language of licenses and dependencies, yet often indifferent to the theological disputes that had once defined that language. Their existence did not negate the continued volunteer contributions from individuals around the globe, but it did reframe them. The passionate hobbyist fixing a bug in a niche library now existed within an ecosystem whose critical paths were increasingly patrolled and funded by corporate interests. The community had not vanished, but it had been infrastructured—its outputs channeled, its governance models formalized, its most vital projects endowed with foundations that themselves operated like small, specialized corporations.

This infrastructuring process was accelerated and shaped by the platforms that hosted the code. GitHub, GitLab, and their ilk were not neutral conduits; they were architectures of participation that made collaboration frictionless at a global scale while simultaneously imposing their own logic of metrics and visibility. The “star,” the “fork,” the “pull request”—these were not merely tools but social cues that gamified contribution and created a hierarchy of attention. Projects lived or died by their traction on these platforms, a dynamic that privileged immediate utility and presentable demos over long-term, foundational work. The bazaar, now hosted on servers owned by Microsoft, had its stalls arranged by an algorithm. The platform’s design choices—the prominence of activity graphs, the default branch protection rules, the integrated dependency scanning—quietly enforced a culture of operational hygiene and continuous delivery that served the needs of its largest enterprise customers. In this environment, the moral or pedagogical ambitions of a project were often secondary to its ability to attract maintainers and pass automated checks. The platform became the unspoken policymaker, its features and defaults shaping the norms of collaboration more decisively than any manifesto.

Within this professionalized, platform-mediated ecosystem, the very concept of “community” underwent a subtle but definitive shift. The bonds that once formed around shared ideology and mailing-list debate were supplanted by the pragmatic ties of co-dependency and shared tooling. A developer contributing to a project was less likely to feel part of a cause and more likely to feel part of a distributed, asynchronous engineering team. Communication happened in issue trackers and pull request comments, focused tightly on technical specifications and implementation details. The sprawling, off-topic debates that characterized early project forums were now actively discouraged as noise, pruned away in the interest of maintainer sanity and project velocity. This efficiency came at the cost of the formative, often messy, political discussions that had woven the social fabric of earlier movements. The community, in its deepest sense, was replaced by a network of technically aligned strangers, cooperating not because they shared a vision for society, but because they shared a need for a particular function to work correctly. The solidarity was in the code, not in the creed.

This evolution towards a purely functional network was perhaps an inevitable outcome of scale. The staggering success of the open source model had necessitated systems—legal, corporate, platform—to manage its complexity. Those systems, in turn, selected for behaviors that were legible, low-friction, and low-risk. The result was a global apparatus of astonishing productive capacity, yet one in which the original impulse to build a different kind of world, rooted in freedom and reciprocity, had been largely metabolized. What persisted was not the ideology, but the institutional and technical patterns it had pioneered: decentralized collaboration, permissive licensing, transparent development. These patterns, however, were now detached from their normative origins, operating as best practices in an industrial context. The revolutionary had become regulatory.

The operational pressure of this vastness generated its own, new forms of tension, contradictions that the infrastructure’s success laid bare. As it solidified, its very ubiquity revealed material and ethical costs that its original architects, operating in a world of academic terminals and dial-up modems, could scarcely have imagined. The environmental impact was one such concrete, ironic consequence. The relentless, global “build process” powered by open source toolchains—the continuous integration, the automated testing, the deployment pipelines—consumed staggering amounts of energy. Every automated pull from a package registry, every container spin-up in a continuous integration runner, every execution of a test suite across a matrix of operating systems and language versions, represented a draw on the electrical grid. The datacenters housing the virtualized, containerized workloads that were the end-product of this globally collaborative development model drew power on a scale comparable to medium-sized nations. The cooling towers sent plumes of water vapor into the atmosphere; the mining of rare earth elements for the servers left scars on the earth.

The code that was free to run, study, share, and modify was now running, incessantly, on millions of machines worldwide, and each execution carried a tangible, carbon cost. The ethical legacy of the crusade for software freedom had, through the sheer, ambient ubiquity of its victory, morphed into a haunting, material question of planetary stewardship. The machinery of global connection, built upon a foundation of freely shared logic, now hummed a constant, low note of consumption, a physical burden inherited from a digital triumph. The freedom to build had collided, inexorably, with the cost of building at the scale of a civilization. The world had gotten the infrastructure it needed, and in doing so, it inherited the infrastructure’s true, uncalculated bill—a bill not for the code, which was free, but for the planet upon which all the code ran.