Notes from the Mystery Machine Bus

Yegge's move is to stop treating each engineering argument on its own terms and notice that the same people keep landing on the same side. Once you see the pattern, the "technical" fights start looking like proxies for one underlying temperament — how much danger you think code represents, and how much machinery you're willing to build to contain it.

The thesis — a risk axis, not politics

Yegge is explicit that he's borrowing the words liberal and conservative as an analogy, not smuggling in Washington. The real variable is how afraid you are of your own software, and how much of your effort you'll spend making it safe before you'll let it run.

"The crux of the disagreement between liberals and conservatives in the software world is this: how much focus should you put on safety? Not just compile-time type-safety, but also broader kinds of "idiot-proofing" for systems spanning more than one machine."— Notes from the Mystery Machine Bus

He compresses the conservative half of the axis into a single line, and it's the load-bearing idea of the whole essay:

"Conservatism, at its heart, is really about risk management."— Notes from the Mystery Machine Bus

The liberal half is the mirror image — not carelessness, but a bet that the cost of ceremony is higher than the cost of the bugs it prevents:

"Liberalism aims to maximize the speed of feature development, while simultaneously maximizing the flexibility of the systems being built, so that feature development never needs to slow down or be compromised."— Notes from the Mystery Machine Bus

The conservative planks

Yegge lays out the conservative worldview as a set of "planks" — the beliefs you'd nod along to if software danger is the thing you feel in your bones. Software is fragile; programmers are fallible; the machinery of types, compilers, schemas, and process exists to catch you before you fall.

• Software should aim to be bug-free before it launches.
• Programmers should be protected from errors.
• Programmers have difficulty learning new syntax.
• Production code must be safety-checked by a compiler.
• Data stores must adhere to a well-defined, published schema.
• Public interfaces should be rigorously modeled.
• Production systems should never have dangerous or risky back-doors.
• Fast is better than slow.

The whole cluster resolves to one uncompromising rule about what earns a place in production:

"If there is ANY doubt as to the safety of a component, it cannot be allowed in production."— Notes from the Mystery Machine Bus, on the conservative planks

The liberal planks

The liberal planks are the same questions answered by someone who believes software is soft — endlessly reshapeable, cheap to fix, and most dangerous when it's too rigid to change. Bugs are a cost of doing business; the real risk is a system too calcified to keep up with the customer.

• Bugs are not a big deal.
• Programmers are only newbies for a little while.
• Programmers figure stuff out amazingly fast when their jobs depend on it.
• Succinctness is power.
• Rigid schemas limit flexibility and slow down development.
• Public interfaces should above all else be simple, backward-compatible, and future-compatible.
• Companies should take risks, embrace progress, and fiercely resist ossification.
• Premature optimization is the root of all evil.

Where the conservative fears the bug, the liberal shrugs at it — the crispest one-line inversion of the whole safety debate:

"Bugs are not a big deal."— Notes from the Mystery Machine Bus, on the liberal planks

Why the lens is useful — most tech fights are really this axis

The payoff isn't the taxonomy; it's the diagnosis. Once you have the axis, a huge share of engineering arguments stop being about their nominal subject. A debate over static vs. dynamic typing, over whether to write the test first, over how much design review a change needs — these aren't independent questions being re-litigated by coincidence. They're the same question, asked in different costumes: how dangerous is this software, and how much do we spend to make it safe? Knowing which side someone sits on predicts their vote before the meeting starts.

It also lowers the temperature. If the real disagreement is a values axis rather than a fact to be won, the goal shifts from "prove them wrong" to "figure out where this codebase should sit" — a bank's ledger and a weekend prototype want opposite ends of it. And Yegge earns the right to draw the map by placing himself squarely on it, no pretense of neutrality:

"I am a hardcore software liberal, bordering on (but not quite) being a liberal extremist."— Notes from the Mystery Machine Bus