algorithms
Algorithms from zero
Know one programming language, know no algorithms. Finish able to solve hard problems with confidence.
Start track →Algorithmic thinking and complexity
How to measure an algorithm's cost before you ever run it.Arrays and strings
The array: a row of boxes, and the patterns that sweep across it.Sorting and binary search
Order unlocks speed: sort once, then find in logarithmic time.Recursion and backtracking
A function that calls itself, and how to explore every option.Hashing
Trade memory for time: answer 'have I seen this?' instantly.Linked lists, stacks, queues
Three ways to hold a sequence, each with its own discipline.Trees
Data that branches, and recursion as the natural way to walk it.Heaps and priority queues
Always reach the smallest (or largest) item first.Graphs
Nodes and edges — how to explore, order, and find shortest paths.Dynamic programming
Solve once, remember, reuse — turning exponential into polynomial.Greedy algorithms
Take the best local choice — and prove it stays best.Problem-solving toolbox
Bits, intervals, and reading a problem to pick the right tool.Build with this track
Guided projects that exercise what you learn here.
Huffman coding
Build a lossless compressor from scratch: construct the optimal prefix-free code tree bottom-up, derive the bit strings, and prove the round-trip is exact and the output is shorter than fixed-width encoding.
JSON parser from scratch
Write a spec-correct recursive-descent parser for JSON — tokenizer, value dispatcher, escape handler, number decoder — and watch every edge case in RFC 8259 become a concrete code path.
Numeric Toolkit
Build the small library every numerical program secretly depends on: vectors, matrices, a linear-system solver, and descriptive statistics — written by you, checked against answers you can verify by hand. This is where the algebra you learned stops being homework and becomes code that other code calls. You'll feel why floating-point arithmetic lies a little, why solving Ax = b is harder than the textbook suggests, and how to prove your own numbers are right.
Pathfinding Route Engine
Four search algorithms, one shared problem: get from A to B across a weighted grid. You'll build BFS, DFS, Dijkstra, and A* on a single graph model, then run them side by side and watch them disagree — DFS lunges into a dead end, BFS floods evenly, Dijkstra crawls outward by cost, A* leans toward the goal. This is where the algorithms unit stops being trivia and becomes a set of tools you choose between, with reasons.
Regex engine
Build a regular expression engine from scratch using Thompson NFA construction and subset simulation — the same technique that makes grep and re2 immune to catastrophic backtracking.
Signals mini
Build a ~100-line reactive signals library (signal/computed/effect) with automatic dependency tracking and glitch-free batched updates — the same model that powers Solid, Preact Signals, and Vue 3.
Skip list
Build a probabilistic ordered data structure that delivers O(log n) search, insert, and delete without the rotation bookkeeping of balanced trees — just layered express lanes through a sorted linked list.
Text diff — Myers algorithm
Implement the Myers diff algorithm from scratch: compute the longest common subsequence, backtrack an edit script, prove minimality, and apply patches so any round-trip is byte-perfect.
Tiny Stack VM
Build the machine that runs the machine. You define a small bytecode instruction set, write an assembler that turns readable mnemonics into bytes, and write the interpreter loop that fetches, decodes, and executes them one at a time. By the end you will have demystified the whole stack between a line of source and a running program — because you wrote every layer of it yourself.
Topological build scheduler
Build a DAG-based task scheduler — like Make or a CI pipeline — that orders jobs by dependency, detects cycles before they deadlock, and identifies which tasks can run in parallel.
Trie autocomplete engine
Build a prefix tree that powers ranked autocomplete — insert words with weights, walk every prefix in O(prefix length + results), and handle tie-breaking deterministically without a database.
Truth-Table Prover
Turn the logic you learned on paper into a working engine: parse a propositional formula into a tree, walk every assignment to build its truth table, and decide whether it is a tautology, satisfiable, or equivalent to another formula. Logic is where rigor becomes mechanical — and writing the machine that checks an argument is the surest way to understand why the argument holds. By the end you'll have a small but honest theorem checker that you trust because you built every step.
Union-Find (Disjoint Set Union)
Build a disjoint-set structure from a naive parent array up to near-constant amortized time — then use it to drive Kruskal's MST algorithm on a weighted graph.
Networking & Protocols
From bits on a wire to TLS 1.3 — the journey of one packet, retold for senior engineers.