Arcs

From functional dependencies through the normal forms: why a table splits, and where it stops.

Noise, automata, and grammars that grow terrain, caves, dungeons, and plants from a seed.

Coordinates, cameras, and shaders down to the pixels a triangle covers, and the shadows it casts.

Matched photos to camera poses, point clouds, surfaces, radiance fields, and splats.

Gradient descent to the perceptron, backpropagation, attention, transformers, and diffusion.

How a language model calls tools, loops on their results, and speaks a protocol to reach them.

Breadth-first search to Dijkstra and A*, then the nav meshes and funnels games walk on.

A traversal to build on, then the orders, trees, flows, and ranks a graph yields: nodes peeled off in dependency order, the cheapest tree that touches every node, the most that fits through a network and the cut that limits it, and the fixed point of rank flowing along links.

Samples to oscillators, envelopes, synthesis, spectra, and notes, up to a working sequencer.

A delay line and the echo it makes, that line swept by an oscillator into chorus and flanger, combs and all-passes stacked into a room, three biquads that bend a spectrum, a curve that clips a wave into harmonics, and a follower that turns a loud passage down.

Cohesion, coupling, the Law of Demeter, and Amdahl's law as measures, then the seven code smells a detector can find in a small program and the refactoring that cures each, and six anti-patterns traced the same way, two of them by running the program.

Bits of surprise to the codes that reach them, the cost of a wrong model, and how many bits survive a noisy wire.

One parity bit that notices a flip and a grid of them that places it, codewords far enough apart to tell apart, a word that fixes one flip and reports two, a remainder that catches bursts, arithmetic on four-bit symbols, the code that rebuilds a scratched disc, and the shuffle that turns a burst into single errors.

Truth tables to solvers and provers: how a machine decides what follows from what, and how Prolog turns that into a program.

Ciphers and the number theory under them, then hashes, keys, signatures, certificates, and the handshake that puts them on the wire.

States and automata to regular expressions, parsers, and a tiny language run first by walking its tree, then as bytecode.

Switches to gates, gates to an adder, a loop of gates that remembers, a machine that fetches, decodes, and executes, and the caches, pipelines, predictors, and memory layout that make it fast.

Paged memory and a collector for the heap, then threads sharing it: the race, the locks and the deadlock they bring, the event loop that avoids both, and actors that share nothing.

Tables whose keys point at each other, the B-tree that finds a row, three ways to join two tables and the planner that prices them, then transactions, the log that survives a crash, and the tree that writes in layers.

Clocks that order messages without a wall clock, copies of a record and the reads they serve, a ring that places keys and shards that split a table, then committing across machines, electing a leader that keeps a log, and the choice a partition forces.

Remote players drawn a little in the past, your own moves predicted and reconciled, a server that rewinds to judge a shot, and two machines that guess each other's inputs and roll back when wrong.

How work grows with input, then the structures that keep it small: a sorted array halved, a heap that always knows its minimum, a table that hashes to its slot, sets that merge in a few hops, a tree that rebalances, a list that skips, two arrays that make a set over small integers, a row of bits that remembers what it saw, counters that estimate a stream, registers that count distinct items in a few bytes, a tree whose every version survives, and subproblems solved once.

Swaps of neighbours to the hybrids libraries run: bubble, selection, and insertion sorts, gaps that shrink, halves merged, a pivot, a heap, the runs Timsort stitches, digits sorted in passes, and a network of comparators that sorts with no branches.

Runs of one symbol, pointers back into what was already sent, then cosines that pile a signal's energy into a few numbers and the codec that throws the rest away.

Forces integrated into motion, bodies that notice they overlap, a grid and a tree that find neighbours without checking every pair, the steering forces one agent obeys, and the flock that emerges when many do.

What a pixel's three numbers mean and the curve that bends them, scene light squeezed onto a screen, a look built from balance, lift, gamma, gain, and saturation, that look baked into a lattice and read back by interpolation, and kernels that blur, sharpen, and find edges.