Systems on

Lesson 12: Production Systems Software — Databases, runtimes, proxies

Fri, 08 Aug 2025 09:33:27 +0000

I’ve been building systems software professionally for a while now, and here’s what I’ve noticed: the skills we’ve covered in this course — no_std programming, memory-mapped I/O, custom allocators, interrupt handlers, network protocols — they all converge when you build production systems software. A database engine is just a file system on top of a storage engine with a query processor. A network proxy is packet parsing plus connection management. A language runtime is memory management plus a scheduler.

Lesson 11: Building a Minimal Hypervisor — Virtualization in Rust

Mon, 04 Aug 2025 15:42:18 +0000

The first time I watched a virtual machine boot — not using VirtualBox, but running inside a hypervisor I’d written — I had the same feeling as when my bootloader printed its first character. Except this time, I wasn’t just running code on bare metal. I was creating a fake machine that thought it was running on bare metal.

Virtualization is where systems programming hits its ceiling of complexity. You’re manipulating the CPU’s hardware virtualization extensions to create isolated execution environments. It’s also where Rust’s safety guarantees become most valuable — because a bug in a hypervisor doesn’t just crash your program, it potentially compromises every virtual machine running on the host.

Lesson 10: Writing a Bootloader — The first code that runs

Fri, 01 Aug 2025 22:10:44 +0000

There’s something almost spiritual about writing a bootloader. Your code is the first thing that runs on a machine. Before the OS. Before any drivers. Before the memory manager. Before anything. The CPU comes out of reset, fetches an instruction from a known address, and that instruction is yours.

I spent a weekend writing one. By Sunday night, I had four characters on screen — BOOT — rendered by writing directly to VGA memory. And it felt like I’d conquered the world.

Lesson 9: Interrupt Handlers and Real-Time Constraints — When timing matters

Wed, 30 Jul 2025 06:55:22 +0000

I once spent three days debugging a motor controller that would randomly twitch. The code was correct. The hardware was fine. The interrupt handler was well-written. But every few thousand cycles, a timer interrupt would preempt the motor control interrupt at exactly the wrong moment, corrupting a shared variable. The fix was two lines of code — disable interrupts around the critical section — but finding it cost me a weekend.

Lesson 8: Designing Custom Allocators — Beyond the global allocator

Sun, 27 Jul 2025 13:19:56 +0000

Here’s a dirty secret of systems programming: malloc is not magic. It’s just code. Code that somebody wrote, code that makes tradeoffs, and code you can replace when those tradeoffs don’t match your workload.

I spent two years writing performance-sensitive Rust before I realized that the global allocator was my bottleneck. Not CPU. Not I/O. Memory allocation — thousands of tiny allocations per request, each one hitting a lock, each one fragmenting the heap a little more. Switching to a bump allocator for request-scoped data cut latency by 40%.

Lesson 7: Implementing Network Protocols — TCP from scratch

Thu, 24 Jul 2025 10:31:48 +0000

I thought I understood TCP until I tried to implement it. Turns out, “client connects to server, data flows” is about 5% of the story. The other 95% is state machines, retransmission timers, congestion windows, and edge cases that would make your head spin.

But here’s the good news: implementing even a simplified TCP teaches you more about networking than any textbook. And Rust’s type system is actually perfect for modeling protocol state machines — states become types, invalid transitions become compile errors.

Lesson 6: Building a File System — From blocks to files

Tue, 22 Jul 2025 16:08:32 +0000

The moment a file system clicked for me was when I stopped thinking of files as “things on disk” and started thinking of them as “names mapped to byte ranges scattered across a block device.” That sounds more complicated, but it’s actually simpler — because now there’s no magic. Just data structures.

Every file system, from FAT16 to ZFS, answers the same fundamental questions: Where does this file’s data live on disk? How do I find a file by name? What metadata (size, permissions, timestamps) does each file have? Let’s answer all of these by building one from scratch.

Lesson 5: OS Concepts in Rust — Processes, threads, signals

Sat, 19 Jul 2025 07:45:19 +0000

I used to think I understood processes. Then I tried to implement fork() semantics in Rust and realized I’d been cargo-culting UNIX concepts for years without actually understanding what was happening underneath.

Here’s the thing — Rust forces you to think about OS primitives more carefully than C ever did. The ownership model doesn’t just prevent memory bugs; it makes you confront questions like “who owns a file descriptor?” and “what happens to shared memory after fork?” that C lets you handwave past.

Lesson 4: Writing Linux Kernel Modules in Rust — Rust in the kernel

Thu, 17 Jul 2025 11:23:45 +0000

In December 2022, Rust officially merged into the Linux kernel source tree. Not as an experiment. Not as a sidecar. As a first-class language for writing kernel code. Linus Torvalds signed off on it.

I remember reading the mailing list thread and thinking: “This is either going to be the most important thing to happen to systems programming in twenty years, or the most spectacular failure.” Three years in, it’s looking a lot like the former.

Lesson 3: Memory-Mapped I/O — Talking to hardware

Mon, 14 Jul 2025 19:52:07 +0000

There’s a moment in every systems programmer’s life when they realize that writing to memory address 0x4002_0818 doesn’t store a value — it turns on an LED. That address isn’t RAM. It’s a hardware register. And the CPU doesn’t know the difference.

That’s memory-mapped I/O in a nutshell, and it’s how virtually all hardware communication works on modern processors. Understanding it properly is the difference between code that happens to work and code that’s correct.

Lesson 2: Embedded Rust — Microcontrollers and bare metal

Sat, 12 Jul 2025 14:37:51 +0000

I bricked my first development board within forty-five minutes of getting it out of the box. Wrote some C code, forgot to configure the clock properly, flashed it, and the thing just… stopped responding. No debugger connection. No serial output. A $15 paperweight.

That experience — the raw, unforgiving nature of hardware programming — is exactly why Rust matters in embedded. Not because it prevents you from writing to the wrong register (it can’t, really), but because it gives you tools to structure hardware access so mistakes become harder to make.

Lesson 1: no_std — Rust without the standard library

Thu, 10 Jul 2025 08:14:33 +0000

The first time I tried to compile a Rust program with #![no_std], I felt like someone had pulled the floor out from under me. No println!. No String. No Vec. No HashMap. Half the stuff I relied on daily — just gone.

And that’s exactly the point.

Why Would Anyone Do This?

Here’s the thing most Rust tutorials won’t tell you up front: the standard library is enormous. It pulls in heap allocation, threading, file I/O, networking, and a whole OS-level runtime. That’s great for application development. It’s a non-starter for:

Lesson 2: CGo Performance and Pitfalls — The hidden cost of crossing the boundary

Thu, 24 Oct 2024 00:00:00 +0000

When I profiled a service that was spending 40% of its time in cgo calls, I thought I was measuring the C library. I was not. I was measuring the overhead of getting to the C library. The actual C work was fast. What was slow was the goroutine-to-OS-thread transition, the stack switching, and the runtime bookkeeping that happens every single time Go code crosses the C boundary. Understanding this overhead is what separates cgo code that runs fine from cgo code that becomes a bottleneck.

Lesson 1: CGo Basics — When you need C and how to call it safely

Mon, 22 Jul 2024 00:00:00 +0000

There is a saying in the Go community: “cgo is not Go.” It is not an insult. It is a warning. The moment you add import "C" to a file, you are no longer writing a pure Go program — you are writing a Go program that manages a C boundary, and all the things that make Go comfortable (fast builds, easy cross-compilation, the race detector, straightforward stack traces) become harder. You are doing it on purpose, because the alternative is worse.