Code: The Hidden Language of Computer Hardware and Software

The argument

The book’s first move is its whole thesis in miniature. Two friends, houses facing across a street, forbidden the telephone after bedtime, want to keep talking. They have flashlights. What they need is not electronics; it is an agreement, a code, and Petzold spends his opening chapters on that distinction. Morse code, with its short common letters and long rare ones, is already a compression scheme. Braille, six dots in a cell, is already a binary encoding, and its number sign and capital indicators, symbols that change the meaning of the symbols after them, are escape codes, the oldest idea in software, invented in the 1830s for fingertips. The lesson is laid down before a single wire appears: code precedes computer. Representation is the primary act; machinery only automates it.

Then electricity, treated with the same patience: circuits, batteries, the telegraph as the first network, and at the telegraph’s heart the component on which the entire book turns. The relay is a switch operated by a current. Its first job was amplification, letting a weak signal from miles away key a strong local one, which is how messages crossed a continent through relay stations that renamed themselves into the word. But its deeper property is the one Petzold builds a computer from: a signal that controls a signal. Once electricity can switch electricity, circuits can make decisions, and the rest of the book is the disciplined exploitation of that single fact.

The middle of the book is the ascent that earns Petzold his reputation. Binary numbers, presented not as computer trivia but as the minimal alphabet, two symbols being the least a code can use and still say anything. George Boole’s algebra of logic, a century-old system for calculating with true and false, and the recognition, which Petzold hands to the reader as Claude Shannon handed it to engineering, that switching circuits obey Boole’s algebra exactly. From there the construction is relentless and completely explicit. Relays wired into gates: AND, OR, NAND, NOR, each a small theorem in metal. Gates composed into a half adder, then a full adder, then a chain of them that adds eight-bit numbers, at which point something that must be called arithmetic is being performed by nothing that could be called a mind. Then the stranger trick: feed two gates into each other and the circuit acquires a past. The latch holds one bit for as long as the power holds, and memory turns out to be feedback, tamed and multiplied. An oscillator, a circuit that contradicts itself forever, provides a beat, and with a clock, counters, and row upon row of latches assembled into addressable memory, all the organs exist.

The assembly is the book’s summit. A machine that fetches a number from memory, interprets it as an instruction, executes it, and moves to the next: opcode by opcode, Petzold builds an automated computer and the reader watches every wire arrive. The instructions are revealed to be one more code, no different in kind from Morse or Braille, and the decision to store them in the same memory as data, the von Neumann arrangement, is shown to be what makes the machine general: programs become information, and the machine can be retasked by writing rather than rewiring. The closing chapters climb the tower upward, relays giving way to vacuum tubes and transistors and integrated circuits, ASCII giving characters their numbers, floating point formats buying range with precision, operating systems layering conveniences over the bare machine, languages compiling human patience into opcodes, and graphics finally painting the whole edifice over with pictures. The hardware changes three times; the argument never changes once. Every layer is a code for the layer beneath, and a person of ordinary intelligence can follow the chain from a spreadsheet cell to a current in a wire, with no step of the descent requiring faith.

There is a quieter lesson threaded through the climb, easy to miss under the engineering: every code is a treaty, and treaties record their wars. ASCII and EBCDIC are not rival answers to one question; they are rival ancestries, one shaped by teletype practice, the other dragging punch-card history behind it, and the machines that adopted each carried the consequences for decades. Floating point buys range by spending precision, and the spending binds everyone downstream who never saw the decision made. Petzold rarely editorializes about any of this, but the reader learns it by construction: a representation, once agreed, outlives every machine that implements it and most of the people who agreed to it.

Working notes

The book’s real subject is epistemology, not electronics. Petzold never asks the reader to trust him; every claim arrives as a construction the reader could, in principle, solder. That is a standard, and once you have felt it you recognize its absence everywhere: in vendor briefings, in architecture reviews, in your own glib explanations of systems you have only used. I keep the book as a calibration instrument. Understanding means being able to rebuild the chain of codes from intention to mechanism; anything less is familiarity wearing understanding’s clothes.

Simon’s account of hierarchy explains why Petzold’s tower stands at all. Systems survive by being nearly decomposable: stable layers with narrow interfaces, each one buildable and testable before the next begins. The gate does not know about the adder; the adder does not know about the opcode. Petzold demonstrates in wiring what Simon argued in theory, that complexity is only constructible as a hierarchy of stable intermediates, and that is as true of an enterprise platform or a fund’s operational stack as of an eight-bit machine.

The detail I return to most is the Braille escape code. A symbol that changes the interpretation of subsequent symbols, invented for reading by touch, decades before electricity did anything useful: context, mode, protocol state, all of it present in a schoolroom code for the blind. Most of what we call software innovation is the rediscovery of representation tricks that are older than the machines, and a man who studies codes rather than products is harder to impress and harder to fool.

One more note, at the book’s expense and mine. Petzold’s standard of understanding was, for one reader with patience, actually attainable in 1999: the whole tower fit in a head. No single head holds the current tower. Understanding at his standard has become a collective possession, distributed across teams and vendors and standards bodies, held entire by no one, and the engineer’s honest position now is to know exactly which floors of his own building he has never visited. The book did not make the stack knowable forever. It made the extent of my ignorance measurable, which is worth nearly as much.

Rereading it now, in the middle of the AI buildout, the book has acquired an edge Petzold did not intend. His tower is honest: every layer opens. The systems I now deploy have, for the first time, a layer that does not: a trained model’s weights can be inspected but not understood, descended into but not followed. That is a genuine break in the epistemic chain the book celebrates, and pretending otherwise is the new form of the magic thinking Petzold spent four hundred pages curing. The cure still applies; it just has to change form, from reading the mechanism to measuring the behavior.

Where I push back

The teaching machine is not the machine on your desk, and the book’s greatest strength manufactures its characteristic injury: false confidence. A reader who has followed Petzold through the adder believes he understands computers, and in the sense that matters for a modern processor, he does not. Caches, pipelines, branch prediction, speculative execution, a memory hierarchy deeper than the whole original machine: these are not the eight-bit machine made bigger, they are qualitatively different engineering, and some of the worst technical decisions I have watched were made by people reasoning confidently from the clean model to the messy artifact. The book should carry the warning its clarity conceals: this is where understanding starts, not where it ends.

The upper floors are also thin. Petzold’s patience is spent by the time the machine boots; operating systems, languages, and everything above them get a survey where the gates got a proof. Fair enough, no book does everything, but the consequence is a shape problem: the book is strongest precisely where modern practitioners least need help, and weakest where the real difficulties now live, in distributed state, in concurrency, in the organizational systems that produce software. Construction as a method stops working at the layer where the components become people.

And comprehension of this kind decays. The book grants a genuine understanding that, unexercised, quietly becomes the memory of understanding, which is more dangerous than ignorance because it answers questions instead of asking them. The reader who finished it a decade ago believes things about his own knowledge that are no longer true. That is not Petzold’s fault. It is a property of his method that an honest reader has to manage, and the maintenance is real work: rebuild an adder on paper, trace one instruction through fetch and execute, or admit that the diploma has expired.

How it enters the work

The descent discipline is the book’s residue in my practice. At Intelliblitz, when a system misbehaves and the room begins theorizing, the working rule is Petzold’s: go down one layer and look. The dashboard is wrong; descend to the query. The query is right; descend to the pipeline. The pipeline is right; descend to the source extract. Almost every durable fix I have shipped was found one layer below where the meeting wanted to talk, and the confidence to keep descending, to insist that the chain of codes is followable all the way down, is something this book installed and client work has never refuted.

It also sets the standard for how we build understanding in teams. Juniors and client engineers learn by construction: build the minimal pipeline by hand before touching the orchestrator, write the SQL before trusting the semantic layer. The Petzold rule is that whoever has built one honest layer beneath his tools cannot be intimidated by them, and unintimidated people ask the questions that save projects.

The sharpest application is the newest. The AI systems I now architect contain the one layer Petzold’s method cannot open, and the book defines the response by contrast: where the mechanism cannot be read, the behavior must be measured. Evaluation harnesses, regression suites for model behavior, logged decisions with the inputs that produced them: this is descent adapted for an opaque layer, engineering’s answer where inspection ends. I tell clients plainly that nobody, including the vendor, understands the model in the sense that Petzold understands the adder, and that the honest substitute is instrumentation. The claim lands because the standard behind it is real. This book is the standard: it is what understanding a machine looks like when it is actually possessed, and it keeps me honest about where, in the new stack, it is not.