Processes, memory management, file systems, scheduling, and virtualization. The OS knowledge that separates engineers who understand why their software behaves the way it does from those who only know that it does.
This is a text-first course that links out to the best supporting material on the internet instead of trying to replace it. The goal is to make this the best course on os fundamentals you can find — even without producing a single minute of custom video.
This course explains OS concepts through the lens of what they mean for your programs — why fork() is expensive, why page faults slow databases, why your filesystem choice affects latency. Not academic abstractions.
Every concept comes with ps, strace, /proc filesystem reads, and perf commands you can run on any Linux machine to observe what the OS is actually doing. Theory you can verify.
Instead of rewriting the Linux kernel documentation, this course links to OSTEP (the definitive free OS textbook), the Linux kernel docs, and the relevant man pages.
Each day is one OS subsystem. Read it, run the commands, build the intuition. No setup required beyond a Linux terminal (WSL works fine).
Each day stands alone. Read them in order for the full picture, or jump straight to the day that answers the question you have today.
What a process actually is in the kernel, how fork() and exec() work, process states, threads vs processes, and why thread-per-request web servers lost to event loops.
Virtual address spaces, page tables, the TLB, page faults, memory-mapped files, and why malloc is not free. How the OS protects processes from each other's memory.
Inodes, directory trees, journaling, fsync, the VFS layer, and the difference between buffered and direct I/O. Why databases bypass the page cache and what that means for your application.
Preemptive scheduling, CFS (the Linux scheduler), priority inversion, mutexes, semaphores, and the concurrency bugs (race conditions, deadlocks) that OS primitives exist to prevent.
How hypervisors virtualize hardware, the difference between VMs and containers, namespaces and cgroups (the Linux kernel features Docker is built on), and what container isolation actually means.
Instead of shooting our own videos, we link to the best deep-dives already on YouTube. Watch them alongside the course. All external, all free, all from builders who ship this stuff.
Visual explanations of how the OS manages processes — creation, scheduling, context switching, and the difference between threads and processes.
How virtual address spaces, page tables, and the TLB work together. Includes visual walkthroughs of page fault handling and memory mapping.
Inodes, directory trees, journaling file systems (ext4, XFS), and why fsync is critical for database durability.
The Linux kernel primitives that Docker and Kubernetes are built on. Understanding namespaces and cgroups demystifies container isolation completely.
CFS, priority scheduling, real-time scheduling — how the Linux scheduler decides which process runs next and how to tune it for your workload.
Use strace to observe every system call a process makes — the best way to understand what your programs actually ask the OS to do.
The best way to deepen understanding is to read the canonical open-source implementations. Clone them, trace the code, understand how the concepts in this course get applied in production.
Code examples from Operating Systems: Three Easy Pieces — the definitive free OS textbook. Every chapter has runnable C examples.
The Linux kernel source. Use it as a reference for understanding exactly how the OS primitives covered in this course are implemented.
Build a simple OS from scratch in C and assembly. The clearest hands-on path to understanding what an OS actually does at the lowest level.
The reference OCI container runtime. Reading the source shows exactly how namespaces and cgroups are used to create container isolation.
Your services run as OS processes, your databases depend on fsync, and your containers use cgroups. Understanding the OS makes you a better backend engineer.
System design and performance questions at senior levels require OS knowledge. Processes, virtual memory, and I/O come up constantly.
Container security, kernel tuning, cgroup limits, and scheduler priorities are daily work for platform teams. This course builds the foundation.
The 2-day in-person Precision AI Academy bootcamp covers AI engineering in depth — hands-on, with practitioners who build AI systems for a living. 5 U.S. cities. $1,490. 40 seats max. June–October 2026 (Thu–Fri).
Reserve Your Seat