Build a mental model of the parts a process runs on — CPU, memory, storage, input/output, and buses — and how the OS coordinates them so many processes can share the machine. The quantitative cost model and the fetch-execute loop are covered in Computer Architecture Fundamentals.

Understand the hardware the OS virtualizes — CPU pipelines, the memory hierarchy, caches, storage tiers, and how the fetch-execute loop becomes the foundation for every systems topic that follows.

Understand the role of an operating system as an intermediary between hardware and software, covering kernel types, user vs kernel mode, system calls, the boot process, and the fundamental abstractions provided by modern OSes.

Learn how the OS creates, schedules, and terminates processes — including process states, context switching, and the classic CPU scheduling algorithms with an interactive Gantt-chart visualizer.

Explore threads as lightweight units of execution within a process, covering thread models, synchronization primitives, and common concurrency challenges like races and deadlock.

Dive into how the OS manages physical and virtual memory — paging, segmentation, page tables, TLB, and the mechanics of virtual address translation — with an interactive page-replacement simulator and address translator.

Examine the boundary between user space and kernel space — how system calls work, their performance cost, and the standard interfaces (POSIX and Win32) programs use, with syscall tracing.

Understand how the OS organizes persistent data — file metadata (inodes, MFT records), directory structures, file allocation methods, journaling, and the Virtual File System layer.

Get hands-on with Linux — the filesystem hierarchy, users and permissions, processes and signals, systemd services, and package management — the environment where systems engineering actually happens.

Brendan Gregg's toolkit for production systems performance — USE method, RED method, flame graphs, perf, eBPF, and the difference between utilisation and saturation.

Debug production systems like a professional — strace and gdb, profilers, core dumps, flamegraphs, and the systematic workflow that separates guessing from diagnosis.

Understand the mechanisms processes use to exchange data — pipes, named pipes, message queues, shared memory, sockets, and signals — and how to choose the right one for a given job.

Go deep on deadlock — resource allocation graphs, wait-for graphs, detection, prevention, and avoidance with the Banker's algorithm, including a full safe-sequence worked example.

Follow a byte from a program's read() all the way to a device — memory-mapped I/O, interrupts, DMA, blocking vs async I/O, and the block I/O stack that makes storage fast.

Understand how one physical machine runs many isolated OSes or applications — Type 1 and Type 2 hypervisors, hardware-assisted virtualization, and containers built from namespaces and cgroups.

Explore the operating system as a security boundary — DAC vs MAC, ACLs and capabilities, privilege separation, sandboxing, TOCTOU races, and secure boot.

Go inside the heap — free lists, first/best-fit strategies, segregated lists, thread caches and arenas, kernel slab allocators, fragmentation, and overcommit.

Extend CPU scheduling to many cores and to deadlines — SMP scheduling, load balancing, CPU affinity and NUMA, the Linux CFS and Windows schedulers, and real-time policies like EDF and rate-monotonic.

The software stack below the operating system — UEFI Secure Boot, the TPM, side-channel attacks, TEEs, and the silicon that defends against tampering with the bootloader.