Gutenberg’s press made ten thousand identical copies from one set of type. The monks made one at a time. The 10x reader explosion was not because the content got better — it was because duplication got cheap. The Semantic layer (the text, the meaning) travelled unchanged in every copy. The Gutenberg layer (the press, the type, the ink) made the copying cost approach zero.

The CDN is the same principle at light speed.

Not ten thousand copies on paper — ten thousand edge nodes with identical cached content, distributed across the geography of where the readers actually are. Netflix’s Open Connect appliance sits inside your ISP’s own network. Not in a data centre — inside the network that connects your home. The books are pre-stocked before you ask. The delivery is twenty milliseconds.

The streaming Billy is not that far away.

Gutenberg did not predict the Reformation. He wanted to print Bibles. Berners-Lee did not predict Wikipedia. He wanted hyperlinked documents at CERN. Linus did not predict Android. He wanted a free Unix for his 386. The 10x cannot be predicted — only the conditions that make it possible. Clean waterline. Stable interfaces. Cheap duplication. Movable plates. The gardener who keeps the exits open wakes up one morning to find a forest. The rest of this post is the conditions.

It would be arrogant to plan for the 10x. NAT was not designed as a clean boundary between public internet and private network identity — it was a workaround for IPv4 address exhaustion. Nobody wrote a specification for “NAT as the Gutenberg/Semantic seam.” It arrived because the problem arrived first. Then millions of networks used it. The seam became load-bearing. The accidental boundary became the foundation. IPv6 arrived with a plan to fix it properly — every device a globally unique address, no more NAT. The plan was architecturally correct. The deployed networks ignored it. The accidental seam survived the planned fix because practice had the head start.

Practice makes perfect. Not theory. The 10x always arrives through what does work — the kludge that became the standard, the workaround that became the foundation, the seam nobody planned that turned out to be load-bearing. Create the conditions. Keep the waterline clean. Let the 10x find its own direction. Standardise what practice reveals, not what theory prescribes.

The DVD Was the Original CDN

Netflix started by mailing DVDs. The DVD was the page. Your home was the edge node. The postal network was the distribution protocol. When you wanted to watch it was already there — O(1) retrieval from local cache. Zero latency. Fully owned. Not accessible from elsewhere.

Streaming moved the cache from your living room to the ISP edge. The trade: physical ownership for digital proximity. The DVD in your home was closer. The streaming Billy is close enough that the difference is imperceptible — and it updates itself overnight while you sleep.

The Billy migration:

  • Your living room — zero latency, fully owned, burns with the house
  • Origin server — one location, all traffic goes there, latency varies
  • CDN edge node — many locations, traffic goes to the nearest copy, 20ms
  • ISP-embedded edge — inside your network, approaches living room latency
  • Browser cache — on your device, zero latency, expires and refreshes

Five Billies. Each one closer than the last. Each one the same content. The SHA is the same at every location. The books are identical. The shelf moved closer without the books changing.

The URI Is the VIN. The URL Is the Plate.

The URI is the hardcoded VIN — stamped at manufacture, derived from the content, never changes. urn:isbn:978-0-345-39180-3 is the VIN of the Hitchhiker’s Guide. Every copy. Every shelf. Every language. Same VIN. You cannot move a VIN. Change it and it is a different book.

The URL is the movable licence plate — assigned by the resolver authority, portable across infrastructure changes. https://rinie.github.io/about/ is the plate. DNS maps it to the nearest Billy. Change the CDN provider: update DNS, the URL stays. The plate did not change. The car did.

Your laptop’s IP address is the parking space — assigned by DHCP, valid for the lease duration, returned to the pool when you disconnect. Move to a coffee shop: new parking space, same laptop, same files, same VIN. The DHCP resolver gave you a different space. The car is the same car.

The full resolver stack:

  • VIN / URI / SHA — hardcoded at creation, never moves, identifies the thing itself
  • Plate / URL / hostname — assigned by the resolver authority, movable, identifies current location
  • Parking space / IP / DHCP lease — temporary, reassigned constantly, identifies where the car is right now

DNS resolves the plate to the parking space. DHCP assigns the parking space. The VIN is what the content says it is regardless of either.

URI does not map. URL does:

The URI is a name. urn:isbn:... — no DNS lookup, no server, no fetch. The Semantic identity without any Gutenberg address attached. The ISBN identifies the beer. It does not tell you which shelf it is on.

The URL has DNS built in. The host name resolves. The resolver maps the plate to the current parking space. Change the server: update DNS, the URL keeps working. The channel number stays. The transmitter changes. The viewer never knows.

The confusion to avoid: UUID in a URL is a VIN pretending to be a plate — unique but carries no semantic label, no trust signal, no routing information a human can read. The opaque short link is a plate pretending to be a VIN — routes correctly but the reader cannot evaluate before clicking. Both are muddy waterlines.

The CDN Evolution: No Forced Migration

The URL stayed. The infrastructure changed underneath it — every time, invisibly, without asking:

  • HTTP → HTTPS: same URL, transport encrypted
  • HTTP/2 → HTTP/3: same URL, faster delivery
  • CDN edge nodes moving closer: same URL, lower latency
  • IPv4 → IPv6 at the CDN layer: invisible to the URL

No “please update your links.” No forced migration. No wider track demanded. The DNS resolver updated. The channel guide changed. The viewer kept watching.

This is the dual-track principle at infrastructure scale. Plant the new edge node alongside the old one. Route traffic to the closer one. Retire the further one when it is no longer needed. No downtime. No rewrite.

Can you move your Billy to another iceberg?

If the waterline is clean: yes, trivially. The content is Markdown in git. The Billy is Jekyll on a static host. Moving is a DNS update and a deploy script. GitHub Pages today. Cloudflare Pages tomorrow. The books travel. The shelf changes. The readers never notice.

If the waterline is muddy: moonshot. The WordPress site with proprietary plugins fused to the platform. The Shopify store where product data, customer flows, and theme are all in Shopify’s format. The Medium post where the distribution network stays behind when you export the text. The books travel. The Billy’s network effects do not.

The test: can you git clone it and deploy it elsewhere in an afternoon? If yes — the Billy is moveable. The waterline is clean.

Own your domain. Own your content. Rent the Billy that is closest to your readers. When the CDN enshittifies: point DNS elsewhere. The books travel. The shelf is replaceable.

The SHA Is the Same at Every Edge Node

The CDN cannot corrupt the content — the hash would change. The CSS file at the Frankfurt edge has the same SHA as the Amsterdam edge and the Singapore edge. One SHA. Ten thousand copies. Every copy verifiable. The Gutenberg layer (the CDN, the cache, the edge node) is indifferent to what it carries. It holds the right-sized things. It does not read the books.

This is git’s content-addressing principle applied to global distribution. The SHA is the VIN of every version of every file. Immutable. Content-derived. Verifiable anywhere without phoning home.

The monks charged for copying because copying was expensive. Netflix charges for streaming because they own the Billy that is twenty milliseconds from your TV. The content is unique. The copy is cheap. The proximity is the moat.

The platform that controls the CDN controls the distribution at near-zero marginal cost. The toll booth at zero marginal cost is pure extraction. The monks at least had to pay for the vellum.

HTTP: The Waterline Visible in the Number

HTTP status codes are the simplest possible waterline indicator. Not a comprehensive taxonomy — just enough signal at the right layer.

  • 2xx — Semantic layer succeeded. You got what you asked for.
  • 3xx — Gutenberg layer moved. The content is elsewhere. Follow the resolver.
  • 4xx — Semantic layer failed. The request was wrong. Fix it. Do not retry as-is.
  • 5xx — Gutenberg layer failed. The infrastructure broke. Retry when it recovers.

The waterline is visible in the number. 2xx and 4xx are above it — meaning and intent. 3xx and 5xx are below it — infrastructure and routing.

The 3xx as the URL’s dual-track:

301 Moved Permanently — the plate was reissued. Update your bookmark. The old URL is the forwarding address. 302 Found — temporary. The car is parked elsewhere today. 410 Gone — it existed, it is gone, it is not coming back. The honest dead end. Better than the silent 404.

The 30x codes made URLs evolvable. Old URL keeps working as a forwarding address. New URL becomes the permanent home. No broken bookmarks. No forced migration. The channel redirected. The viewer followed automatically.

Treat 429 as 5xx:

429 Too Many Requests is a 4xx code — but it is a Gutenberg error dressed as a Semantic one.

The request was valid. The meaning was correct. The resource exists. The infrastructure declined to serve it because of a capacity policy — a Gutenberg constraint, not a Semantic failure. The 4xx placement is political, not structural. The API vendor assigned blame to the client. The capacity policy is below the waterline.

Like HTML5 accepting real-world feedback and standardising what actually works — treat 429 as 5xx in your retry logic:

  • Read the Retry-After header
  • Back off and retry at the indicated time
  • Do not treat it as a permanent failure
  • Do not log it as a client error

202 Accepted has the same muddy waterline problem from the other direction. The server accepted the request and told you nothing about what happens next. The honest 202 includes a Location header or job ID — here is the resolver, here is how to find out what happened. The dishonest 202 is the complaint department transferred to a background job with no forwarding address.

The Retry-After header is structural. The status code family is political. Trust the header. Keep the waterline clean.

The Books Are Already There

The streaming Billy is not that far away. The content was written once. The copies are cheap. The SHA is the same at every edge. The DNS resolves the plate to the nearest shelf. The browser caches the copy locally. The next request is zero milliseconds.

The house burns down: git clone. New machine. New Billy. Same books. Same SHA. The content survived because duplication was cheap and the copies were geographically separated. Gutenberg knew this in 1450. The CDN confirmed it in 2026.

The URI is the VIN. The URL is the plate. The IP is the parking space. The content is above the waterline. The shelf is below it. Own the plate. Rent the parking space. Keep the exits open.

The streaming Billy is twenty milliseconds away. The books were already there before you asked.

This post is part of the Gutenberg/Semantic series. Related: Worse Ages Better Than Perfect on Gutenberg enabling the 10x reader explosion, Gutenberg: Your Next Phone Will Be a Different Make on a Different Carrier. Your Number Is Still Yours. on the movable plate, Moore’s Law as an Architectural Principle on collecting the gains for free, Should I Click? Trusting the Letter by the Envelope on the opaque redirect as the removed envelope, and The Complaint Department Has Been Transferred to Another Dimension on enshittification when the resolver becomes a toll booth.