Move the pieces.
Watch the code run.

TALLMOVE teaches computer science with interactive demonstrations driven by real, published implementations - every animation is the actual code executing, line by line.

Algorithms & Data Structures

Sorting, searching, graphs, and the machinery behind efficient computation.

20 in review · 15 in progress · 13 planned

Math Foundations

Linear algebra, calculus intuition, and probability - visual and rigorous.

3 in review · 13 in progress · 17 planned

How Computers Work

Bits, logic gates, and how code becomes electrons flipping switches.

1 lesson · 16 in review · 2 in progress · 2 planned

Software Engineering

Code smells, anti-patterns, state machines, concurrency: the concepts behind code that stays reliable.

22 in review · 5 in progress · 9 planned

Databases & Data

How data is stored, queried, and moved - relational, graph, and the pipelines between.

12 in review · 6 planned

System Design

How services scale and survive: caching, queues, replicas, and the trade-offs between them.

7 in review · 8 planned

Game Development

Engines, loops, navigation, and the systems that make simulated worlds tick.

9 in review · 17 in progress · 7 planned

Computer Graphics

From triangles to light: how math becomes the pictures on your screen.

6 in review · 18 in progress · 13 planned

Security & Cryptography

Why math keeps secrets: ciphers, trust chains, and tamper-proof ledgers.

10 in review · 4 planned

Digital Sound & Music

Samples, spectra, synthesis, and the theory behind a tune: how numbers become music.

8 in review · 13 in progress · 20 planned

Machine Learning

Perceptrons to transformers to agents: how a network learns from examples, how a language model reads a sentence, and how a model runs a tool.

10 in progress · 15 planned

Arcs

All arcs

Relational Design

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

Data · 5 lessons

Procedural Generation

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

Games · 13 lessons

The Graphics Pipeline

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

Graphics · 6 lessons

3D from Images

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

Graphics · 11 lessons

Learning Machines

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

Math · ML · 8 lessons

Agents & Tools

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

ML · Computers · 4 lessons

Graph Search to Navigation

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

Algorithms · Games · 6 lessons

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.

Algorithms · 5 lessons

Sound from Scratch

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

Sound · 14 lessons

Audio Effects

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.

Sound · 6 lessons

Design Principles & Smells

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.

Software · 17 lessons

Information Theory

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

Math · Algorithms · Computers · 8 lessons

Error Correction

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.

Computers · Math · 8 lessons

Logic & Reasoning

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

Math · Algorithms · Software · 9 lessons

Secrets & Trust

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

Security · Math · 12 lessons

Languages & Interpreters

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

Software · 5 lessons

Gates to a CPU

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.

Computers · 9 lessons

Memory & Concurrency

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.

Computers · Software · 6 lessons

Inside a Database

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.

Data · 7 lessons

Across Many Machines

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.

Systems · 7 lessons

Multiplayer Netcode

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.

Games · 4 lessons

Core Data Structures

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.

Algorithms · 13 lessons

Sorting

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.

Algorithms · 10 lessons

Compression

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.

Algorithms · Sound · Graphics · 4 lessons

Forces to Flocks

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.

Games · 6 lessons

Color & Images

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.