The map
Ten phases, and why they're in this order
You do not need to read this page to start. It's here for when you want to know how far the road goes — and why each stretch comes where it does.
Every phase ends with a project that forces its ideas to hold up under real use. And every phase leans on the ones before it — which is the whole reason the order matters. You can't write a database until you understand files and memory. You can't understand memory until you've held a pointer. You can't hold a pointer until you know what a variable is.
So we go bottom-up. Slowly at first, then faster, because each phase makes the next one easier than it looks.
Nothing in this course is ever "used but not explained". If a phase relies on something, an earlier phase built it. That's the difference between knowing how to use a tool and knowing how the tool works.
Phase 0 · available nowFoundations — how a program actually runs
The ground floor. Assumes nothing: not that you've written code, not that you've opened a terminal, not that you know what a file is. If you have programmed before, it still has surprises — most working developers have hairline cracks down here.
8 chapters · builds wordle-cli, a playable game
Phase 1 · available nowObjects, properly
Most courses teach objects as vocabulary — class, inheritance, polymorphism. This phase teaches them as machinery: what an object is while the program runs, what a variable really 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.
8 chapters · builds json-java — a JSON parser and object mapper from scratch
- 1.1 A variable never holds an object available
- 1.2 Two fivers are the same money available
- 1.3 A square is not a rectangle available
- 1.4 The compiler reads your angle brackets, then throws them away available
- 1.5 A crash is an object you can catch available
- 1.6 A program can read its own classes available
- 1.7 Build a JSON library available
- 1.8 Finish JSON available
Phases 2–8The rest of the road
Each of these is a phase in its own right, with chapters and a project. They get harder, but never by skipping a step.
Phase 2 — Data structures, written by hand
builds collections-lite
Lists, hash tables, trees, heaps, graphs — implemented from nothing, measured honestly, then compared against Java's own versions. Afterwards you read the real HashMap source and understand it, because you wrote one.
Phase 2.5 — Reaching for the right tool
builds gauntlet, a local judge you then live in
The bridge. Every other phase builds something and then uses it — Phase 2 was the exception, where you write a hash map from scratch and never pick one up again. Knowing how one works and reaching for one under time pressure are different skills, and this phase teaches the second.
It is also what makes coding-platform problems tractable: the tools you built as tools, Big-O you measured yourself, sorting with a comparator, and the handful of patterns that unlock most of the list — two pointers, sliding windows, counting with a hash map, binary search on an answer, and BFS on a grid. Then about 60 problems, grouped by pattern rather than by difficulty, run through a judge you wrote.
Phase 3 — Down to the metal, in C
builds libds.c, then your own malloc
Everything Java hides, held in your hands once: pointers, manual memory, what a struct looks like in bytes. Writing your own memory allocator is the moment the machine stops being magic.
Phase 4 — The JVM itself
builds classfile-parser
Bytecode, class loading, garbage collection, and the just-in-time compiler that makes long-running Java fast. You'll parse real .class files with your own code — the same files Phase 0 taught you to make.
Phase 5 — Concurrency
builds threadpool and concache
Threads, locks, and the rules of the Java Memory Model — the actual rules, not folklore. Then a cache you can hammer from a hundred threads at once without it corrupting itself.
Phase 6 — Systems from scratch
builds httpd, kvstore, lox-java, git-lite
The phase everything else was preparing for. A web server from raw sockets. A database with a write-ahead log and crash recovery you test by killing the process. An interpreter for a small language. A working subset of git.
Phase 7 — Backend, production shape
builds depthboard
Authentication, caching, job queues, rate limiting — assembled into one service made only from parts you wrote yourself, then deliberately overloaded to see where it bends.
Phase 8 — Publishing
builds pressgen
A static site generator, in Java. Its first job is to publish this course — the pages you're reading get rendered by a program you wrote. A fitting last exam.
The methodHow a phase actually ends
A phase is finished when three things are true, in this order:
- The project runs, and has tests you wrote.
- Its write-up reads like something you'd send a colleague — not notes to yourself.
- You can explain the core ideas without looking.
Then, and only then, the next phase starts. Depth over pace: a phase is done when its ideas feel obvious in hindsight, not when the calendar says so.
Every output in this course was produced by actually running the code on JDK 17 — never written from memory. Where a chapter simplifies, it says so and points at the chapter with the full truth. Where something was wrong and got fixed, the correction stays on the page with its date. Seeing which claims turned out to be fragile teaches more than a tidy final version does.