From the Transistor to the Token

What this is. Opinion + Experience + Fact (40% opinion · 25% experience · 35% fact). Written in collaboration with AI — I discuss, I do not outsource.

First in a series — "What Actually Happens When…" — tracing the full stack behind the moments that feel instant.

---

1. The quarter-second miracle

You press the power button and a screen appears. You type a web address and a page arrives. You send a chatbot a sentence and an answer comes back. Each of these feels instant — a quarter of a second, maybe less — and each one feels simple. You did one thing; one thing happened.

None of them is simple. Each is a signal falling through dozens of layers of engineering, every layer invented by a different generation of people solving a different hard problem, every layer stacked so cleanly on the one below that you never feel the seams. The reason these moments feel simple is not that they are simple. It is that the simplicity was manufactured — built, deliberately, over eighty years — so that you could forget everything underneath.

This post is the opening of a short series. Over the next few posts I am going to take three everyday moments — pressing power, loading a web page, prompting a model — and fall all the way down the stack with each one, from the thing you touched to the physics at the bottom. This first post is the map: what a "stack" actually is, why we built it in layers, and why the layers disappear from view exactly when they are working. By the end you will have a single mental model that makes all three journeys legible.

I have spent 20+ years building at a lot of these layers — firmware on bare silicon, boards through a factory, cloud services, and lately AI agents on top of all of it. The thing that strikes me, still, is how little any one layer needs to know about the others to work. That is not an accident. It is the central trick of the entire field.

▸ First principle. Every interaction that feels instant is a deep stack pretending to be simple. The simplicity was engineered on purpose.

---

2. Abstraction is the whole story

If you had to compress the history of computing into one word, the word is abstraction. Not the vague, hand-wavy kind — the precise kind. Edsger Dijkstra put it exactly: "The purpose of abstraction is not to be vague, but to create a new semantic level in which one can be absolutely precise."

Here is what that means in practice. The bottom of the stack is physics — electrons, voltage, silicon. Nobody can build an email client out of electrons directly; the gap is too large. So we did not. We built a small, trustworthy layer on top of the physics — the transistor, a switch with no moving parts — and then we agreed to stop thinking about the electrons. Then we built logic gates out of transistors and agreed to stop thinking about transistors. Then arithmetic out of gates, a processor out of arithmetic, an operating system on the processor, a language on the operating system, a framework in the language, an application in the framework. Each layer is a deal: use me through this narrow interface, and you never have to know what I am made of.

That deal is the most productive idea in the history of the field. It is what lets a web developer who has never seen a logic gate ship a product, and a firmware engineer who has never trained a neural network put a model on a microcontroller. Each of us stands on a tower of other people's solved problems and only has to understand the rung we are standing on.

The cost of the deal is that the tower becomes invisible. You stop being able to see how tall it is. Most people using a computer today are standing near the very top, and from up there it genuinely looks like there is nothing underneath — like the screen just does things. The series is, in a sense, an attempt to look down.

▸ First principle. Progress in computing is the art of building a layer so trustworthy that the next person can forget it exists — and be absolutely precise at their own level because of it.

---

3. The tower, named

Let me make the tower concrete, because "layers" stays abstract until you can see the rungs. Here is the stack that sits under the three moments in this series, bottom to top, with what each layer hides and roughly when it arrived. Read it as a climb.

Layer	What it hides	Roughly arrived
Physics — electrons in silicon	the universe	always
The transistor	the physics; a switch with no moving parts	1947
Logic gates	the transistor; AND, OR, NOT	1950s
Microarchitecture	the gates; registers, adders, pipelines	1960s–70s
The instruction set (ISA)	the hardware; a stable contract for software	1964 onward
Firmware / boot	the silicon bring-up; from power to a running CPU	1970s onward
The operating system	the hardware; processes, memory, files	1969–70s
Drivers + protocols	the devices and the wire; networks, buses, sensors	1970s–80s
Languages + runtimes	the machine; human-readable logic	1950s–70s
The web	the network; documents, links, requests	1989–91
Frameworks + applications	the platform; the thing you actually use	ongoing
The model + inference	the algorithm; language as an interface	2017 onward
The token	the model; the unit a prompt is made of	now

Every row is a generation's hard problem, solved well enough that the next generation could build on top without re-solving it. The transistor (1947) made the switch reliable so the gate could forget the physics. The instruction set gave software a stable target so it could ignore which exact chip it ran on. The operating system gave applications memory and files so they could ignore the hardware. The web gave us documents-over-a-network so we could ignore routing. The transformer, in 2017, added the newest rung — language itself as an interface — and most people already treat it as magic, exactly the way people once treated the layers below it.

▸ First principle. The stack is not a metaphor. It is a real ladder of contracts, each rung a solved problem the rung above is allowed to forget.

---

4. Why you forget the layers — and why that is the point

Here is something worth sitting with: the better a layer is, the less you think about it. You do not think about TCP's congestion-control algorithm when a page loads. You do not think about the reset vector when the screen lights up. You do not think about attention heads when a model answers you. The whole point of each of those layers is that you don't have to. Forgetting is not a failure of attention. Forgetting is the feature being delivered.

This is why computing feels like magic to most people and like plumbing to the people who build it. The magic is real — but it is the specific kind of magic that a great abstraction produces: the underlying machinery has been made so dependable that thinking about it would be a waste of your attention. A pilot does not think about combustion. A driver does not think about the differential. A user does not think about the kernel scheduler. Each of those layers earned the right to be ignored by being right, almost always.

But "almost always" is doing a lot of work in that sentence, and it is where builders live. Someone has to remember the forgotten layers — has to hold the whole tower in their head — precisely so that everyone else can keep forgetting it. That is, in large part, what an engineer is: a person who remembers a layer on everyone else's behalf, and who can drop down a rung when the rung below stops behaving.

▸ First principle. A good abstraction earns the right to be forgotten. A builder's job is to remember it on everyone else's behalf.

---

5. Where the towers leak

In 2002, Joel Spolsky named a thing every builder already felt: the Law of Leaky Abstractions — "all non-trivial abstractions, to some degree, are leaky." A layer hides the one below it right up until the moment it can't, and then the thing you were promised you'd never have to think about is suddenly the only thing that matters.

You have lived this even if you have never written code. The web page that loads instantly a thousand times and then one day spins forever — that is the network layer leaking through the browser's tidy abstraction, and now you are thinking about Wi-Fi signal and DNS whether you wanted to or not. The app that works on every phone but one — a driver leaking. The chatbot that is fluent and confident and completely wrong — the model layer leaking, reminding you there is statistics under the conversation, not understanding.

I have spent a meaningful share of my career at the bottom of these leaks. The bug that only appears on the factory line and never on the bench. The field failure that traces back, three layers down, to a power rail that sags for a few milliseconds at boot. When a tower leaks, you cannot fix it from the top. You have to climb down to the rung that actually broke, which means you have to know the rung is there — which means you have to have never fully forgotten it. This is the entire reason the layers are worth understanding even though the point of them is that you can ignore them. You ignore them until you can't, and the day you can't is the day the understanding pays for itself all at once.

▸ First principle. You never have to think about a layer until it leaks. Then you have to think about nothing else — and only the person who remembered it can climb back down.

---

6. Three moments, three descents

So here is the series. Three everyday moments, each one a descent through the tower from the top rung you touched to the physics at the bottom.

You press power, and a screen appears. This is the boot story, and it is the one closest to my own work. Between the button and the first pixel, a chip with no running software has to pull itself up by its bootstraps — a reset vector, a tiny piece of firmware, a bootloader, the linker's careful map of where everything lives in memory, drivers waking up one bus at a time, an operating system or a structured layer above an RTOS taking the wheel, and finally something to draw. From dead silicon to a working system in a few hundred milliseconds. We will do it embedded-first, where the layers are most exposed, and note where a laptop's version differs.

You type google.com, and a page arrives. This is the descent through the network, and it spans the planet. A name becomes an address, an address becomes a route across networks owned by hundreds of strangers, a connection is negotiated and encrypted in a handshake measured in milliseconds, a request crosses the world, a server and its databases assemble an answer, and your browser turns a stream of text into a living page. It is the most-asked question in computing interviews for a reason: almost the entire history of networking is hiding inside it.

You send a prompt, and an answer comes back. This is the newest descent and the deepest in some ways — years of research compressed into the gap between your sentence and the reply. Your words become tokens, tokens become vectors, vectors fall through a stack of attention layers, and a probability over the next token becomes a word, then another, streamed back to you one piece at a time. It is the rung we just added to the tower, and the one most people are standing on without looking down.

▸ First principle. Every one of these moments is the same shape: a signal falling through decades of engineering, fast enough to feel like nothing happened at all.

---

7. Why the climb is worth it now

There has never been a more useful time to understand the tower, because we just added a rung to the top of it and handed it to everyone.

For most of computing's history, the people standing on the top rung — the users — were content to treat everything below as magic, and that was fine. But AI moved the top rung. The model is now an interface that anyone can speak to in plain language, which means the entire population is suddenly standing on the newest, least-understood layer in the whole stack, treating it exactly the way people once treated the operating system and the network: as a thing that simply works, until it doesn't. And it does leak — confidently, fluently, in ways that look like understanding and are not.

The people who will do well in this era are the ones who can move up and down the stack instead of camping on the top of it. Who know that the token has a model under it, the model has math under it, the math has silicon under it, and the silicon has physics under it — and who can drop down a rung when the layer they are standing on starts to leak. That is not nostalgia for the old layers. It is the opposite: it is what lets you use the new one well. You trust an abstraction correctly only when you know what it is hiding.

That is what this series is for. Not to make you an expert in every layer — nobody is — but to make the tower visible, so the next time something feels like magic, you know it is really just engineering, stacked very high, by people who wanted you to be able to forget them.

▸ First principle. The most valuable engineers can move up and down the stack — because they remember the layers everyone else was invited to forget.

So before the series goes layer by layer: which rungs of the tower do you actually understand — and which do you, honestly, treat as magic?

Next in the series: you press power, and four hundred milliseconds later, a screen. Everything that happens in between.

---

Labeled: Opinion + Experience + Fact (40% opinion · 25% experience · 35% fact)

Sources:

• Edsger W. Dijkstra, on abstraction — "The purpose of abstraction is not to be vague, but to create a new semantic level in which one can be absolutely precise."
• Joel Spolsky, "The Law of Leaky Abstractions" (2002)
• Earlier post — The Layer Above Your RTOS Has a Name — one rung of this tower, in detail
• Earlier post — What 20 Years of Firmware Taught Me About AI — why moving across layers is the durable skill

(Written in collaboration with AI — I discuss, I do not outsource.)

New to this labeling? Read the framework → 20+ Years of Ideas. Articulation Is the Craft.

— Ritesh | ritzylab.com

#ComputerScience #EmbeddedSystems #SystemsArchitecture #FirstPrinciples #SoftwareEngineering