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
The code is shaped like the language, and imperfectly.
- 1876-1901 Bit
Five bits cost the same for every letter, so frequency bought holes instead of time.
- 1919 Bit
The output is fed back into the input, and now the circuit remembers.
- 1928 Bit
Eighty columns of holes, and the physics that decided the code.
- 1932-1939 Bit
Send the odd lines, then the even ones, and freeze it to see the comb.
- 1935-1991 Byte
The answer is on both sides of the equation, so it had to be a machine.
- 1937 Bit
An operator is a wiring diagram, and a shift is not a computation at all.
- 1937 Nibble
Each bit adds correctly, and the answer still depends on the bit to its right.
- 1945 Bit
The instructions are numbers, in the same memory as the numbers.
- 1945-1949 Bit
The adder does not know whether the number is negative.
- 1946-1947 Nibble
Every sweep starts at the same point, so repetitions land on each other instead of smearing.
- 1947-1964 Bit
Why a byte is eight, why a nibble is one hex digit, and how the bases fell out of the hardware.
- 1947 Bit
A relay is open or closed; this has a continuous middle, so it amplifies as well as switches.
- 1950s-1970s Nibble
An electromechanical table cannot add, it can only count at the speed of a motor.
- 1950 Nibble
Put the checks at the powers of two and the failures spell the address.
- 1952 Nibble
The two rarest symbols marry, and the tree that falls out is provably the best.
- 1953 Nibble
Half a current does nothing, and reading a bit is what erases it.
- 1953 Nibble
Finding the key is constant time until two keys want the same drawer.
- 1954 Nibble
How a machine stops doing what it was told, and finds its way back.
- 1959 Nibble
A sine, from nothing but shifts and adds.
- 1960 Nibble
Memory becomes garbage when nobody can reach it, not when somebody says it is finished.
- 1961 Nibble
Divide the message by a polynomial and the remainder is what you send.
- 1961 Nibble
The next instruction starts before this one finishes, until it needs something that does not exist yet.
- 1961 Nibble
Every program believes it owns the processor because none of them gets to keep it.
- 1962 Nibble
The address exists even when the memory does not.
- 1962 Nibble
Your program loses the processor, and when it gets it back nothing appears to have happened.
- 1963-1967 Bit
No lowercase until 1967, and then one bit from its capital.
- 1964-1990s Byte
The loop you did not write, and the day it cost to get it wrong.
- 1965 Bit
A straight line, drawn with no division and no fractions.
- 1965-1990s Nibble
Reading memory twice is not the same operation twice.
- 1965 Nibble
Two increments, and the orderings that lose one of them.
- 1968 Nibble
A generator that passes every test you thought to run, and lands on fifteen planes.
- 1970 Nibble
A billion rows, four reads, and the width of a node is the only reason.
- 1971-1995 Byte
You could telnet to port 80 and be the browser, and then you could not.
- 1973-1976 Nibble
Two machines talk at once on one wire, and both wait a random time.
- 1974 Nibble
The label tells the scanner which way up it went across the glass.
- 1975 Byte
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
The secret is not among the things that crossed the wire, and everything that did is on the screen.
- 1977-1981 Nibble
Assembly for a processor nobody built, so one file runs everywhere.
- 1977-2018 Nibble
Colour and resolution are the same currency, and the rate runs both ways.
- 1977 Nibble
The next bytes are a pointer into bytes you have already seen.
- 1978 Nibble
Anyone can check it, and only one person could have made it.
- 1979 Nibble
Five bits is not enough for English, so Zork learned to shift.
- 1979 Nibble
Proof that a leaf is in the tree, without being shown the tree.
- 1980s Byte
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
The processor runs an instruction before knowing whether it should exist.
- 1981-1992 Nibble
The database says done before half the database has been written.
- 1982 Nibble
Scratch the disc and watch a burst come apart into single symbols.
- 1983 Bit
Eight per scanline and the ninth is dropped, which is why they flickered.
- 1983 Nibble
Nobody knows the answer, and everybody knows who to ask next.
- 1985 Nibble
The addition is exact and the answer is still wrong.
- 1988 Nibble
The network never says how fast you may send, so TCP finds out by hurting it.
- 1992-2008 Nibble
History is whatever was most expensive to produce.
- 1992 Nibble
Throw away numbers, not pixels.
- 1992 Nibble
You can start reading in the middle, and that cost a bit in every byte.
- 1993 Nibble
A louder tone beside a quiet one, and the quiet one need not be stored.
- 1994 Byte
The two seconds after the modem stopped screeching, before anything worked.
- 1998 Nibble
Importance defined by importance, and the circle closes if you iterate.
- 2002-2015 Nibble
The sort in every standard library, and the invariant it did not keep.
- 2005 Nibble
A commit holds hashes pointing at hashes, and never holds your repository.
- 2007 Nibble
Wrong on purpose, by an amount it knows before it starts.
- 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.
Thirty-six more are on the bench: 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; DMA, the processor never copied these bytes and they arrived in memory anyway; The Call Stack, a function that calls itself costs memory nobody wrote down, and the depth it dies at is arithmetic; The Shuffle, the obvious way to shuffle a list cannot be fair, and you can prove it by counting rather than by measuring; Packet Switching, the message is cut into pieces that find their own way, so losing part of the network loses nothing; Out of Order, the processor runs the program out of order so that you can watch it run in order; Deadlock, each program is waiting for the other to release the thing it cannot release; Fragmentation, there is enough free memory for the request and the request still fails; SIMD, one instruction, many lanes, and the speedup stops being the number of lanes the moment the data disagrees; DRAM Refresh, the bit disappears unless the machine keeps reading it and writing it back; 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; Compare and Swap, change it only if nobody changed it since you looked; Bloom Filter, no means no, and yes means maybe; The Inode, the filename is not the file; Raster, a picture is a grid of numbers, and a colour is three of them; 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; Avalanche, change one bit and half the answer changes; Sequence Numbers, the stream arrives in order and nothing underneath it is in order; Dithering, the error you cannot remove, pushed into the pixels next door; Logical Clock, the clocks disagree and the machines still agree which event happened first; MVCC, the reader never waits, because it is reading a version nobody is writing; Memory Ordering, both processors wrote first, and both of them still read zero; False Sharing, two cores never touch the same variable and still fight over it; Cache Coherence, two processors both have a copy, one writes, and one of the copies is now a lie; LZW, the dictionary is never sent, and both ends build the same one out of the data; Premultiplied Alpha, the edge of the cut-out is wrong unless you multiply before you blend; Erase Block, the drive cannot overwrite the page you asked it to overwrite; RAID Parity, a whole disk is gone and XOR still knows every byte that was on it; Longest Prefix, three routes match the address, and the longest one wins; TLS Handshake, everybody hears the conversation that agrees the key nobody else has; PNG Filters, the compression happens after something else has made the bytes boring; Gamma, the numbers are not brightness, which is why the average of two of them is the wrong colour; AES, sixteen bytes go in, and every byte that comes out depends on every byte that went in; Majority, a write is permanent before every machine has heard about it; Rowhammer, reading one address changes a different address you never wrote; and Spectre, the instruction never happened, and the cache remembers that it did. logicalart.us →
