Sam Rose: Computer Science You Can Play With

samwho.dev contains about nine essays. That is the whole site. It is also one of the best places on the web to learn how computers actually work, and the two facts are related.

Sam Rose has said that each of these posts takes him between one and three months. You can tell. Every diagram moves, most of them respond to you, and none of them are decoration — the animation is doing the explaining, and the prose is mostly there to point at it.

What is samwho.dev?

Sam Rose is a software engineer who has been working on the web professionally since 2012, with time at Google and Budibase along the way, and who is now a senior developer educator at ngrok. He lives in London. The essays are a side project written in evenings and weekends, which makes the production values slightly absurd.

The catalogue covers the load-bearing concepts of computing: Big O, Reservoir Sampling, Turing Machines, Queueing, Bloom Filters, Retries, Hashing, Memory Allocation and Load Balancing.

The house method is bottom-up. Each essay starts from the stupidest version of the thing that could possibly work, shows you why it breaks, and then fixes it — repeatedly. Memory Allocation opens with an allocator that never frees anything, watches it leak, adds a free list, watches fragmentation eat it, adds coalescing, and eventually arrives at slab allocators and inline bookkeeping with boundary tags. By the time you get to the sophisticated design you have personally watched every naive one fail.

Load Balancing does the same climb: round robin, weighted round robin, dynamic weighted round robin, least connections, and finally PEWMA. Rather than asserting which is best, it runs them side by side and reports latency percentiles, which surfaces the genuinely counterintuitive result that round robin posts the best median latency while doing badly where users actually notice — the tail. The simulations are rendered with PixiJS, and the essay is candid that they are simulations, with the simplifications spelled out.

Turing Machines might be the most complete demonstration of the format. The embedded machines play, pause, step forward, step backward, restart and run at adjustable speeds, and Rose built a small browser-based development environment so you can write your own programs and watch them execute against the same visualisation. The illustrations are by his wife, Sophie; the acknowledgements thank reviewers and the people who watched him build it on Twitch.

What can you do on samwho.dev?

• Step through an allocator as it hands out and reclaims memory, with sliders and a clickable grid that respond to arrow keys as well as the mouse.
• Race five load balancing algorithms against each other, then open the playground and change server power, request rate and complexity to see what breaks.
• Write and run your own Turing machine programs in the browser, with reverse-stepping so you can back out of a mistake.
• Add values to a live Bloom filter and test membership, watching the false-positive rate climb as the bit array fills.
• Play the binary search guessing game in the Big O essay, which teaches logarithmic growth by making you the algorithm.
• Compare queue disciplines — FIFO, LIFO, priority, and priority with Random Early Detection — under load you control, measuring drops, timeouts and percentiles.
• Read the source. Everything is client-side, and the visualisations repository is MIT-licensed: vanilla JavaScript in the early pieces, TypeScript compiled with Bun and shipped as custom HTML elements in the newer ones.

The craft details

Small things signal how much care went in. The Bloom Filters essay ships alternate colour palettes for readers with colour vision deficiency, toggleable in the page. It also refuses to fake prerequisites: it tells you to go and read Hashing first, because it needs you to already understand hash functions. Sliders take keyboard input. Every essay ends with named acknowledgements — a dozen reviewers on Bloom Filters alone — which is a decent proxy for how many drafts these went through.

The essays also stay grounded. Bloom Filters explains not just the mechanism but where it is actually deployed: malware detection in Chrome, caching at Akamai, BigTable. Big O ends with three ordinary code problems — swapping a list for a set, unpicking an accidental nested loop, caching a repeated computation — rather than leaving complexity as an interview abstraction.

Rose’s work for ngrok extends the same approach to newer material; his visual explainer on how large language models work, nominally about prompt caching but covering tokenisation, embeddings and transformer basics, was described by Simon Willison as one of the clearest introductions to LLM internals he had seen. That one lives on ngrok’s blog rather than samwho.dev, but it is the same hand.

Honest limitations

The catalogue is tiny, and it will stay tiny, because months per post is not a schedule that produces volume. If you arrive hoping for a curriculum you will leave disappointed — this is nine excellent essays, not a course, with no exercises, no assessment and no path.

The pages are heavy. Dozens of live simulations per article means these want a reasonably modern machine and a screen with room on it. They work on phones, but you lose a lot.

The simulations are also, by design, simplified. Load Balancing says so explicitly, and it is worth remembering before you carry a conclusion from a browser animation into a production capacity plan. And the coverage skews towards systems and algorithms; there is nothing here about, say, compilers or networking protocols.

None of that is really a complaint. This is one person doing something difficult very slowly and very well, and giving it away.

If you like Sam Rose, also try…

• Bartosz Ciechanowski: the same obsessive interactive-explainer instinct applied to the physical world — gears, cameras, GPS.
• Acko.net: Steven Wittens on maths and graphics, explained through live WebGL rather than static figures.
• BetterExplained: intuition before formalism, for the maths underneath all of it.
• Making Software: visual explanations of how the software you use every day is put together.

More things worth reading slowly in our Learning & Education collection.