This is part of a series. The Gutenberg/Semantic model describes physical versus logical layers. The Def-Use split describes how authors and users inhabit different semantic models. This post examines a beautiful internal contradiction: the same project name covering the most successful Use-pull infrastructure in history and some of the most spectacular Def-push disasters in open source.

1. The Linux Kernel: Use-Pull at OS Scale

The Linux kernel is Use-pull almost by definition. Linus Torvalds reviews patches on their merits — does this make the kernel better for the hardware it runs on? The feedback loop is the mailing list, the pull requests, the bug reports from real workloads on real hardware.

The kernel’s Gutenberg oracle is unambiguous: hardware either works or it doesn’t. A driver either supports the device or it doesn’t. A scheduler change either improves throughput on real workloads or it doesn’t. Benchmarks exist. Regressions are caught. The Use signal is measurable and largely objective. Tribal identity cannot easily override a benchmark.

The kernel ships every 8-10 weeks regardless of feature completeness, because the feedback loop matters more than the Def being perfect before release. Features get merged because hardware exists and users need them. Features get rejected because they add complexity without measurable Use benefit. This is Build-Measure-Learn at OS layer scale, running continuously since 1991.

Linus is famously protective of certain design principles — no binary-only kernel modules, no breaking userspace, stability of the kernel ABI. These are not tribal aesthetics. They are semantic contracts with the Use layer: your drivers will keep working, your applications will keep running. The Def is held stable precisely where the Use depends on it, and nowhere else.

2. The Linux Desktop: Def Tribe Without an Oracle

The Linux desktop is a different story. GNOME, KDE, and the broader desktop ecosystem have produced some of the most spectacular Def-push failures in open source history — not despite being open source, but in a specific way that open source enables.

The difference from the kernel is the absence of an objective Use oracle. “Does the driver work?” has a binary answer. “Is this a good interface?” does not. In the absence of a measurable Use signal, tribal identity fills the vacuum. The tribe’s semantic model of the correct desktop becomes the Def by default.

GNOME 3 (2011) is the canonical example. The GNOME team removed features that power users had relied on for a decade:

  • Minimise button removed
  • Desktop icons removed
  • System tray removed
  • Traditional taskbar replaced with Activities overview

All in service of a design vision the GNOME tribe considered correct — a cleaner, more focused interface inspired by mobile paradigms. The Use signal was immediate and volcanic. Forum threads, blog posts, mailing list arguments, years of sustained user fury. The response from GNOME leadership was largely “you’ll adapt” and “you’re not our target user.” Classic Def-push: the tribe knows what the correct desktop looks like, and users who disagree are holding it wrong.

Several developers forked GNOME 2 into MATE rather than accept the new Def. Cinnamon was forked from GNOME 3 to restore the removed functionality. The market fragmented — which in Linux desktop terms means the already-small user base split further, weakening every fork. The tribe defended the Def and the Use paid the price.

KDE 4 (2008) followed the same pattern — a ground-up architectural rewrite that shipped before the Use cases were ready, years of instability, users fleeing to GNOME or other environments. The architectural vision was sound. The timing was tribal: the Def was ready (in the tribe’s estimation) therefore it shipped, regardless of whether the Use was ready.

3. Lennart Poettering and the systemd Controversy

No figure in recent Linux history illustrates the Gutenberg/Semantic boundary tension more sharply than Lennart Poettering — the primary author of systemd, PulseAudio, and Avahi, and the most controversial developer in the Linux ecosystem.

The traditional Unix init system (SysV init) was pure Gutenberg philosophy: small programs, shell scripts, each doing one thing, composable via pipes and files. Starting a service was a shell script. Dependencies were managed by numbered runlevels. Transparent, auditable, and — by 2010 — genuinely inadequate for modern hardware with parallel boot, hotplug devices, network-dependent services, and containers. The Gutenberg layer had changed. SysV init was a Gutenberg solution from a different era of hardware.

systemd was Poettering’s answer: replace the entire init system with a unified, integrated service manager that handles service dependencies, socket activation, logging (journald), device management (udev), network configuration (networkd), login sessions (logind), and more. It works. Boot times dropped dramatically. Service management became genuinely reliable. Modern Linux distributions — Debian, Ubuntu, Fedora, Arch — all adopted it.

The controversy is about exactly where the Gutenberg/Semantic boundary should sit.

The pro-systemd position is that the old boundary was wrong. SysV init was too thin — it forced every distribution, every service author, and every administrator to reinvent the same semantic logic (dependency management, failure recovery, logging) in shell scripts. systemd moves that semantic logic into a single well-tested implementation with a stable interface. This is the same argument as fread() versus raw read() — let the library manage the boundary so application code stays clean.

The anti-systemd position is that systemd crossed the boundary too far in the other direction. It is not just an init system — it is an integrated semantic layer that owns too much. journald replaces syslog. networkd competes with NetworkManager and dhclient. logind manages user sessions. Each component individually defensible; the combination creates a semantic monolith that violates the Unix principle of small composable tools. Critics call it “software that describes what it is” — semantic noise baked into the init layer.

Both positions are arguing about the same thing in different vocabulary: where should the Gutenberg/Semantic boundary sit in the boot and service management stack?

Poettering’s tribal problem is distinct from the technical argument. He is a gifted engineer who consistently makes technically sound decisions and consistently alienates the communities his software serves. PulseAudio was genuinely better than ALSA’s userspace audio mixing — and shipped in a state that broke audio for years on many configurations. The Use signal (broken audio is worse than imperfect audio) was overridden by the Def (the new architecture is correct). systemd was technically superior to SysV and shipped with a communication style that treated critics as obstacles rather than Use signals.

The pattern: right about the Def, wrong about the feedback loop. A weak link willing to learn would have shipped PulseAudio as opt-in, measured adoption, and made it default once the Use cases were solid. Instead it was pushed as the default before it was ready, creating years of “why is my audio broken” as the dominant Linux audio experience.

This is the Marissa Mayer problem in reverse: Mayer had the Use signal (clicks) without a Semantic theory. Poettering had the Semantic theory (correct architecture) without respecting the Use signal (working audio). Both are failures of the Def-Use loop, from opposite directions.

4. Why the Kernel Escapes and the Desktop Doesn’t

Both the kernel and the desktop use the same tools: git, mailing lists, pull requests, public code review. Both are nominally open to community feedback. The outcomes are radically different.

The kernel has three properties the desktop lacks:

An objective oracle. Does the hardware work? Does the benchmark improve? Does userspace break? These are answerable questions. The Use signal is measurable. Tribal aesthetics cannot override a failed boot or a performance regression.

Scale of diversity. The kernel community is large enough and diverse enough that no single tribe can dominate. Linus is the final arbiter, but he is one person receiving patches from thousands of contributors across hundreds of hardware platforms and use cases. The cognitive surplus is large enough to drown out any single tribe’s Def. The desktop communities are smaller, more ideologically coherent, and therefore more vulnerable to tribal capture.

Hardware as the Use proxy. When a patch is submitted for a new GPU driver, the GPU manufacturer’s engineers are part of the feedback loop. Hardware vendors have Use-side incentives — their hardware needs to work. This creates a permanent Use-pull force that no desktop community has an equivalent of. Desktop users are diffuse, unorganised, and — unlike GPU manufacturers — cannot submit a patch that says “my workflow broke.”

Clay Shirky’s cognitive surplus works at kernel scale. The desktop is too small a community to escape its own orthodoxy. The tribe sets the Def, the Def sets the roadmap, and users who disagree fork or leave.

5. Android: What Linux Desktop Could Have Been

Android is the Linux desktop done with a Use-signal mechanism built in from the start.

Android uses the Linux kernel — the same Gutenberg layer, the same driver model, the same process isolation. But the semantic layer above it was designed around measurable Use signals: app store ratings, install counts, device manufacturer feedback, carrier requirements, crash reporting. The semantic layer was shaped by what users actually installed and used, not by what a desktop tribe thought the correct interface should look like.

The result is that Android’s semantic layer evolved rapidly and continuously in response to Use, while the Gutenberg layer (the kernel) evolved on its own cadence underneath. The layers were decoupled. Changes in one did not require changes in the other. This is the architecture that Linux desktop never achieved — semantic evolution at Use-pull speed, Gutenberg evolution at hardware-pull speed, clean boundary between them.

The irony is complete: the most widely used Linux desktop in the world is one where the “desktop” tribe had no control over the semantic layer at all.

6. The Lesson

The Linux paradox resolves cleanly through the Def-Use lens:

  • The kernel succeeds because it has an objective Use oracle (hardware), a diverse enough community to prevent tribal capture, and a culture of “does it work?” over “is it correct?”
  • The desktop struggles because it lacks an objective Use oracle, the community is small enough to be captured by a tribe, and the culture rewards architectural correctness over Use-signal responsiveness
  • systemd is right and wrong simultaneously — right about the technical Def, wrong about the feedback loop, which is exactly half of the job
  • Android wins by separating the layers cleanly and putting a Use-signal mechanism at the semantic layer boundary from the start

The weak link willing to learn does not just get the Def right. They build the feedback loop that tells them when the Def needs to change. The kernel has that loop built into its physics. The desktop has to choose to build it. So far, mostly, it has chosen not to.