We began this course with a promise the operating system makes to every program: three illusions — virtualization, concurrency, and persistence — held up by a privileged kernel guarding a hardware boundary. That model, essentially unchanged since the 1970s, has been extraordinarily durable. But it is being pushed hard from every side: by hardware that is no longer slow, by datacenters that are no longer single machines, and by security threats that no longer respect the boundary. This closing lesson steps back and asks where the operating system is going — and finds, pleasingly, that every trend is a re-examination of one of our three illusions.
The oldest assumption we can drop is that every operation must pass through the kernel. When a
device answered in ten milliseconds, the few thousand cycles of a
The through-line: keep the kernel's safety role, remove it from the performance path.
Four movements dominate current OS research and practice. Reveal them one by one — notice how each is not a brand-new idea but a fresh answer to a question this course has already posed.
Watch a modern deployment and the general-purpose OS seems to be vanishing. A
serverless function is a scrap of code that runs in a
Pulling the other way is specialization. For fifty years the general-purpose kernel that
runs anything won by economy of scale. But when you deploy one function a billion times, the generality is
pure overhead, and
Two more forces round out the picture. Disaggregation attacks the deepest assumption of
all — that an OS manages one machine's CPU, memory, and disk. In a modern datacenter, memory and
storage are increasingly pooled across the building and reached over fast fabrics (CXL, RDMA); a job's
"RAM" may live in another rack. The OS's job stretches from managing a box to scheduling a warehouse — the
old dream of the
Finally, memory safety at the root of trust. A staggering fraction of critical kernel
vulnerabilities are memory-safety bugs in C — the very
No — but it will keep hiding better. Every generation predicts the OS's death: time-sharing would end it, then the PC, then the browser, then the cloud, then serverless. Each time, the OS didn't vanish; it moved and multiplied. The three problems it solves — safely sharing a machine (virtualization), coordinating simultaneous activity (concurrency), and keeping data safe across failures (persistence) — are not artifacts of old hardware; they are intrinsic to computing itself. What changes is where the OS lives (a hypervisor, a unikernel image, an eBPF program, a datacenter scheduler) and how visible it is. The abstractions you learned in this course are the enduring part; the packaging is what keeps being reinvented. Learn the illusions, and you can read whatever shape the OS takes next.
A trap in reading systems research is treating each trend as unprecedented. Almost none are. Unikernels are the 1990s exokernel and library-OS work (and arguably 1960s single-address-space machines). Disaggregated memory is distributed shared memory from the 1980s. Microkernels and message passing predate Linux. Kernel-bypass networking is decades old. What changes is not the idea but the constraint that made it lose last time: DSM lost to slow networks — now RDMA is fast; microkernels lost to slow IPC — now L4/seL4 fixed it; specialization lost to the economics of generality — now hyperscale flipped that sum. The skill this course was really teaching is to see the invariant idea beneath the shifting trade-off, so you can predict which "dead" idea the next hardware shift will resurrect.
You started at the