Logical Art

Interactive explanations of difficult machines.

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 here sits somewhere on that line, and all of it is working: every number live, every failure honest, nothing faked.

New here? Punch a card takes about a minute. Front Panel (on frontpanel.dev) is the one to sit down with.

Bit
One idea
Nibble
One mechanism in three or four stages
Byte
A complete machine you operate

Showing 42 built

  1. 1838-1865 Bit

    Morse

    The code is shaped like the language, and imperfectly.

    /bits/morse/
  2. 1876-1901 Bit

    Baudot

    Five bits cost the same for every letter, so frequency bought holes instead of time.

    /bits/baudot/
  3. 1928 Bit

    Punch Cards

    Eighty columns of holes, and the physics that decided the code.

    /bits/punch-cards/
  4. 1932-1939 Bit

    Interlace

    Send the odd lines, then the even ones, and freeze it to see the comb.

    /bits/interlace/
  5. 1935-1991 Byte

    Rangekeeper (on rangekeeper.dev)

    The answer is on both sides of the equation, so it had to be a machine.

    rangekeeper.dev
  6. 1937 Bit

    Bitwise

    An operator is a wiring diagram, and a shift is not a computation at all.

    /bits/bitwise/
  7. 1945 Bit

    Stored Program planned

    The instructions are numbers, in the same memory as the numbers.

  8. 1946-1947 Nibble

    Trigger

    Every sweep starts at the same point, so repetitions land on each other instead of smearing.

    /nibbles/trigger/
  9. 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.

    /bits/bit-nibble-byte/
  10. 1947 Bit

    Transistor planned

    A weak signal controls a stronger one, and two of them make NOT.

  11. 1950 Nibble

    Hamming

    Put the checks at the powers of two and the failures spell the address.

    /nibbles/hamming/
  12. 1952 Nibble

    Huffman

    The two rarest symbols marry, and the tree that falls out is provably the best.

    /nibbles/huffman/
  13. 1953 Nibble

    Core Memory

    Half a current does nothing, and reading a bit is what erases it.

    /nibbles/core-memory/
  14. 1954 Nibble

    The Interrupt

    How a machine stops doing what it was told, and finds its way back.

    /nibbles/interrupt/
  15. 1950s-1970s Nibble

    Score Reel

    An electromechanical table cannot add, it can only count at the speed of a motor.

    /nibbles/score-reel/
  16. 1961 Nibble

    CRC

    Divide the message by a polynomial and the remainder is what you send.

    /nibbles/crc/
  17. 1962 Nibble

    Page Fault planned

    The address exists even when the memory does not.

  18. 1963-1967 Bit

    ASCII

    No lowercase until 1967, and then one bit from its capital.

    /bits/ascii/
  19. 1964-1990s Byte

    Abend (on abend.dev)

    The loop you did not write, and the day it cost to get it wrong.

    abend.dev
  20. 1965-1990s Nibble

    CPU Cache planned

    Reading memory twice is not the same operation twice.

  21. 1965 Nibble

    Race

    Two increments, and the orderings that lose one of them.

    /nibbles/race/
  22. 1968 Nibble

    Fifteen Planes

    A generator that passes every test you thought to run, and lands on fifteen planes.

    /nibbles/fifteen-planes/
  23. 1970 Nibble

    B-tree

    A billion rows, four reads, and the width of a node is the only reason.

    /nibbles/b-tree/
  24. 1971-1994 Byte

    Line Mode planned

    You could telnet to port 80 and be the browser, and then you could not.

  25. 1973-1976 Nibble

    Backoff

    Two machines talk at once on one wire, and both wait a random time.

    /nibbles/backoff/
  26. 1974 Nibble

    Checkout

    The label tells the scanner which way up it went across the glass.

    /nibbles/checkout/
  27. 1975 Byte

    Front Panel (on frontpanel.dev)

    A working 1975 Altair 8800 you program by flipping switches.

    frontpanel.dev
  28. 1976 Nibble

    Diffie-Hellman

    The secret is not among the things that crossed the wire, and everything that did is on the screen.

    /nibbles/diffie-hellman/
  29. 1977-2018 Nibble

    Fringes

    Colour and resolution are the same currency, and the rate runs both ways.

    /nibbles/fringes/
  30. 1977 Nibble

    LZ77

    The next bytes are a pointer into bytes you have already seen.

    /nibbles/lz77/
  31. 1977-1981 Nibble

    Zero Address

    Assembly for a processor nobody built, so one file runs everywhere.

    /nibbles/zero-address/
  32. 1978 Nibble

    Signature

    Anyone can check it, and only one person could have made it.

    /nibbles/signature/
  33. 1979 Nibble

    Z-Characters

    Five bits is not enough for English, so Zork learned to shift.

    /nibbles/z-characters/
  34. 1979 Nibble

    Merkle Proof

    Proof that a leaf is in the tree, without being shown the tree.

    /nibbles/merkle-proof/
  35. 1980s Byte

    300 Baud (on 300baud.dev)

    A real dial-up modem and the BBS on the other end of it.

    300baud.dev
  36. 1981-1990s Nibble

    Branch Prediction planned

    The processor runs an instruction before knowing whether it should exist.

  37. 1982 Nibble

    Interleave

    Scratch the disc and watch a burst come apart into single symbols.

    /nibbles/interleave/
  38. 1983 Bit

    Eight Sprites

    Eight per scanline and the ninth is dropped, which is why they flickered.

    /bits/eight-sprites/
  39. 1983 Nibble

    DNS

    Nobody knows the answer, and everybody knows who to ask next.

    /nibbles/dns/
  40. 1985 Nibble

    Floating Point

    The addition is exact and the answer is still wrong.

    /nibbles/floating-point/
  41. 1988 Nibble

    Slow Start

    The network never says how fast you may send, so TCP finds out by hurting it.

    /nibbles/slow-start/
  42. 1992 Nibble

    UTF-8

    You can start reading in the middle, and that cost a bit in every byte.

    /nibbles/utf-8/
  43. 1981-1992 Nibble

    Write-Ahead Log planned

    The database says done before half the database has been written.

  44. 1992 Nibble

    JPEG planned

    Throw away numbers, not pixels.

  45. 1993 Nibble

    Masking

    A louder tone beside a quiet one, and the quiet one need not be stored.

    /nibbles/masking/
  46. 1994 Byte

    Winsock (on winsock.dev)

    The two seconds after the modem stopped screeching, before anything worked.

    winsock.dev
  47. 1998 Nibble

    PageRank

    Importance defined by importance, and the circle closes if you iterate.

    /nibbles/pagerank/
  48. 2002-2015 Nibble

    Merge Collapse

    The sort in every standard library, and the invariant it did not keep.

    /nibbles/merge-collapse/
  49. 2005 Nibble

    Merkle DAG planned

    A commit holds hashes pointing at hashes, and never holds your repository.

  50. 2007 Nibble

    Count Distinct

    Wrong on purpose, by an amount it knows before it starts.

    /nibbles/count-distinct/
  51. 1992-2008 Nibble

    Longest Chain planned

    History is whatever was most expensive to produce.

  52. 2020s Byte

    LLM Lab (on watchitlearn.com)

    Train a tiny language model and watch every number as it learns.

    watchitlearn.com

Why these machines

A hole punched in card stock and a weight in a matrix are the same kind of object: a decision written down somewhere a machine can read it back. Everything here is a point on that line, and the line is the reason the set is what it is.

The big ones are not chosen from a syllabus. Each is something I actually sat in front of. I toggled a program into an Altair through the front panel switches in the late 1970s, and ran bulletin boards in the 1980s when getting online meant listening to a modem negotiate at 300 baud. In college and on contract work I punched decks and leased mainframe time by the hour on an AS/400 and a 9221, in FORTRAN, COBOL, PL/I, RPG and REXX. I served aboard the USS Missouri in Desert Shield and Desert Storm, where the guns were still being aimed by a mechanical analog computer designed in the 1930s. In 1994 I was at Spry when the web stopped being something you had to already be inside. Now I build with language models.

That constraint costs a lot of good subjects, and it buys the one thing this studio is for: I can tell you where the simulation departs from the real machine, because I used the real machine. Every one of them ends with a section saying what is faithful, what is approximated, and what is simply wrong on purpose, with the sources that settle it.

The work is sized in three, named after what they are. The rule about my own history applies only to the largest, which is what lets the small pieces cover subjects that are worth building and are nobody's biography.

Bit
One idea, with nothing in it handing off to anything else. Lives on logicalart.us. 10 here, 8 built
Nibble
One mechanism in three or four stages, each one reachable only through the one before. Lives on logicalart.us. 35 here, 28 built
Byte
A complete machine you operate, on its own domain, with its own sources and honesty ledger. 7 here, 6 built

Nothing here is a video of a machine. If a number is on the screen, something computed it. How that is checked, what counts as a source, and what happens when this is wrong: the method. New machines arrive in the feed.