Operating Systems Roadmap

What an OS is for, and what happens between ./server and the first instruction on a CPU: the loader, the address space, and why one executable on disk is not the same thing as the three instances running from it.

• What an Operating System Is ForNot startedLearningPracticingMastered
• Follow a Program: from `./server` to the First InstructionNot startedLearningPracticingMastered
• Program versus ProcessNot startedLearningPracticingMastered
• The Process Memory LayoutNot startedLearningPracticingMastered

A process has an identity, an address space, a state, open resources and a parent. The process table, the state machine from Runnable to Zombie, and fork + exec as the two halves of "start a program".

• The Anatomy of a ProcessNot startedLearningPracticingMastered
• Process StatesNot startedLearningPracticingMastered
• Creating Processes: fork, exec, waitNot startedLearningPracticingMastered

Several flows of control inside one address space; concurrency as interleaving versus parallelism as simultaneous cores; and how C++, JavaScript/TypeScript and Python each map "do many things at once" onto OS threads, event loops and async I/O.

• Threads: Several Instruction Streams in One ProcessNot startedLearningPracticingMastered
• Process versus ThreadNot startedLearningPracticingMastered
• Concurrency versus ParallelismNot startedLearningPracticingMastered
• Threads versus Async versus ProcessesNot startedLearningPracticingMastered
• How C++, JavaScript and Python Map onto the OSNot startedLearningPracticingMastered
• The Event LoopNot startedLearningPracticingMastered
• Async I/O: What `await readFile()` Actually DoesNot startedLearningPracticingMastered

A hundred runnable tasks and eight cores: ready queues, time slices, priority and preemption, and what a context switch actually saves, restores and throws away (registers, the TLB, the cache).

• The Scheduling ProblemNot startedLearningPracticingMastered
• Scheduling Simulator: FCFS, Round Robin, PriorityNot startedLearningPracticingMastered
• Context SwitchingNot startedLearningPracticingMastered

Why a program cannot write to the disk itself: the user/kernel boundary, the trap into kernel mode, what a syscall costs, and why "mostly system time" in top is a diagnosis in itself.

• System CallsNot startedLearningPracticingMastered
• User Mode vs Kernel ModeNot startedLearningPracticingMastered

A filename is not a file: paths, directories, metadata and permissions; the per-process descriptor table (and what FD 3 is); how a path becomes blocks on storage; and inodes on Unix-style systems.

• Files, Paths and NamesNot startedLearningPracticingMastered
• File DescriptorsNot startedLearningPracticingMastered
• File Systems: From Path to BlocksNot startedLearningPracticingMastered
• InodesNot startedLearningPracticingMastered

Where a local variable lives, where an object lives, why recursion has a limit and what malloc/new/an object allocation actually asks the kernel for — then the illusion underneath: every process believes it owns a huge private, contiguous memory.

• Stack vs HeapNot startedLearningPracticingMastered
• Stack FramesNot startedLearningPracticingMastered
• Stack OverflowNot startedLearningPracticingMastered
• What Happens When I Allocate Memory?Not startedLearningPracticingMastered
• Why Virtual Memory?Not startedLearningPracticingMastered
• The Virtual Address SpaceNot startedLearningPracticingMastered

How the illusion is built: pages and frames, multi-level page tables, the TLB that makes translation affordable, page faults as the normal mechanism (not an error), memory pressure and swapping, mmap, and copy-on-write behind a fast fork().

• PagingNot startedLearningPracticingMastered
• Page TablesNot startedLearningPracticingMastered
• The TLBNot startedLearningPracticingMastered
• Page FaultsNot startedLearningPracticingMastered
• Memory Pressure, Swap and the OOM KillerNot startedLearningPracticingMastered
• Memory MappingNot startedLearningPracticingMastered
• Copy-on-WriteNot startedLearningPracticingMastered

Follow one read() from the call through the page cache to the SSD and back; blocking, non-blocking, asynchronous and multiplexed I/O; select/poll versus epoll/kqueue; and why a file, a pipe and a socket are the same kind of thing to the kernel.

• Follow a File ReadNot startedLearningPracticingMastered
• Blocking, Non-blocking, Multiplexed, AsynchronousNot startedLearningPracticingMastered
• I/O Multiplexing: select, poll, epoll, kqueue, IOCPNot startedLearningPracticingMastered
• Everything Is I/ONot startedLearningPracticingMastered

Two threads add one to a counter and the result is one: the zoo of concurrency bugs, why a race is a property of the interleaving and not of the code, and the critical section as the thing every fix protects.

• A Taxonomy of Concurrency BugsNot startedLearningPracticingMastered
• Race ConditionsNot startedLearningPracticingMastered
• Critical SectionsNot startedLearningPracticingMastered

The tools that make a critical section safe — mutexes, counting semaphores, atomic compare-and-swap — and the four ingredients that turn a lock into a deadlock, with the wait-for graph that finds it.

• MutexesNot startedLearningPracticingMastered
• Semaphores and Condition VariablesNot startedLearningPracticingMastered
• Atomic OperationsNot startedLearningPracticingMastered
• DeadlocksNot startedLearningPracticingMastered

Two isolated processes need to talk: pipes, shared memory, message queues, signals and sockets compared on speed, isolation, complexity and local-versus-remote.

• IPC: Deliberate Holes in Process IsolationNot startedLearningPracticingMastered
• Pipes: A Kernel Buffer Between Two ProcessesNot startedLearningPracticingMastered
• Shared Memory: Zero Copies, Zero ProtectionNot startedLearningPracticingMastered
• Signals: Asynchronous Notifications From the KernelNot startedLearningPracticingMastered

What the kernel actually hands you when you call socket(): a descriptor with send and receive buffers behind it, a state machine, and the bridge into the Networking domain.

• The Socket: A Descriptor With Two Kernel Buffers Behind ItNot startedLearningPracticingMastered

A container has no kernel of its own, so what isolates it? Namespaces, control groups and layered filesystems on a shared host kernel — and how that differs from a hypervisor running a whole guest OS.

• Containers Are Processes With the Kernel’s View NarrowedNot startedLearningPracticingMastered
• Process Isolation: One Kernel, Many PID 1sNot startedLearningPracticingMastered
• VM vs Container: Where the Boundary IsNot startedLearningPracticingMastered

Break a simulated OS on purpose, then learn the playbook for high CPU, high memory, hangs and EMFILE; the capstone explains a 50,000-connection server layer by layer, and the together lessons follow send() across the wire to a recv() on another machine.

• The OS Simulator: Cores, Processes, RAM, I/O and LocksNot startedLearningPracticingMastered
• Break the OS: Predict, Break, DiagnoseNot startedLearningPracticingMastered
• The OS Debugging Playbook: Four Symptoms, Fourteen CausesNot startedLearningPracticingMastered
• Capstone: A Server With 50,000 Concurrent ConnectionsNot startedLearningPracticingMastered
• Follow send() Through the OS to recv()Not startedLearningPracticingMastered
• Build a Tiny Server: V0 to V5Not startedLearningPracticingMastered
• C10K: Ten Thousand Connections, Then a MillionNot startedLearningPracticingMastered
• Combined Failure Simulator: Break a Layer, Watch It PropagateNot startedLearningPracticingMastered
• Capstone: Three Seconds from WarsawNot startedLearningPracticingMastered