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
The code is shaped like the language, and imperfectly.
- 1876-1901 Bit
Baudot
Five bits cost the same for every letter, so frequency bought holes instead of time.
- 1919 Bit
Flip-Flop
The output is fed back into the input, and now the circuit remembers.
- 1928 Bit
Punch Cards
Eighty columns of holes, and the code that had to fit inside them.
- 1932-1939 Bit
Interlace
Send the odd lines, then the even ones, and freeze it to see the comb.
- 1935-1991 Byte
Rangekeeper rangekeeper.dev
The answer is on both sides of the equation, so it had to be a machine.
- 1937 Bit
Bitwise
An operator is a wiring diagram, and a shift is not a computation at all.
- 1937 Nibble
The Adder
Each bit adds correctly, and the answer still depends on the bit to its right.
- 1945 Bit
Stored Program
The instructions are numbers, in the same memory as the numbers.
- 1945-1949 Bit
Two's Complement
The adder does not know whether the number is negative.
- 1946-1947 Nibble
Trigger
Every sweep starts at the same point, so repetitions land on each other instead of smearing.
- 1947-1964 Bit
Bit, Nibble, Byte
Why a byte is eight, why a nibble is one hex digit, and how the bases fell out of the hardware.
- 1947 Bit
Transistor
A relay is open or closed; this has a continuous middle, so it amplifies as well as switches.
- 1949 Nibble
The Middle Square
The first 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, and reading a bit is what erases it.
- 1953 Nibble
Hash Table
Finding the key is constant time until two keys want the same drawer.
- 1954 Nibble
The Interrupt
How a machine stops doing what it was told, and finds its way back.
- 1956 Nibble
Carry-Lookahead Adder
Stop waiting for the carry to ripple and work out where every carry is born.
- 1959 Nibble
CORDIC
A sine, from nothing but shifts and adds.
- 1960 Nibble
The Call Stack
A function that calls itself costs memory nobody wrote down, and the depth it dies at is arithmetic.
- 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
Every address has to be translated first, and the translation is itself in memory.
- 1962 Nibble
Context Switch
Your program loses the processor, and when it gets it back nothing appears to have happened.
- 1963-1967 Bit
ASCII
No lowercase until 1967, and then one bit from its capital.
- 1964-1990s Byte
Abend abend.dev
The loop you did not write, and the day it cost to get it wrong.
- 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 runs them in an order you did not write, and the answer is the same.
- 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
Reuse each sum instead of redoing it, and n-squared work becomes 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, and the orderings that lose one of them.
- 1968 Nibble
Fifteen Planes
A generator that passes every test you thought to run, and 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, four reads, and the width of a node is the only reason.
- 1970 Nibble
Bloom Filter
No means no, and yes means maybe.
- 1971-1995 Byte
Line Mode linemode.dev
You could telnet to port 80 and be the browser, and then you could not.
- 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
The frame you are looking at is not the one being drawn, and if you look at the wrong moment you see both.
- 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 talk at once on one wire, and both wait a random time.
- 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 nobody built, so one file runs everywhere.
- 1977-2018 Nibble
Fringes
Colour and resolution are the same currency, and the rate runs both ways.
- 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
Anyone can check it, and only one person could have made it.
- 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, so Zork learned to shift.
- 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, and they fight over one cache line.
- 1984 Nibble
Cache Coherence
Four states instead of three, and the one that was added is free.
- 1984-1987 Nibble
LZW
The dictionary is never sent, and both ends build the same one out of 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
Spanning Tree
One spare cable and the network drowns; cut the right links and it is safe.
- 1988 Nibble
Slow Start
The network never says how fast you may send, so TCP finds out by hurting it.
- 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
You can start reading in the middle, and that cost a bit in every byte.
- 1993 Nibble
Masking
A louder tone beside a quiet one, and the quiet one need not be stored.
- 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 is permanent before every machine has heard about it.
- 2018 Nibble
Spectre
The instruction never happened, and the cache remembers that it did.
- 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.