A hole punched in card stock in 1928 and a neural network trained in a browser tab are the same idea a century apart. Everything in the studio sits somewhere on that line, and all of it runs. The numbers are live, the failure modes are the real ones, and nothing is faked for the screenshot.
Pieces are sized in three tiers. A bit is one idea, about a minute of your time. A nibble is a single mechanism you can take apart and put back together. A byte is a whole machine, big enough to earn its own domain.
- 1838-1865 Bit
Morse
Letter frequency, turned into dots and dashes. Badly, in places.
- 1876-1901 Bit
Baudot
What happens when every letter costs exactly five bits, however common it is?.
- 1919 Bit
Flip-Flop
Feed a circuit its own output. What does it do now that it could not do before?.
- 1928 Bit
Punch Cards
Eighty columns of holes. Everything had to fit.
- 1932-1939 Bit
Interlace
Odd lines, then even. Freeze the picture to see the comb.
- 1933-1991 Byte
Rangekeeper rangekeeper.dev
The answer is on both sides of the equation, so it had to be a machine.
- 1937 Bit
Bitwise
Every bitwise operator is a wiring diagram. The shift is not even arithmetic.
- 1937 Nibble
The Adder
Every bit adds correctly on its own. The carry is what makes it slow.
- 1945 Bit
Stored Program
Instructions are numbers. They live in the same memory as the data.
- 1945-1949 Bit
Two's Complement
The adder does not know whether the number is negative.
- 1946-1947 Nibble
Trigger
Why the trace stands still.
- 1947-1964 Bit
Bit, Nibble, Byte
Why a byte is eight.
- 1947 Bit
Transistor
A relay is open or closed. This one has a middle.
- 1949 Nibble
Sampling
The same samples fit two different waves, and nothing in them says which one you had.
- 1949 Nibble
The Middle Square
An early way of making random numbers by arithmetic, and it dies: every seed there is falls into one of eight short cycles.
- 1950s-1970s Nibble
Score Reel
An electromechanical table cannot add, it can only count at the speed of a motor.
- 1950 Nibble
Hamming
Put the checks at the powers of two and the failures spell the address.
- 1952 Nibble
Huffman
The two rarest symbols marry, and the tree that falls out is provably the best.
- 1953 Nibble
Core Memory
Half a current does nothing. Reading the bit is what destroys it.
- 1953 Nibble
Hash Table
Finding the key is constant time until two keys want the same drawer.
- 1954 Nibble
The Interrupt
What happens in between two instructions.
- 1956 Nibble
Carry-Lookahead Adder
Stop waiting for the carry to ripple and work out where every carry is born.
- 1957 Bit
Raster
How much picture fits in one bit per square? The first ones found out.
- 1958 Nibble
DMA
The processor never copied these bytes and they arrived in memory anyway.
- 1959 Nibble
CORDIC
A sine, from nothing but shifts and adds.
- 1960 Nibble
The Call Stack
Recursion spends memory that appears in no line of the source. You can work out the exact depth it dies at.
- 1960 Nibble
Garbage
Memory becomes garbage when nobody can reach it, not when somebody says it is finished.
- 1960 Nibble
Reed-Solomon
Erase the bytes you can see are gone and the equations hand them back.
- 1961 Nibble
CRC
Divide the message by a polynomial and the remainder is what you send.
- 1961 Nibble
The Pipeline
The next instruction starts before this one finishes, until it needs something that does not exist yet.
- 1961 Nibble
Round Robin
Every program believes it owns the processor because none of them gets to keep it.
- 1962 Nibble
Page Fault
The address exists even when the memory does not.
- 1962 Nibble
The TLB
If every address must be translated, where does the translation table live?.
- 1962 Nibble
Context Switch
Your program is stopped mid-instruction, its registers are copied somewhere, another program runs for a while, and then everything is put back so precisely that it cannot tell.
- 1963-1967 Bit
ASCII
There was no lowercase until 1967. Then it was one bit away.
- 1964-1990s Byte
Abend abend.dev
The loop nobody wrote. It cost a day.
- 1964 Nibble
The Shuffle
The obvious way to shuffle a list cannot be fair, and you can prove it by counting rather than by measuring.
- 1964 Nibble
Packet Switching
The message is cut into pieces that find their own way, so the network can route around what is gone.
- 1964-1967 Nibble
Out of Order
The processor reorders your instructions, runs them in an order you never wrote, and is required to produce the answer you would have got anyway. Most of the time it manages.
- 1965 Bit
Bresenham
A straight line, drawn with no division and no fractions.
- 1965-1990s Nibble
CPU Cache
Reading memory twice is not the same operation twice.
- 1965 Nibble
FFT
Reusing a sum instead of recomputing it takes n-squared work down to n log n.
- 1965 Nibble
Deadlock
Each program is waiting for the other to release the thing it cannot release.
- 1965 Nibble
Race
Two increments. One of them goes missing.
- 1965 Nibble
Fragmentation
There is enough free memory for the request and the request still fails.
- 1966 Nibble
SIMD
One instruction, many lanes, and the speedup stops being the number of lanes the moment the data disagrees.
- 1968 Nibble
Fifteen Planes
It passes every easy test. Then everything lands on fifteen planes.
- 1968 Nibble
DRAM Refresh
The bit disappears unless the machine keeps reading it and writing it back.
- 1968 Nibble
Regular Expressions
The search holds every state at once, which is why it never has to go back and can never be made to take forever.
- 1970 Nibble
B-tree
A billion rows in four reads. Node width is the whole reason.
- 1970 Nibble
Bloom Filter
No means no. Yes means maybe.
- 1971-1995 Byte
Line Mode linemode.dev
For a while you could telnet to port 80 and be the browser.
- 1971 Nibble
The Inode
The filename is not the file.
- 1972 Nibble
Copy-on-Write
Two processes share the same memory until one of them writes.
- 1973 Nibble
Double Buffer
Why the picture tears.
- 1973 Nibble
Metastability
Catch a flip-flop at the wrong instant and it cannot promise when it decides.
- 1973 Nibble
Avalanche
Change one bit and half the answer changes.
- 1973-1976 Nibble
Backoff
Two machines transmit on the same wire. Both back off for a random interval.
- 1974 Nibble
Checkout
The label tells the scanner which way up it went across the glass.
- 1974-1981 Nibble
Sequence Numbers
The stream arrives in order and nothing underneath it is in order.
- 1974 Nibble
Compare and Swap
Change it only if nobody changed it since you looked.
- 1974 Nibble
Z-Buffer
Draw the triangles in any order and every pixel still keeps the nearest one.
- 1975 Byte
Front Panel frontpanel.dev
A working MITS Altair 8800 you program by flipping switches. The Intel 8080 is written from scratch and passes the four period diagnostics the retrocomputing world uses to settle arguments, including 8080EXM. Panel geometry is measured off the machine's own circuit-board artwork, and BASIC loads the way it did in 1975.
- 1976 Nibble
Diffie-Hellman
The secret is not among the things that crossed the wire, and everything that did is on the screen.
- 1976 Nibble
Dithering
The error you cannot remove, pushed into the pixels next door.
- 1976 Nibble
Arithmetic Coding
The whole message becomes one number in an interval that keeps shrinking.
- 1977-1981 Nibble
Zero Address
Assembly for a processor that was usually not there.
- 1977-2018 Nibble
Fringes
Colour and resolution are the same currency.
- 1977 Nibble
LZ77
The next bytes are a pointer into bytes you have already seen.
- 1978 Nibble
Two-Phase Commit
Everyone promises before anyone acts, and one silent machine blocks them all.
- 1978 Nibble
Signature
How can everyone verify something only one person could have produced?.
- 1978 Nibble
Logical Clock
The clocks disagree and the machines still agree which event happened first.
- 1978 Nibble
MVCC
The reader never waits, because it is reading a version nobody is writing.
- 1979 Nibble
Z-Characters
Five bits is not enough for English. Zork shifted.
- 1979 Nibble
Merkle Proof
Proof that a leaf is in the tree, without being shown the tree.
- 1979 Nibble
Memory Ordering
Both processors wrote first, and both can still read zero.
- 1980s Byte
300 Baud 300baud.dev
A real Bell 103 modem and the BBS on the other end of it. Every tone you hear is generated from bits, and every character you read was recovered from that audio by a detector running in the page. There is no recording anywhere in it.
- 1981-1990s Nibble
Branch Prediction
The processor runs an instruction before knowing whether it should exist.
- 1981-1992 Nibble
Write-Ahead Log
The database says done before half the database has been written.
- 1982 Nibble
Interleave
Scratch the disc and watch a burst come apart into single symbols.
- 1983 Bit
Eight Sprites
Eight per scanline and the ninth is dropped, which is why they flickered.
- 1983 Nibble
DNS
Nobody knows the answer, and everybody knows who to ask next.
- 1984-1990s Nibble
False Sharing
Two threads, two variables, nothing shared. They still fight.
- 1984 Nibble
Cache Coherence
The fourth state is free.
- 1984-1987 Nibble
LZW
The dictionary is never sent. Both ends build it from the data.
- 1984 Nibble
Premultiplied Alpha
The edge of the cut-out is wrong unless you multiply before you blend.
- 1985 Nibble
Floating Point
The answer is already wrong before the addition rounds it.
- 1985 Nibble
Quantum Interference
Measured once it is fifty-fifty, and the same step twice gives one answer every time.
- 1985 Nibble
Spanning Tree
One spare cable and the network drowns; cut the right links and it is safe.
- 1987-1990s Nibble
Erase Block
The drive cannot overwrite the page you asked it to overwrite.
- 1988 Nibble
Slow Start
Nobody tells TCP how fast it may send. It finds out by hurting the network.
- 1988 Nibble
Vector Clock
Each machine counts everyone's messages, so it can tell concurrent from caused.
- 1988 Nibble
RAID Parity
A whole disk is gone and XOR still knows every byte that was on it.
- 1992-2008 Nibble
Longest Chain
History is whatever was most expensive to produce.
- 1992 Nibble
JPEG
Throw away numbers, not pixels.
- 1992 Nibble
UTF-8
Starting to read in the middle costs a bit in every byte.
- 1993 Nibble
Masking
Put a loud tone beside a quiet one, then throw the quiet one away.
- 1993-1995 Nibble
Longest Prefix
Three routes match the address, and the longest one wins.
- 1994 Byte
Winsock winsock.dev
The two seconds after the modem stopped screeching, before anything worked.
- 1996 Nibble
LSM-Tree
Never change a file, write another, then keep rewriting them all.
- 1996-1997 Nibble
PNG Filters
The compression happens after something else has made the bytes boring.
- 1996-1999 Nibble
Gamma
The numbers are not brightness, which is why the average of two of them is the wrong colour.
- 1997 Nibble
Consistent Hashing
Add one more server and almost every key stays where it was.
- 1998 Nibble
PageRank
Importance defined by importance, and the circle closes if you iterate.
- 2001 Nibble
AES
Sixteen bytes go in, and every byte that comes out depends on every byte that went in.
- 2002-2015 Nibble
Merge Collapse
The sort in every standard library, and the invariant it did not keep.
- 2005 Nibble
Merkle DAG
A commit holds hashes pointing at hashes, and never holds your repository.
- 2007 Nibble
Count Distinct
Wrong on purpose, by an amount it knows before it starts.
- 2014 Nibble
Majority
A write counts once most machines have it, and no later majority can miss it.
- 2014 Nibble
Rowhammer
Reading one address changes a different address you never wrote.
- 2018 Nibble
Spectre
The instruction never happened, and the cache remembers that it did.
- 2018 Nibble
TLS Handshake
Everybody hears the conversation that agrees the key nobody else has.
- 2020s Byte
LLM Lab watchitlearn.com
Train a real neural network character by character and watch every number as it learns. Tokenization through backpropagation to a KV-cache explainer, SmolLM2 running in the browser, and a graded diploma at the end.