Operating Systems

Processes, threads, concurrency, memory virtualization, and file systems, covering a standard undergraduate operating systems course.

All 27 topics

Every skill the diagnostic can check, grouped the way the map is. Open any topic to start a lesson on it.

What an operating system does: The OS as the layer that turns raw, shared hardware into a clean, protected abstraction for programs.
System calls and kernel mode: The controlled doorway, a trap into kernel mode, a program uses to ask the OS to do something on its behalf.

The process abstraction: A running program's isolated illusion of its own CPU and memory, tracked by the OS as a process control block.
Process creation and control: The fork, exec, and wait calls that create, replace, and clean up processes.
Interprocess communication: Pipes, shared memory, and message passing, the ways separate processes exchange data safely.

Threads: Multiple independent execution paths sharing one process's address space.
Race conditions and critical sections: What goes wrong when two threads touch the same data at the same time without coordination.
Locks and mutual exclusion: A lock that lets only one thread at a time execute a critical section.
Semaphores and condition variables: Counting locks and wait-until-signaled primitives, more flexible tools than a plain mutex.
Classic synchronization problems: Named puzzles, producer-consumer, readers-writers, dining philosophers, that stress-test a synchronization design.
Deadlock: A cycle of threads each waiting on a lock another one holds, so none of them can proceed.

CPU scheduling basics: The policy that decides which ready process runs next, and for how long.
Advanced and real-world scheduling: Scheduling policies, priority queues, MLFQ, CFS, that adapt to real workloads instead of assuming uniform jobs.

Address spaces: Each process's private view of memory, starting at zero, that the OS maps onto real physical RAM.
Free-space memory allocation: How the OS carves up physical memory among processes, and tracks the resulting free space.
Paging: Splitting memory into fixed-size pages so a process's address space doesn't need to sit in one contiguous block.
TLBs and fast address translation: A small hardware cache of recent address translations, so paging doesn't cost a memory access on every access.
Multi-level and inverted page tables: Multi-level and inverted page tables, ways to keep the translation structure itself from eating too much memory.
Virtual memory and page replacement: Letting total memory usage exceed physical RAM by swapping pages to disk, and deciding which page to evict.

I/O devices and interrupts: How the OS talks to devices, through polling, interrupts, or DMA, without the CPU babysitting every transfer.
Hard disks and SSDs: How spinning disks and flash storage actually store and retrieve data, and why their performance shapes differ.
The file system abstraction: Files and directories as the OS's user-facing model, sitting on top of raw disk blocks.
File system implementation: How a real file system, FFS, FAT, NTFS, lays out inodes, directories, and data blocks on disk.
Crash consistency and journaling: Keeping the file system's on-disk structures coherent after a crash, via journaling or fsck-style checking.
Redundancy and RAID: Spreading or duplicating data across multiple disks so one drive failing doesn't lose data.

Protection and security basics: The privilege levels and access checks that keep one process from reading or corrupting another's memory.
Virtual machines and containers: Running an entire guest OS, or a lightweight container, on top of a host OS or hypervisor.