Learn

Start with one of two complete sections, try the AI-serving demo, or see the whole map below. Read each section’s first lesson without an account. Sign in with a verified free account for all remaining lessons and saved progress.

Available foundation sections

Available

How programs execute

From source code to instructions, processes, system calls, and scheduling. Learn to separate work from waiting, then explain a request's complete timeline.

9 lessons · Includes a final investigation

Explore program execution
Available

Memory and data movement

From bytes and object lifetime to virtual memory, caches, data layout, and ownership. Learn why an optimization that avoids copying can retain far more memory than expected.

10 lessons · Includes a final investigation

Explore memory and data
Working demo · Interactive model · No GPU required

The model is fast. Why is the response slow?

Eight requests arrive together. Change the number of worker slots and see how waiting changes.

Explore the demo

The whole map

Thirteen areas and 39 named units. Two complete foundation sections are available; deeper extensions and the other eleven areas are coming soon. Every outline is public; future content remains unavailable even with an account.

01 / Foundations

Two complete starting sections. Broader units show the direction beyond today's foundation scope.

  1. 01Foundation available · 9 lessons
    How programs execute

    Broader area: Computation and operating systems

    Connect source code to execution, operating-system services, and resource sharing.

    First lesson without an account; a verified free account opens the remaining lessons.

    Deeper OS experiments and advanced scheduling are coming soon; the foundation does not cover every operating-system mechanism.

    Broader outline · 3 units
    1. OS-01
      From code to CPU work

      Explain instructions, registers, branches, execution time, and why operation counts alone do not predict elapsed time.

    2. OS-02
      Processes, system calls, and isolation

      Distinguish a process, its address space, file descriptors, and user/kernel execution.

    3. OS-03
      Scheduling and waiting

      Distinguish runnable work, CPU execution, blocking, and wake-up delay.

  2. 02Foundation available · 10 lessons
    Memory and data movement

    Broader area: Memory and data layout

    Reason about where bytes live, how they are accessed, and when movement dominates computation.

    First lesson without an account; a verified free account opens the remaining lessons.

    NUMA, coherence and device-memory extensions are coming soon; the foundation does not cover the whole memory hierarchy.

    Broader outline · 3 units
    1. MEM-01
      Allocation, lifetime, and virtual memory

      Explain stack/heap lifetimes, virtual addresses, page mappings, page faults, and resident memory.

    2. MEM-02
      Caches, locality, and layout

      Predict how access order and data layout affect cache use.

    3. MEM-03
      Copies, bandwidth, and NUMA

      Build a byte-movement budget and distinguish latency from bandwidth limits.

02 / Shared systems

Coordination, persistence, communication and the evidence needed to understand them.

  1. 03Coming soon

    Concurrency and synchronization

    Understand overlapping work, shared-state hazards, and coordination costs.

    View outline · 3 units
    1. CON-01
      Threads, async, and bounded work

      Choose an execution model for CPU work and waiting; explain concurrency versus parallel execution.

    2. CON-02
      Races, locks, and atomics

      Identify an invariant, show an interleaving that breaks it, and apply appropriate synchronization.

    3. CON-03
      Deadlocks, contention, and cancellation

      Diagnose lock ordering, contention, starvation, and unfinished work after cancellation.

  2. 04Coming soon

    Storage and I/O

    Connect application persistence promises to buffering, storage structures, and recovery.

    View outline · 3 units
    1. IO-01
      Files, buffers, and durability

      Distinguish application buffering, page cache, write completion, and durability.

    2. IO-02
      Indexes, pages, and access patterns

      Explain how an index and workload determine page access and write costs.

    3. IO-03
      Logs, checkpoints, and recovery

      Explain write-ahead logging, replay, checksums, and recovery boundaries.

  3. 05Coming soon

    Networking and data movement

    Follow application bytes across transport, kernel, queues, and devices.

    View outline · 3 units
    1. NET-01
      Bytes, framing, and transport semantics

      Explain serialization, byte order, framing, TCP streams, UDP datagrams, and connection lifecycle.

    2. NET-02
      The Linux send and receive paths

      Locate socket buffers, protocol processing, NIC queues, interrupts/polling, and application reads.

    3. NET-03
      Transport and interconnect choices

      Reason about TCP, UDP, QUIC, RDMA, congestion, and host/device data movement by workload.

  4. 06Coming soon

    Distributed systems

    Reason about partial failure and state across independently failing processes.

    View outline · 3 units
    1. DIST-01
      Timeouts, retries, and idempotency

      Explain why a missing reply leaves an operation's outcome uncertain.

    2. DIST-02
      Replication, ordering, and coordination

      Explain stale reads, ordering, leader changes, quorums, and consistency guarantees.

    3. DIST-03
      Queues, durable workflows, and recovery

      Explain acknowledgement boundaries, redelivery, outbox patterns, and recovery state machines.

  5. 07Coming soon

    Measurement and reliability

    Develop a repeatable method for investigating behaviour and validating improvements.

    View outline · 3 units
    1. MEAS-01
      Questions, workloads, and measurements

      Define a hypothesis, representative workload, baseline, warm-up, and reproducible experiment.

    2. MEAS-02
      Profiles, traces, and resource limits

      Use complementary evidence to distinguish CPU, memory, I/O, queueing, and synchronization costs.

    3. MEAS-03
      Capacity, failures, and correctness

      Define useful service objectives and test overload, degradation, and recovery.

03 / AI workload applications

Apply systems reasoning to model computation, accelerators, serving and training.

  1. 08Coming soon

    Model execution

    Make the computation and state behind model inference concrete for software engineers.

    View outline · 3 units
    1. MODEL-01
      Tensors and a small forward pass

      Explain shapes, strides, matrix multiplication, broadcasting, and a minimal computation graph.

    2. MODEL-02
      Autoregressive execution and state

      Explain tokenization, attention, prefill, decode, and why generation retains state.

    3. MODEL-03
      Precision, memory, and quality

      Estimate weight, activation, and state memory; explain precision and quantization tradeoffs.

  2. 09Coming soon

    GPU computing

    Reason about accelerator execution, memory, transfers, and synchronization.

    View outline · 3 units
    1. GPU-01
      Execution and memory hierarchy

      Explain grids, blocks, warps, occupancy constraints, and memory spaces in a specified GPU model.

    2. GPU-02
      Transfers, streams, and synchronization

      Separate host/device transfer, kernel execution, and waiting; understand asynchronous timing.

    3. GPU-03
      Kernel access patterns and profiling

      Reason about coalescing, reuse, arithmetic intensity, and compute versus bandwidth limits.

  3. 10Coming soon

    Inference engines

    Connect model execution to engine scheduling and memory-management decisions.

    View outline · 3 units
    1. ENGINE-01
      Prefill/decode performance models

      Estimate how workload shape changes compute, memory, and state demands.

    2. ENGINE-02
      KV-cache allocation and reuse

      Explain cache lifetime, capacity, fragmentation, paging, and prefix reuse.

    3. ENGINE-03
      Batching and scheduling

      Explain static/continuous batching, admission decisions, fairness, and cancellation.

  4. 11Coming soon

    Serving infrastructure

    Operate the complete request path around a model engine.

    View outline · 3 units
    1. SERVE-01
      Routing, streaming, and cancellation

      Trace a request through gateway, queue, replica, engine, and streamed response.

    2. SERVE-02
      Load balancing, scaling, and overload

      Reason about uneven request cost, queue-aware routing, cold starts, and admission control.

    3. SERVE-03
      Deployments, observability, and recovery

      Use health/readiness, tracing, rollout checks, and rollback to protect service behaviour.

  5. 12Coming soon

    Distributed training systems

    Understand the interaction of compute, communication, data supply, and recoverable training state.

    View outline · 3 units
    1. TRAIN-01
      Parallelism and collective communication

      Explain data, tensor, and pipeline parallelism and the communication each requires.

    2. TRAIN-02
      Input pipelines, overlap, and stragglers

      Locate slow data loading, imbalanced workers, and exposed communication.

    3. TRAIN-03
      Checkpointing and recovery

      Explain which training state must be preserved and the cost of saving it.

04 / Engineering judgment

Bring the mechanisms together in bounded, defensible engineering decisions.

  1. 13Coming soon

    Engineering tradeoffs and integrated investigations

    Turn observations into defensible architecture and operational decisions.

    View outline · 3 units
    1. JUDGE-01
      Performance, cost, and capacity

      Compare systems at a stated workload, quality target, and service objective.

    2. JUDGE-02
      Correctness, quality, and reliability

      Define acceptance criteria before optimizing and identify what can silently regress.

    3. JUDGE-03
      Unfamiliar-system investigation

      Transfer mechanisms to a new case and communicate a bounded conclusion.

Next planned courses

Not available yet. No release dates are promised.

  • Planned

    Where inference time and memory go

    Follow preparation, model execution, retained state, and response delivery; distinguish a useful measurement from a headline number.

    Not available yet — being prepared

  • Planned

    AI networking: follow the bytes

    Trace application buffers, kernel and transport boundaries, and data movement between machines before choosing an optimization.

    Not available yet — being prepared

  • Planned

    Build an inference scheduler

    Explore how admission, batching, and cancellation affect waiting, completed work, and fairness.

    Not available yet — being prepared