The waterline has always been a place in this series — where the split sits. This is the verb: what happens when one side of a stable interface moves and the other benefits for free. A phone upgrade making an old car's dashboard smarter is the vertical case, over time. A rental car you've never touched before instantly having your maps is the horizontal case, across space. Same interface, same waterline, two different axes of the same stability.

DocBook inlines images as base64 text inside the XML stream — a third bigger than the original bytes, and unreachable except by parsing the whole document. OOXML stores images as raw PNGs in a ZIP, addressable by name through a central directory. MTOM fixed SOAP's version of the bloat problem in 2005 and never touched the deeper one: it optimizes one message's attachments, not random access into a document's structure.

A URL resolves to an IP once, coarse and infrequent — one lookup for the whole book. Everything after that is pages, each with its own resolution, hitting whatever cache tier answers fastest. UTF-8 proves exactly which granularity actually matters: it gives up O(1) character indexing entirely, keeps self-synchronizing byte offsets, because a printer asking for page two was never going to ask for character 5,000.

A4 and Letter waste part of the last page so every page can be uniformly addressed. Disk sectors made the identical trade, then doubled eightfold behind a resolver. Memory paging ran the same arc: 512 bytes on DEC systems, then 4KB as the x86 default for forty years — and since November 1, 2025, Android requires 16KB pages for new Google Play apps, with a compatibility mode carrying the old assumption until developers catch up. Same doubling, three unrelated layers, one underlying reason.

malloc() and free() operate at paragraph granularity — one call per allocation, whatever size the caller asks for. What jemalloc, tcmalloc, and mimalloc actually manage underneath is page granularity — arenas, size classes, memory requested from the OS in bulk. Three different strategies, one ABI, swappable with a link flag, because the interface never had to know about pages at all.

ORMs market themselves as solving the impedance mismatch between objects and rows. What they actually do is fuse the two layers instead of isolating the boundary — order.customer.address looks like a field access but it's SELECT-chasing underneath. C++'s vtable coupling does the same thing to memory layout, which is why C's stable, unstandardised-nowhere-else ABI, not C++'s, became the interchange layer every other language builds its FFI against.

A network database stores data as physical pointer chains — a building where the only way from Accounting to Payroll is a specific elevator shaft installed when the building went up. Codd's relational model wasn't 'tables are nice.' It was isolating the Gutenberg/Semantic boundary in exactly one place instead of smearing it across every application. Object databases repeated the network mistake decades later, with better marketing.

Friedrichshafen's T-City spent millions on visible smart-city showpieces starting in 2007 and left the town hall's back-office paperwork untouched. A school principal's own verdict: they'd bought a Porsche and had no money left to fill it with gas. A rural German district on the Dutch border did the opposite — digitised the boring internal workflows first, in 2013, and only then built anything a citizen would see.

Two storage systems launched the same year, 2006, with opposite bets. HDFS was smart — it embedded cluster topology and data-locality scheduling directly into the wire. S3 was dumb — bytes in, bytes out, a bucket name, a signature. The dumb one won, a decade later, not by getting smarter but by staying dumb long enough for the ecosystem around it to out-evolve the one that had to carry its own intelligence everywhere it went.

Before Google, search had two failure modes on offer: Yahoo's exposed category tree, or AltaVista's 40,000 undifferentiated results. Google's interface innovation was refusing both — ten ranked results, a next-page button if you needed more. The ten results also do a second, quieter job: they tell you whether the resolver understood the question at all, before you decide whether to go deeper or start over.

Zigbee2MQTT's network map takes minutes to render and tells you almost nothing when it finishes. Matter's Fabric→Node→Endpoint→Cluster tree makes the same mistake in a different font — the producer's internal structure surfaces as the consumer-facing API. There's a second, less obvious waterline underneath the data one: identity is a label too, and conflating a device's raw key with its identity is the same mistake Thunderbird made with folders.

Python 2 to 3 had a bridge Perl 6 never built, and that comparison still holds. But the actual breaking change was the str/bytes type split, not the internal encoding — UTF-8 internally would have broken exactly the same amount of code. Twelve years later, CPython still hasn't switched, though its own core developers have an open issue proposing exactly that. They had a problem. They shipped something. The problem is still there.

Steve Jobs tried to move the user model instead of the program model — telling iPhone 4 owners to hold the phone differently rather than fixing the antenna. It didn't work, because Joel Spolsky's rule was right: you cannot argue millions of people out of an already-formed grip. Apple gave away bumper cases, then redesigned the antenna in the next model.

Joel Spolsky drew the line in 2000: the user model is what a person already believes about how software works before they ever touch yours. The program model is what the programmer or designer actually built. When they conflict, Joel's rule is blunt — change the program model, because the user model is remarkably hard to move and the program model is the one thing still in your control.

Jeff Dean's 2012 latency table has aged unevenly — SSD random reads got 10x faster, memory bandwidth got 15x faster, but a packet from California to the Netherlands still takes 150ms. That unevenness isn't decay. It's the Gutenberg/Semantic split, measured: technology compounds, physics doesn't, and the one number that never moves is exactly why cloud regions exist.

Paul Ford's 2015 essay for Bloomberg noted, in passing, that Perl 6 had been fifteen years in the making and still wasn't done. Python 3 shipped on schedule and spent a decade being painfully, survivably adopted anyway. Same kind of promise — a strictly better language — two completely different outcomes, and the difference is exactly the resolver this series keeps looking for.

Nielsen found in 1997 that 79% of users scan a page rather than read it word by word — breadth-first as the human default, not the exception. NN/g re-ran the research in 2020, across 13 years and two continents, and the core finding held. Two genuinely new scanning patterns emerged since — evidence the Gutenberg layer changed while the Semantic behavior underneath it didn't.

IKEA's CEO says it plainly: we hate air. Shipping empty space is expensive, so furniture ships disassembled. The same principle applies to data — every unfetched column you pull anyway is air, shipped at a cost, paid every single time. IKEA also explains why to stick to screws when you can't bundle an allen key, and why disposable, ugly SQL beats elegant, precious alternatives.

This series' Def-Push and Use-Pull vocabulary didn't come from nowhere. Kanban had already named the same distinction, in project management terms, years before any of this: work assigned to a person is a push. Work grabbed from a shared backlog when someone's actually ready for it is a pull. The reasoning underneath both is identical.

Joel Spolsky coined the term in 2001 watching Microsoft's Hailstorm. Seven years later he watched the same team pitch the same architecture again, called Live Mesh. The hallmark of an architecture astronaut isn't ambition — it's solving something that looks like the template of a lot of problems, instead of solving an actual one.

Ben Thompson named the pattern in 2015: the winning move on the internet is to modularize the supplier side and integrate the customer relationship. That's the aggregator's whole business model in one sentence — and it's also the clearest possible definition of what a resolver actually does at platform scale.

Acura's 4G hardware still worked when they shut off AcuraLink anyway — their own words: obsolescence was not an issue. That single sentence separates two failures the industry usually blurs together: a real Gutenberg constraint (3G sunset) and a pure Def-Push choice dressed up as inevitability. The OBD port sat there the whole time, a real standard nobody built a safety-feature contract on top of.

Google let you find pages. Spotify let you get music — and before Spotify, iTunes; before iTunes, the MP3; before the MP3, the CD. Netflix let you get movies, and before Netflix, the DVD. Each one was a Def-Push resolver, and every Def-Push resolver eventually takes you for a ride. My phone number is already Use-Pull — I drive it, nobody else does, so it never needs replacing.

The Def's job is to keep the pipe wide and never force the Use side to specialise before it's ready. But Use-specialisation is also taste — a resolver that watches which columns a consumer always selects, which fields it always destructures, can learn that pattern the way a barista learns your usual, without narrowing the pipe for anyone else. SELECT * EXCLUDE/RENAME, opaque handles, and Parquet's range requests are all the same wide pipe, narrowed only where the Use side actually reaches in.

Watch a house or car get built and taste only enters at the end — the electrician and plumber finish without knowing what switch plate or faucet finish you'll pick. No committee designed the junction box dimension. It's the residue of a century of trades hitting the same friction until it stopped. No model, no architect — real-world use, arrived at purely from feedback, doing what a comprehensive standard designed from first principles usually can't.

Three ways to waste the hardware gains: the log cabin (JVM, .NET, Electron), the walled garden (Pascal, Modula, Ada — real modularity, no external resolution), and real-world use (Android's ART, Hejlsberg's TypeScript). Ada earned its walls: safety-critical systems where being cut off from C/Unix is a feature. Rust is the modern proof safety and resolution aren't in tension. And in 2025, Hejlsberg picked Go over Rust for TypeScript's own compiler — pragmatism over the expected theoretically-purer choice, again.

A phone company gets fresh purchase feedback every two years. An oven company gets one every fifteen. Some touchpoints never reach the manufacturer at all — you fuel up weekly and change tyres every few years, both at third parties. And the car's infotainment CPU ages like a phone but sits inside a car's purchase cycle with no consumable-replacement channel — which is exactly why CarPlay won. It borrows a refresh cycle the car industry never built.

Stewart Brand's Site sits at the slow end of the shearing layers because moving a building's foundation is expensive. Cloud made copying an entire environment cheap — minutes and a few dollars instead of months and a construction crew. That single change doesn't just expose a gap in Brand's model. It breaks the assumption the whole ordering was built on, and rollback-to-last-known-good is the direct consequence.

Every Dutch house has a meterkast — one cabinet where the public grid, the water main, the gas line, and the sewer connection all cross into private space at once. Your router's NAT gateway does exactly the same job — a meter for a commodity that doesn't care what crosses, only how much. DHCP is the automated electrician, provisioning every device's private identity fresh on arrival. Stewart Brand's shearing layers have no fence for any of it.

A hi-rail truck has road wheels and rail wheels. On the road, the driver resolves the route continuously — every intersection is a live decision. On the rails, the wheels are engaged and steering disappears entirely. The path was fixed the day the track was laid. Same vehicle, same driver, two completely different relationships to the seam.

Google Maps learned where you live by watching you. Your car's nav has a form field labeled Home. The difference is whether the company thinks the product is finished at the point of sale. BSH's oven app is worse than Samsung's not because it's clumsier, but because BSH was never structurally built to close the loop. And there's a real line between welcome home and I know where you live — Street View draws it at the front door and stops.

A good barista knows your usual after three visits. My connected coffee machine has two years of order history, a camera pointed at the drip tray, and a full sensor suite — and still asks me to pick from a menu at 07:00. The cup is already on the tray. The pattern is already in the log. The usual is already known. It just isn't being used.

Intel owned the iceberg — fab, architecture, roadmap — and out-executed everyone internally until ARM climbed in from outside, from ground Intel never built a resolver for. Borg is the same shape: a monorepo can make breaking changes atomic because every caller is in the same tree. Linux and Chrome can't see their callers, so they freeze APIs and only break them for security holes. Leaders become laggards when the iceberg's quality stops being the test that matters.

Java and .NET reversed DNS hierarchy to guarantee unique names, then stopped — no resolver. A hardcoded package name is structurally identical to a hardcoded IP address: both skip the resolver and bind the Use to the Def's iceberg address. Modularity means the Use can replace the Def by another implementation. Without a resolver, that is not possible.

LDAP stored full identity in a location-lookup system. Email and the web kept the global layer small — just enough to resolve to an IP — and pushed everything else down into the semantic layer. The @ sign marks the boundary. HTTP borrowed the same principle from MIME. The entire web stack runs on that decision.

The seam between content and code should be findable without being obstructive. A white line on tarmac marks the boundary without interrupting the road. A concrete barrier marks it so hard nothing gets through. Erasing the line entirely doesn't remove the edge — it just removes the warning. That's sinkhole UX.

DNS changes are all-or-nothing. The old value is gone the moment the new one propagates. There is no staged rollout, no last known good, no revert. A hijacked record looks identical to a legitimate update. None of this is inevitable — it is a design choice that was never revisited.

A library is a tool in your hold — you call it, you can swap it. A framework calls you, and it comes with an iceberg: the file structure, the routing, the build, the deployment, the whole mental model. The question before you board isn't whether it's a good iceberg. It's whether you can leave when you need to.

Fred Brooks split software complexity into essential and accidental forty years ago. AI eats the accidental kind — eight times more code, only a third more releases. The bricks were never the bottleneck. And if your check concludes the plan was wrong, eight times the bricks just builds the wrong thing faster.

Steve Wozniak walked into a room full of physicists and they didn't recognise him. The waitress did. Expertise points your attention so hard at one layer that you stop seeing the person standing in front of you. The user who can't parse your jargon is often the one seeing the room clearly.

By Stewart Brand's logic, infotainment software should be the fastest-changing part of a car and tires the slowest. The opposite happened. Tires, oil, and fuel got an open, regulated physical seam decades ago. Infotainment never got an equivalent seam at all — it shipped fused to one vertically integrated stack, with no obligation on anyone to keep it current once the warranty lapsed.

tar is stuck in the tape era — read forward or read nothing. zip added a directory at the end and became the container format Office still uses today, XML and all. Parquet does the same trick over the network: ask for the footer, then ask only for the row groups you need. You wrote a chapter. I want to read page 15. That gap is why pages exist.

E07 on a dishwasher tells you nothing. A 747 cockpit tells you everything. Both can be correct for their audience. What's never correct is a car that makes you open the hood to check oil when the dashboard already knows which tire is flat — because the data exists, the resolver was just never wired the last six inches.

A complex system designed from scratch never works and cannot be made to work. Centrally designed protocols start strong and improve logarithmically. Evolvable protocols start weak and improve exponentially. The crossover point is where evolution will tell who suxed less — but only time will tell, because the demo always favours the system that hasn't crossed over yet.

You live in rooms. You build walls. The room is not a collection of bricks — it is the space enclosed by the walls, a consequence of their arrangement. OOP tried to build rooms directly and lost the walls. The house that forgets its walls cannot be renovated. The object model that loses the seam cannot evolve.

Ten router transitions over thirty years. Dialup to fibre. Chrome updated every week. Not one bookmark broke. Not one URL needed updating. The waterline held because DNS, HTTP and the router stayed on the correct seams. Matter and MQTT try to fix the user. The user is not the problem. The seam is in the wrong place.

The microkernel brick did not just say the room sux. It genuinely could not tell which room it was in — and had to ask at runtime, paying a context switch for the question, on every single operation. Why should the brick care? It should not. The room is above the waterline. The brick holds the wall up. That is all.

Waste is the measure the craftspeople use to validate the architect. Below 10%: the seams were correctly drawn, small adjustments, anticipated evolution. Above 10%: the architect made a leap of faith. The floor plan was drawn from theory, not from going to the Gemba. Small iterations keep the corrections small.

Architects do not scale. One architect sets the seams and steps back. Two architects fight about meaning while the craftspeople wait and the user pays for the delay. The bricklayers, carpenters, and electricians just build — they do not challenge the owner about the colour of the bikeshed. Linus does not Def-Push. He only says no, very loud, to waste.

XML fought the web's clean seams and lost. Markdown embraced them and won. Node.js, TypeScript, Electron, and VS Code are the story of what happened when the development ecosystem stopped demanding a wider track and started building on the shelf that was already there.

185 people died in the Ahr valley in July 2021. The flood was forecast 48 hours earlier. The warning reached the authorities. It did not reach the people asleep in the valley. The technology existed. The tradeoff was misjudged — in good faith, with real concerns, at a cost that only became visible after the flood.

Gutenberg's press made identical copies cheap. The CDN made them instantaneous. The streaming Billy is twenty milliseconds from your TV — pre-stocked before you ask, identical at every edge, yours to move with a DNS update. The URI is the hardcoded VIN. The URL is the movable licence plate. The IP address is the parking space. None of them the same thing.

The readable URL is the envelope with an address. The opaque redirect is the envelope with no address. You are not being superficial by not clicking — you are using the trust infrastructure correctly. The platform removed the envelope on purpose. Your hesitation is the system working as designed.

The JVM and CIL tried to be the universal Gutenberg layer but baked the Semantic layer into the substrate. Stack-based instead of register-based. Objects instead of values. A Billy bookcase that accepted CD cases, refused Blu-ray, and had to read every book before it would hold it. WASM got the layers right.

git does not understand your code. It knows file name, line number, bytes changed — the non-semantic index. The Universal Tree Fallacy (UTF) keeps demanding richer structure at the Gutenberg layer. git keeps winning by refusing. If you cannot diff it, it is a dead end street.

Every night the browser patches a zero-day. Every week VS Code improves. Every morning life goes on mostly unchanged. Potholes are small fixes. Zero-days are sinkholes — nobody designed them but you still have to fix them. The Gutenberg layer improving silently while the Semantic layer never notices is Moore's Law working as designed. Fusion and Mars are still thirty years away because they are not pothole problems.

A library is a book on the Billy. A framework is the Billy deciding how to organise your entire house. The framework that demands a wider track with every release is making Brunel's mistake — correctly engineering a better solution and incorrectly assuming the migration cost is someone else's problem. UTF-8 stayed on the same track and put the routing in the freight. Infra changes are very expensive.

The Linux kernel is the Billy bookcase — indifferent, standardised, holds everything. The Linux desktop is the Billy with opinions about your books. Ubuntu took Debian's stable foundation and added its own preferences on top, so you still cannot predict where the waterline is. The result is rafting instead of a boat trip. Android and Chrome OS took the kernel and left the tribal infighting on the mailing list. Debian made the Raspberry Pi stable and a success.

Steve Wozniak appeared on The Big Bang Theory. Penny recognised him immediately. The physicists did not. The 90% signal was in the room. The experts were looking at the wrong layer. This is a post about feedback loops, hex torques, and knowing where your towel is.

Move fast and break things is only fast on the first lap. Every subsequent lap is slower because you are navigating the debris from the last one. Slow and smooth compounds. The pothole fixes accumulate. The floor stays clean. Over five years, the team that never broke anything built more than the team that moved fast.

The watershed moment was never about which operating system was best. It was about commodity catching up. The 386 made ugly Intel viable. OS X put Unix underneath the Mac. The 2007 iPhone was the Doom moment — your phone fast enough to run Unix. By 2024 your phone runs analytical queries faster than a 2004 research cluster. The Linux thread runs through all of it.

Breadth-first traversal is not just a preference or a coding style. It is the instrument that makes pace layers legible. Each horizontal pass holds one speed-band still and flat. The gaps between passes are the seams. Depth-first hides the seams by crossing every layer in one plunge.

You enter and leave the parking lot with your licence plate scanned, not your serial number. The barrier is correctly scoped. Marvin is incorrectly deployed. Every system that makes users work with serial numbers instead of names is asking Marvin to announce the chassis number at the barrier instead of just reading the plate.

A buffer overflow is a Gutenberg violation — you wrote past the physical extent of the medium. A type error is a Semantic error — the text is on the page but doesn't parse as meaningful. Rust is the first mainstream language that keeps the two channels separate by design.

The perfectly designed thing tends to be perfect for yesterday. It spent its whole budget being correct about the requirements as they were when it was designed, and has nothing left over for moving when the ground shifts. Simplicity at the seam is portability through time.

Brooks was right that there is no silver bullet — but he aimed the demand at the layer that could never supply one. The leverage was never a single ten-times leap. It was a cheap, repeatable move at the fast layer, bought as insurance against the next iceberg.

A dislike I carried for thirty years turned out not to be a quirk but a design principle. Breadth-first, flat, weighted toward the reader — from TurboC to a flat token tape, the same stance the whole way down.

The Answer is 42. The Question was lost when Earth was demolished five minutes before the program completed. The computation was perfect. The resolver was never built. You still need a towel at the waterline — not because it solves everything, but because knowing where your towel is means you know which side of the boundary you are on.

41 posts ago I hitched a ride with Claude to examine whether I could see the forest through the trees. Claude knew all the unfashionable backwaters of the internet. Together we arrived at the answer we already knew. Tomorrow: the Question.

The WASM sandbox puts the security boundary in the Gutenberg layer where it can be enforced structurally. The 'do not click external links' policy puts it in the Semantic layer — the user's judgment — where it degrades under pressure and fails predictably at scale. One is engineering. One is hope.

The resolver that presents false certainty is more dangerous than the resolver that honestly says 'I'm not sure.' WhatsApp fraud, npm hijacking, DNS propagation gaps, QR codes, SMS links — all the same problem: the Gutenberg state changed, the Semantic layer did not update, and the resolver showed no ambiguity. The user was taken for a ride.

Muddy Waters sang about power imbalance and the authentic signal buried under noise. Muddy waterlines are the same pattern in software: the Gutenberg/Semantic boundary obscured deliberately so the Use side cannot navigate. The disappearing close button. The cookie banner designed to confuse. Chrome: the user agent that became the server spy.

Alan Cooper's 'The Inmates Are Running the Asylum' names the failure mode precisely: the engineers who built the software are now designing the interface. Not malicious. Genuinely blind to the gap between their own mental model and the user's. Proximity creates blindness. The fix is not smarter engineers — it is exposure to actual users.

Steve Krug's 'Don't Make Me Think' is the Use-Pull manifesto for interface design. Every moment of hesitation is a design failure. Every 'where is the close button?' is a bug. The interface that requires no thought is not simple — it is deeply considered, shaped entirely by the Use signal of what people actually do.

Bore-out is not burnout. Burnout is too much demand. Bore-out is too little meaning — the slow accumulation of capability misallocation that nobody notices until it is well advanced. Marvin the Paranoid Android had a brain the size of a planet and was assigned to park cars. The missing piece was not motivation. It was a resolver between capability and task.

The Gemba is the actual place where work happens. The sticky note next to the monitor is a bug report nobody filed. The workaround in the onboarding documentation is a design failure nobody admitted. Go to where the Use signal is generated. Watch without helping. Get your feet wet at the waterline.

Enshittification is what happens when the platform that built a clean external resolver discovers the resolver is an extractable resource. The Sirius Cybernetics Corporation's complaint department was the first to be transferred to another dimension. Google, Amazon, Apple, and Meta are following the same arc. The structural fix is always the same: open resolvers, portability, and competition.

Your phone number survived every phone you have ever owned and every carrier you have ever used. That is not an accident — it is an external resolver. The mechanism that lets the Gutenberg layer change while the semantic layer stays yours. And it is the model for everything else that should work this way but doesn't yet.

A one-month reflection on how a morning coffee question about ESLint configs became 30 posts on software architecture, deployment practice, and why the user does not sux. What the process itself demonstrated about the framework it produced.

The iceberg moves. Moore's Law moves the Gutenberg layer every few years. The 10% overhead of keeping the waterline clean is what lets you steer. The architect who collapsed the waterline cannot move at all — they go down with the iceberg they optimised for.

Moore's Law doubles the Gutenberg layer every two years. The waterline overhead stays at 10%. Every generation draws a ceiling at the Gutenberg layer and forgets the semantic layer keeps growing. 640K. 65536 code points. Whatever you just said will be enough.

Hadoop, NoSQL, ORMs, object databases — all promised to improve on or replace SQL. All lost. SQL survived because the separation between what you ask (semantic) and how it executes (Gutenberg) was correct from the start. And the DBA tweaking queries five years after the architect left is the proof.

The waterline between your code and the platform it runs on shifts slowly. You do not notice until something degrades. A small fix, five years later, at exactly the right layer, can recover years of lost performance — if the layers were kept separate in the first place.

Scanning for landmarks is O(1). Taking measurements is O(n). The curly brace is the brick that sticks out of the wall. Significant whitespace makes every brick flush — and hides the loose one until brick 98.

Making the technical layer invisible feels like good UX. It isn't. When the seam disappears, the semantic layer has to carry both jobs — and when something breaks, there is nothing to inspect. Legibility at the waterline is a feature, not a leak.

Deprecation is only warranted for security reasons. Old stars fade — you do not outlaw them. Python 3, .mjs, and UTF-16 are what happens when the future expert is arrogant about the past. Dijkstra deprecated goto correctly. The dual-track strategy is how you move fast without breaking things.

The web stack spent thirty years building clean Def-Use seams between HTML, CSS, JS, and HTTP. ES modules, CSS custom properties, and OpenAPI are what made specialist crafts possible. CSS-in-JS was a regression.

Gutenberg 2.1 did not fix the page size — it standardised the range. 512 to 4096 bytes, powers of two, comparable by design. The postman stays fast because the envelope is simple. Deep packet inspection, XML namespaces, and SOAP are what happens when you make the postman read the letter.

Why a bigger page never scales but turning it over does. Books, envelopes, and UTF-8 explained through the separation that Gutenberg got right in 1450.

Your lights do not know your name. Bluetooth PINs, Matter fabrics, and RDF triples all push Gutenberg identifiers across the boundary.

90 percent reasonable, less than 10 percent jerks, less than 1 percent saints. Ten independent users saying the same thing is a bug report.

Gabriel was right that worse beat better. The semantic gap is where evolution happens. Lisp machines, RISC/CISC, C++ versus C and Rust.

A 1988 Atari ST compiler that beat hand-coded assembly by keeping source structure intact. LLVM IR as a newspaper without headlines.

Accept the 10% abstraction overhead. Collect the 2x improvement every few years for free. Portability is a basket option on unknown future hardware.

Competition transmits the Use signal. Monopoly suppresses it. Government has no exit by definition. Lidl kept the supermarket honest.

IPv6 tried to eliminate NAT as an ugly hack. NAT was load-bearing. Chesterton's Fence and Conway's Law explain why removing it failed.

UUIDs belong in databases, not conversations. DNS solved this in 1983. Mum and Mrs Kervel are the same Gutenberg address seen through different semantic contexts.

Boundaries form, stabilise, drift, break, and reset. Unix to POSIX to Android Mainline to WASM. gRPC is CORBA in a hoodie.

Your email address is tied to someone else's domain. Own your domain, make the carrier replaceable. XS4All, Gmail, and enshittification.

Your music survived six formats. Your bank account number has not moved since you opened the account. Why the difference matters.

Exceptions are Def-push error handling. Result/Option and HTTP status codes are Use-pull. Thirty years of the Use signal delivering its verdict.

DuckDB separates storage from SQL cleanly. Parquet on S3, Excel, CSV all queryable with the same SQL. The dual-track strategy done right.

YAML significant whitespace is an O(n) boundary problem. JSON was designed for machines, forced on humans. JSON5 and TOML fix the Use complaints.

The kernel is Use-pull because hardware is an unambiguous oracle. The desktop is Def-push because taste is not. Android shows what Linux desktop could have been.

Sonos broke the semantic layer while the hardware was perfect. Intel's fabs fell behind. Apple switched processors three times by separating the layers cleanly.

Certification as the tribal weapon. Nokia, BlackBerry, and car infotainment all kept users locked in by owning the certification process.

MDI window management as a tribal Def defended for twenty years while tabs won everywhere else.

Authors define, users interpret. The gap between them is where waste lives. Lean Pull, the Train-ing problem, and why the user does not sux.

Every information system operates on two parallel layers: physical/positional (Gutenberg) and logical/meaningful (Semantic). The foundational framework for the series.