Skip to content

The curriculum

Six areas of engineering judgment. Each area is a set of paths, and each path is a handful of ideas taken to the depth where you can predict what a system will do and say what it should do.

One path is written and in the private beta. The others are planned, and are listed here so you can see where this is going.

  1. Data in more than one place

    What happens when the same data lives on machines that cannot always reach each other.

    • Replication and consistency modelsplanned
    • Partitions, and what CAP actually saysplanned
    • Clocks, order and causalityplanned
    • Consensus, and what it costsplanned
    • CRDTs and local-first syncin the beta
    • Transactions and isolation levelsplanned
  2. Designing for failure

    Everything fails eventually. These are the ideas that keep a failure small.

    • Timeouts, retries and backoffplanned
    • Idempotency and delivery guaranteesplanned
    • Backpressure and load sheddingplanned
    • Queues, and what they hideplanned
    • Degrading gracefullyplanned
  3. Saying exactly what you mean

    Turning what you know into something a team, or a model, can build from.

    • State machines and statechartsplanned
    • Invariants, preconditions and contractsplanned
    • Modelling a domain in its own wordsplanned
    • Decision tables and the cases nobody listedplanned
    • Writing a spec a model can followplanned
  4. Knowing it is right before you ship

    Ways to find out that a system is wrong while that is still cheap.

    • Property-based testingplanned
    • Deterministic simulation testingplanned
    • Model checking a designplanned
    • Fuzzingplanned
    • Canaries and progressive deliveryplanned
  5. Where data rests

    How bytes are laid out on disk, and what each layout is good and bad at.

    • B-trees and LSM treesplanned
    • Write-ahead logs and durabilityplanned
    • Indexes, and how queries use themplanned
    • Bloom filters, HyperLogLog and Count-Minplanned
  6. How machines talk and wait

    The network and the operating system underneath every request.

    • TCP, loss and congestion controlplanned
    • Event loops: epoll and io_uringplanned
    • Latency, tails and queueingplanned
    • Caches, and what they costplanned

How a path works

A path is a handful of concepts. Each one is taught in four steps: name it, predict what a system will do with it, decide with it in a design choice, and place it in a system you work on. A few days later one new question on it comes back. See the four steps, or try three short exercises.

Follow it as it is written.

Join the beta list and we'll email when an invitation is available.