One of the most intense parts of my degree so far has been working on Nachos, a teaching operating system.

We implemented:

• Thread scheduling and synchronization
• Multiprogramming with per-process page tables
• Demand paging and page replacement
• System calls with user–kernel transitions

And we did it in a codebase where everything is just barely working until you fix it.

Threads and synchronization

Understanding join(), finish(), and condition variables forced me to think carefully about:

• Who owns what lock?
• When is it safe to sleep?
• How do you avoid deadlocks without sprinkling disableInterrupts() everywhere?

Getting a clean rendezvous mechanism working (where threads can exchange values) was one of those “oh, I actually understand concurrency now” moments.

Virtual memory and demand paging

Demand paging was both painful and satisfying. The tricky parts:

• Correctly initializing page tables per process
• Handling page faults without corrupting state
• Making sure swapped-out pages and frames remain consistent

Once it worked, watching processes run “bigger than RAM” felt like magic.

Why this matters for me

All of this made the OS less of a black box and more like a big, understandable machine.
It’s also changed how I think about performance bugs and memory-related issues in higher-level code.

Future posts might dive into specific Nachos bugs I hit and how I tracked them down.