Resources
Changelog
Subroute grows one topic at a time — each shipped end-to-end with written explanations, live prototypes, and quizzes before it lands here. Newest first.
Leader Election
Latest5 conceptsHow a cluster picks one node to be in charge — and how it picks again when that node falls over. Five algorithms, from the textbook ID-based shouting matches to the lease-and-watcher schemes real coordination services ship.
Open the track →Consensus
7 conceptsHow a cluster agrees on a single answer when nodes die, packets drop, and some machines may even lie. Seven algorithms, from the two-phase commit that everyone learns first to the Byzantine-fault-tolerant PBFT.
Open the track →Circuit Breaker
6 conceptsWhen a downstream service is failing, stop hammering it — fail fast instead. Six variants, from the state machine itself to the trip-condition tweaks that production resilience libraries actually ship.
Open the track →Consistent Hashing
5 conceptsMap keys to servers so that adding or removing a server moves as few keys as possible. Five methods, from the classic hash ring to the table-based hashing inside modern network load balancers.
Open the track →Load Balancing
9 conceptsRun more than one server and something has to decide which one handles each request. Nine algorithms, from a blind counter to capacity-and-load-aware routing — built up one signal at a time.
Open the track →Rate Limiting
5 conceptsControl request throughput so a noisy client cannot starve everyone else. Compare the five canonical algorithms side-by-side.
Open the track →Cache Eviction
10 conceptsWhen the cache fills up, something has to go — and which one you pick decides your hit rate. Ten classic policies, side-by-side.
Open the track →Cache Write Policies
3 conceptsThree ways to handle a write when you have a cache in front of the store. Each policy is a different bet about durability, throughput, and how stale your data is allowed to get.
Open the track →Page Replacement
8 conceptsWhen memory is full and a new page must come in, which page do you throw out? Eight algorithms, from the simple FIFO baseline through the unbeatable Optimal to the LRU approximations real operating systems actually ship.
Open the track →Garbage Collection
8 conceptsHow a runtime reclaims memory you stopped using — without you ever calling free(). Eight algorithms, from the counter on every object to the collectors that run alongside your program.
Open the track →Memory Allocation
6 conceptsBefore garbage collection ever runs, something has to hand out the memory. Six allocators — four ways to pick a hole, plus the two structured schemes real kernels actually ship.
Open the track →Bloom & Cuckoo Filters
3 conceptsThree probabilistic set-membership structures that answer 'have I seen this before?' in a few bytes per item. From the classic bit-array Bloom filter to the counting variant that can delete, to the cuckoo filter that does it all with a smaller memory footprint.
Open the track →Graph Algorithms
10 conceptsHow computers reason about networks of things — roads, friends, packets, dependencies. Ten algorithms, from the two traversals every other algorithm is built on, to weighted shortest paths, minimum spanning trees, and the heuristic search behind every modern pathfinder.
Open the track →Graph Theory
8 conceptsBefore the algorithms, the shapes. Eight kinds of graph — directed and undirected, weighted and not, complete, bipartite, cyclic, and the all-important DAG — and how each property decides what you're allowed to do with the graph.
Open the track →Trees
9 conceptsThe branching data structure under databases, filesystems, autocompletes, and priority queues. Nine trees, from the plain binary search tree through the self-balancing workhorses to the disk-friendly B-trees and the range-query structures competitive programmers swear by.
Open the track →Sorting
10 conceptsOrder a list — ten ways. From the textbook swap-adjacent sorts you write in a single loop, to the divide-and-conquer giants, to the non-comparison tricks that beat O(n log n), to the hybrid your language's sort() actually uses.
Open the track →
Where things are headed next lives on the Roadmap.