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
STEP 01Not started From Source Code to a Running Program
Goal: Explain how source code passes through a compiler, interpreter, and runtime before execution.
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
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
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
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
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
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
- Atomicity: choosing an indivisible operation
- Happens-before: causal and synchronization order
- Read memory ordering through publication and synchronization
- Check linearizability from invocation and response histories
- From unlinking a node to reclaiming it safely
- Design thread pools from slots, queues and dependencies
- Separate cancellation delivery from cleanup ownership
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
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
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
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
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
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
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
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
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
- Cache stampede: a burst of recomputation
- Retry storms: recovery traffic that expands a failure
- Idempotent requests: retry without duplicating effects
- Bound additional load with a retry budget
- Propagate remaining request time
- Shed load to protect useful completion
- Isolate resource occupancy with bulkheads
- Trace circuit-breaker suppression and recovery
- Compare refreshed and propagated deadlines across three services
- Trace logical clocks and causality
- Assign logical clocks to an event DAG
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
- Linearizability: explaining operations as instantaneous effects
- Serializability: explaining concurrent transactions sequentially
- Consistency models: what a read is allowed to observe
- Preserve send intent with a transactional outbox
- Trace outbox restart and receiver deduplication
- Commit received identity and effect with an inbox
- Reason about failures in distributed transactions
- Design saga compensation and unresolved states
- Separate command and query responsibilities with CQRS
- Reconstruct state from authoritative event history
- Read through replica lag and required positions
- Reason about stream time and late events
- Compare batch and stream processing for the same sales
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
- Raft replicated logs: separating storage, commitment and application
- Consistent hashing: limit placement changes as membership changes
- Split brain
- Quorum intersection and fault tolerance
- Trace partitioning and live rebalancing
- Shard by ranges while handling boundaries and skew
- Limit placement changes with consistent hashing
- Choose owners with rendezvous hashing
- Measure hash-placement changes for fixed keys
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
- Build a threat model from assets and data flows
- Trust boundaries: checking data before relying on it
- Design authority transfer with capabilities
- Mandatory access control: policy beyond an owner’s sharing choice
- Observe read-handle authority and shared file state
- Trust boundaries in signed software updates
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
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
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
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
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.