Operating System

I mentioned in my about section that operating systems is the class that made me actually fall in love with programming, and this project is why. It started as the standard assignment sequence for Michigan's OS course, and I kept going past where the course stopped, because I wanted to see the whole picture connect. I wanted a thread library I wrote myself, a virtual memory pager sitting underneath it, and a networked filesystem built on top of both.

What got me was realizing how much of what I'd been treating as "how computers just work" is actually a pile of deliberate engineering decisions that somebody had to get right. A thread waking up, a page fault resolving invisibly, a file read returning the right bytes, none of that is automatic. Building each layer myself instead of just reading about it was the only way I was going to really understand that.

The project has three layers built on top of each other. A user-level thread library handles its own scheduling, context switching, and synchronization primitives. A virtual memory pager underneath it manages page tables and page faults. A networked filesystem sits on top of both. Each layer depends on the correctness of the one below it, which was very much the point of building them in that order.

I went into the thread library assuming the interesting problem would be picking a scheduling policy. It turned out the part that actually demanded care was context switching and synchronization. I had to get a thread's saved state exactly right so it resumes as if nothing happened, and make sure two threads touching shared state can't interleave in a way that corrupts it. Those are the bugs that don't show up every run, and they taught me to be a lot more paranoid about concurrent code than any lecture did.

Implementing the pager, managing page tables and handling page faults, is where virtual memory stopped being a diagram in a textbook. It became something I had to get exactly right or watch the whole system behave incorrectly in confusing ways. There's a particular kind of understanding that only comes from debugging a page fault handler that isn't doing what you expect.

By the time I got to the networked filesystem, I already had a thread library and a memory system to build on, which meant I got to feel directly how much a higher layer depends on the correctness of the layers underneath it. A subtle bug in the pager doesn't stay contained to the pager. It shows up as a weird, hard to explain failure two layers up. That's the lesson from this project I've carried into everything since. Get the foundation right, because you will pay for it later if you don't.