How Computers Work

Build any number out of on/off switches, then flip one weight negative and unlock negative numbers.

Three parity bits guard four data bits, each over a different group of positions. Any single flip fails exactly the groups that spell its position, so the receiver can put it back without asking.

A sign, a biased exponent, and a fraction with a hidden leading 1: how 6.3 becomes 6.5 in eight bits, why the error is relative, and where zero, the subnormals, and infinity live.

Six truth tables, wired together: XOR is the sum bit, AND is the carry, and one full adder per column adds two bytes while the carry ripples from the lowest column to the top.

Two NOR gates feeding each other hold a bit for as long as the power is on. Gate it with an enable for a latch; clock two latches and Q changes only on the edge.

Sixteen bytes, four registers, nine instructions: fetch the byte at the program counter, decode its two halves, execute. The adder does the arithmetic, and data runs as code if you let it.

A few lines of fast memory in front of the slow one: an address splits into offset, set, and tag, a hit costs nothing, a miss fetches a block, and whether a program hits is a question of locality.

Five stages, five instructions in flight, one finished per cycle: the assembly line inside a processor, and the data and control hazards that stall it, forward around it, or squash what it fetched.

A pipeline must guess which way a branch goes before it knows: one bit remembers the last outcome, two bits forgive a single surprise, and a history table learns the pattern a loop makes.

A call pushes a frame and a return pops it, free of charge; a block asked for by size comes from a heap of holes that split, merge, and fragment. The two grow toward each other until they meet.

Every address a program uses is a lie the hardware keeps: a page table maps it to a frame, a tiny buffer remembers the last few answers, and a page not in memory is a fault that reads the disk.

Live means reachable from a root. Mark everything the program can still reach, sweep the heap and free the rest, cycles included, then compact if the holes matter.

A call is a line of JSON with a method, params, and an id; the reply comes back under the same id, in any order. Leave the id out and nothing comes back at all. The wire is someone else's problem.

One extra bit makes a line of bits count even, so a single flip is noticed. Lay the bits out as a grid with a parity bit per row and per column, and the failing lines cross at the flip.

A code is a set of words, and what it can do is one number: the fewest positions two of its words differ in. That distance fixes what is noticed, what is undone, and what is perfect.

An eighth parity bit over the whole Hamming word tells one flip from two: a single flip is fixed as before and a double is reported, not mended wrong. ECC memory does this on every read.

The message as a polynomial over GF(2), divided by a generator with shift-and-XOR steps, its remainder sent along: any burst up to the generator's degree leaves a nonzero remainder at the far end.

Treat four-bit symbols as a polynomial over GF(16), append a remainder so the generator's four roots all give zero, and solve four equations to find and undo any two changed symbols.

A burst of noise wrecks the one word it lands on. Write the words into a block by row, send the block by column, and the same burst leaves one flip in every word, which each word can fix.