Operating systems

Understand the machine under your code.

A full course, from a single system call down into the kernel and back up through processes, scheduling, concurrency, memory and file systems. Every idea is drawn out as a clear visual and explained the way a working engineer needs it.

Start with the introduction See all 37 chapters

Handwritten A4 diagram: an interleaving table with two thread columns (T1, T2) and a shared "count" column; count starts at 5; rows show T1 load 5, T2 load 5, T1 add=6, T2 add=6, T1 store 6, T2 store 6; the final count is circled as 6 with a note "should be 7, one increment lost".

Chapter 14, Race Conditions & the Critical SectionAnatomy of a race: count++ is three steps

chapters

parts

296

illustrated pages

hours of reading

What the course covers

37 chapters in 7 parts.

Read them in order, or jump to the topic you need. Every section pairs a clear written explanation with a drawn page you can take in at a glance.

Operating systems notes: Why the OS matters for engineers

Start hereIntroduction to Operating SystemsWhat the OS really does for you, and the road aheadWhy the OS matters for engineersWhat an operating system actually isThe line between your code and the kernelProcesses, threads & schedulingConcurrency, synchronization & deadlockMemory & virtual memory8 sections · 10 min

Part A

Foundations

What an OS is, the hardware it drives, system calls, and how a program becomes a process.

7 chapters

Part B

Processes, threads and scheduling

The PCB, threads, context switches, CPU schedulers, and interprocess communication.

6 chapters

Part C

Concurrency and synchronization

Race conditions, locks and semaphores, classic problems, lock-free code, and deadlocks.

6 chapters

Part D

Memory management

Address spaces, segmentation, paging and the MMU, virtual memory, and page replacement.

6 chapters

Part E

Storage, I/O and file systems

I/O layers, disks and scheduling, files and directories, and real file-system implementations.

5 chapters

Part F

Modern and distributed systems

Virtualization and hypervisors, containers and cgroups, multiprocessors and distributed systems.

3 chapters

Part G

Case studies and capstone

Linux and Android, Windows internals, performance debugging, and the OS seen from a database.

4 chapters

Questions

Good to know.

Who is this course for?

Developers and CS students who can already write and run programs, but want to understand what happens underneath them: how a process is born, how the CPU is shared, why concurrency is hard, and how memory is stretched across many programs at once.

How is a chapter laid out?

Each chapter opens with a short introduction, then works through its topic one section at a time. Every section pairs a drawn page with a written explanation, so you can take in the picture first and then read the detail.

How long does it take?

About 11 hours of reading in all, across 296 sections. A chapter takes between 13 and 19 minutes, so one fits comfortably into a study session.

See what your program is really asking for.

Start with the introduction for a map of the whole course, then work through the parts in order or jump to the one your next interview needs.

Start with the introduction Browse the chapters