How this series is built

The four acts

1. 0

   The Map

   The whole journey once, simplified to the point of being slightly false — and a list of the lies it tells.

2. I

   The Machine Underneath

   Two ideas application developers have never needed: who is running this code, and who owns this memory.

3. II

   Arrival

   From a voltage on a pair of wires to bytes sitting in a queue with your socket’s name on them.

4. III

   The Stream Illusion

   Where packets stop existing, why framing becomes your problem, and how your process gets woken up.

5. IV

   Departure & Payoff

   Sending is not receiving in reverse — and every failure you have ever seen, explained by one picture.

The shape of every post

The same seven beats, every time. The repetition is the pedagogy: once a reader knows where the payoff sits, they stop bracing and start reading.

1. Open on a symptom the reader has hit at work — not a concept.
2. Tell the smallest true story that answers it.
3. Refine: the naive version, why it breaks, what is actually done.
4. Answer the two recurring questions: who owns this memory, which context is running.
5. A diagram where one earns its place, in the same visual grammar as every other diagram.
6. One command they can run and see.
7. What was simplified, and where it gets paid off.

Rules held throughout

Motivation before mechanism

Never "here is the mechanism". Always: here is the obvious design, here is the load at which it collapses, here is what was built instead. A mechanism introduced as an answer is remembered; one introduced as a fact is not.

Engineering history, not taxonomy

Layers are a filing system, not an explanation. Every layer in this stack exists because something hurt. The posts say what hurt.

Lies tracked out loud

Each post simplifies, and each post ends by saying exactly how, with a pointer to where it gets paid off. The difference between a useful model and a confidently wrong one is knowing which edges are drawn in pencil.

No code as exposition

Snippets appear as evidence, never as explanation. But the nouns stay — ring, descriptor, backlog, receive window — because the nouns are the model, and they are what make the reader searchable-literate afterwards.

Concrete numbers, constantly

A 1024-descriptor ring at ten gigabits holds 1.3 milliseconds of full-size frames — and 69 microseconds of minimum-size ones. Two numbers do more for intuition than three paragraphs, and they carry an argument prose would have to make separately: sizing advice that ignores traffic shape is worthless.

Something to run

Every post ends with one command that makes the mechanism visible on a real machine. This is what turns "I read that" into "I believe that".

What this series will never cover

Routing protocols, DNS resolution, what happens to a packet between machines, and anything that requires a second host to explain. Not because they are unimportant — because the node-local story is already a whole book, and it is the half that nobody writes down.