LEARNING PATH

Understand the systems behind the web

What happens on the other side of a request?

Study processes, virtual memory, and concurrency in sequence. Build the foundation needed to understand network communication and databases.

For web developers who want to understand operating systems and infrastructure

Which components carry out the work between a browser and a server?

Scope and finish line

Every main reading in this course is published and available now.

Steps
24
Main readings
24
Check questions
66

What you will learn to explain

  • Trace a request through processes, memory, networking and database operations.
  • Explain failures and consistency in distributed systems, and reason about the boundaries of permissions, cryptography and containers.

Final main reading: Containers, Namespaces, cgroups, and Orchestration

Complete each step’s main reading and its check, where one is provided. Extra reading and experiments are optional.

See the final step ↓

0 of 24 steps complete

Start learning →

Apply the course in code

After an experiment, apply its rule in a short function and test the result.

Your learning steps

  1. STEP 01Not started

    From Source Code to a Running Program

    Goal: Explain how source code passes through a compiler, interpreter, and runtime before execution.

    Main reading: From Source Code to a Running Program →

  2. STEP 02Not started

    Memory, Pointers, References, and Lifetimes

    Goal: Diagram runtime memory using stacks, heaps, addresses, pointers, and references.

    Main reading: Memory, Pointers, References, and Lifetimes →

    Explore the mechanisms
  3. STEP 03Not started

    Interrupts, I/O, DMA, and Multicore Processors

    Goal: Explain how processors and devices cooperate through interrupts, exceptions, memory-mapped I/O, and direct memory access.

    Main reading: Interrupts, I/O, DMA, and Multicore Processors →

    Explore the mechanisms
  4. STEP 04Not started

    The Kernel, Privilege Modes, and System Calls

    Goal: Explain the protection boundary between user and kernel modes and how a system call crosses it.

    Main reading: The Kernel, Privilege Modes, and System Calls →

    Explore the mechanisms
  5. STEP 05Not started

    Processes, Threads, and Context Switches

    Goal: Explain how processes and threads differ in resource sharing, address spaces, and execution state.

    Main reading: Processes, Threads, and Context Switches →

    Explore the mechanisms
  6. STEP 06Not started

    Virtual Memory, Page Tables, and the TLB

    Goal: Split a virtual address into a page number and offset, and trace translation through page tables and the translation lookaside buffer.

    Main reading: Virtual Memory, Page Tables, and the TLB →

    Explore the mechanisms
  7. STEP 07Not started

    Interleaving, Race Conditions, and Atomicity

    Goal: Enumerate thread interleavings to detect race conditions and lost updates to shared state.

    Main reading: Interleaving, Race Conditions, and Atomicity →

    Explore the mechanisms
  8. STEP 08Not started

    Network Layers, Frames, and Packets

    Goal: Explain why communication is divided into link, network, transport, and application layers.

    Main reading: Understand network layers through one web request →

    Explore the mechanisms
  9. STEP 09Not started

    IP, Subnets, Routing, and NAT

    Goal: Use IP addresses and prefixes to determine whether hosts share a subnet and explain a packet's forwarding path.

    Main reading: Read an IP forwarding table and choose a next hop →

    Explore the mechanisms
  10. STEP 10Not started

    TCP, DNS, HTTP, and Sockets

    Goal: Explain how ordering, retransmission, flow control, and congestion control allow TCP to provide a reliable byte stream.

    Main reading: Connect DNS, TCP, and HTTP in a web request →

    Explore the mechanisms
  11. STEP 11Not started

    The Relational Model, Keys, Normalization, and SQL

    Goal: Model real-world data as relations, tuples, attributes, primary keys, and foreign keys.

    Main reading: Reason about SQL rows, joins, and aggregates →

    Explore the mechanisms
  12. STEP 12Not started

    Pages, Indexes, Joins, and Query Plans

    Goal: Explain how database pages, B-tree indexes, and hash indexes reduce search costs.

    Main reading: Understand indexes and query plans through the work performed →

    Explore the mechanisms
  13. STEP 13Not started

    Transactions, Isolation Levels, MVCC, and WAL

    Goal: Use ACID and isolation levels to explain the guarantees a database provides during concurrent operations and failures.

    Main reading: Choose a transaction boundary and handle concurrent updates →

    Explore the mechanisms
  14. STEP 14Not started

    Filesystems, Buffers, and Persistence

    Goal: Use files, directories, inodes, and blocks to explain the path from a filename to data on storage.

    Main reading: Understand file I/O through names, descriptors, and persistence →

    Explore the mechanisms
  15. STEP 15Not started

    Mutexes, Semaphores, Condition Variables, and Deadlock

    Goal: Trace state changes in mutexes, semaphores, condition variables, and monitors, and explain their different uses.

    Main reading: Locks and condition variables: protect state and wait for change →

    Explore the mechanisms
  16. STEP 16Not started

    Partial Failures, Clocks, Timeouts, and Ordering

    Goal: Distinguish crashes, delays, message loss, and network partitions, and explain why failure is difficult to determine in a distributed system.

    Main reading: Partial Failures, Clocks, Timeouts, and Ordering →

    Explore the mechanisms
  17. STEP 17Not started

    Replication, Consistency Models, and Quorums

    Goal: Explain write paths and failure behavior in single-leader, multi-leader, and leaderless replication.

    Main reading: Replication and consistency: what changes when data has copies →

    Explore the mechanisms
  18. STEP 18Not started

    Consensus, Raft, CAP, and Sharding

    Goal: Explain safety and liveness in consensus, and trace Raft leader election and log replication.

    Main reading: Consensus, Raft, CAP, and Sharding →

    Explore the mechanisms
  19. STEP 19Not started

    Threat Models, Authentication, Authorization, and Access Control

    Goal: Build a threat model by identifying assets, adversaries, trust boundaries, and attack surfaces.

    Main reading: Threat Models, Authentication, Authorization, and Access Control →

    Explore the mechanisms
  20. STEP 20Not started

    Hashes, MACs, Symmetric Encryption, and Randomness

    Goal: Distinguish the properties provided by cryptographic hashes, message authentication codes, symmetric encryption, and authenticated encryption.

    Main reading: Hashes, MACs, Symmetric Encryption, and Randomness →

    Explore the mechanisms
  21. STEP 21Not started

    Public-Key Cryptography, Signatures, PKI, and TLS

    Goal: Explain the different roles of public-key encryption, digital signatures, and key exchange in confidentiality, authenticity, and shared-key establishment.

    Main reading: Public-Key Cryptography, Signatures, PKI, and TLS →

    Explore the mechanisms
  22. STEP 22Not started

    Memory Safety and Web Security

    Goal: Explain the inputs and trust boundaries involved in buffer overflows, use-after-free, injection, cross-site scripting, and cross-site request forgery.

    Main reading: Memory Safety and Web Security →

    Explore the mechanisms
  23. STEP 23Not started

    Isolation, the Trusted Computing Base, and Side Channels

    Goal: Use protection domains, isolation, and the trusted computing base to explain which components a design must trust.

    Main reading: Isolation, the Trusted Computing Base, and Side Channels →

    Explore the mechanisms
  24. STEP 24Not started

    Containers, Namespaces, cgroups, and Orchestration

    Goal: Explain process isolation and resource limits using namespaces, control groups, container images, and runtimes.

    Main reading: Containers, Namespaces, cgroups, and Orchestration →

    Explore the mechanisms

Progress is kept in this browser for the current language. You can read the steps in any order.