An interactive course
Learn programming from the ground up — by breaking things on purpose
No experience needed. Not even a little. We start with what a program actually is, and end with a database, a web server and a language interpreter you wrote yourself.
Most courses hand you code and tell you it works. This one asks you to guess what the code will do before you run it — and then you run it and find out. When your guess is wrong, that's not a setback. That's the entire point: a wrong guess shows you exactly which idea in your head needs fixing, and you'll remember the fix for years.
Every chapter is one page. You read a bit, you type a bit, you make a prediction, you get a surprise. Each page remembers where you got to, so you can close the tab and come back later.
Work through the chapters in order — each one leans on the one before it. One chapter per sitting is about right. Keep a terminal open next to the page, because you'll be typing real commands from the very first chapter.
Phase 0Foundations — how a program actually runs
The ground floor. This phase assumes nothing at all: not that you've written code, not that you've opened a terminal, not that you know what a file is. Everything later in the course stands on this, so we pour the concrete properly.
8 chapters · ends with a game you can play
Flagship project: a working Wordle you build yourself, in the terminal.
Phase 1Objects, properly
Most courses teach objects as vocabulary — class, object, inheritance. This phase teaches them as machinery: what an object is while your program runs, what a variable actually holds, and why two things that look equal sometimes aren't.
By the end of Phase 0 your Wordle code is a pile of loose methods and arrays, and it has started to feel unwieldy. That feeling is the argument for this phase. Nobody should have to take "objects are useful" on faith.
6 chapters · builds a JSON library from scratch
Flagship project: json-java — a parser and an object mapper, written by hand.
What comes afterThe rest of the road
Phase 0 is the beginning of a much longer path. Each phase ends with a real project that forces its ideas to hold up under pressure — and every phase leans on the ones before it. Here's the shape of it; the full map, with the reasoning for the order, is one page away.
| Phase | What you learn | What you build |
|---|---|---|
| 1 | Objects, properly — what they are in memory, not just the vocabulary | A JSON library from scratch |
| 2 | Data structures & algorithms, written by hand | Your own version of Java's collections |
| 2.5 | Using what you built — the patterns and tools that make coding problems tractable | gauntlet, a judge you solve 60 problems through |
| 3 | C — pointers and memory, everything Java hides | Your own malloc |
| 4 | The JVM itself — bytecode, garbage collection, JIT | A class-file parser |
| 5 | Concurrency — threads, locks, and why they're hard | A thread pool and a concurrent cache |
| 6 | Systems from scratch | A web server, a database, an interpreter, a mini-git |
| 7 | Backend engineering for real | A service built only from your own parts |
| 8 | Publishing | The site generator that renders this course |
Every output shown in this course was produced by actually running the code on JDK 17 — never written from memory. Where a chapter simplifies something, it says so and points at the chapter that tells the full truth. Where we got something wrong and fixed it, the correction stays on the page with its date, because seeing which claims turned out to be fragile teaches you more than a tidy final version does.