Operating system, a thing that everybody uses but no one talks about.

While reading Operating Systems: Three Easy Pieces (OSTEP), my background in C and C++ fueled a growing fascination with memory allocation, virtualization, scheduling, and the intricate mechanics of operating systems. This would be a series of article, the number i am not sure, it will be the amount of content that someone might comfortably read in a 10 min Article. 

Keeping each piece to a solid 10-minute read is the perfect sweet spot for a developer to read over a cup of coffee. It gives you enough runway to explain a core concept, show the math, and link a practical C/C++ experiment without making their eyes glaze over.

Why this Article ? We are often warned against “reinventing the wheel.” However, I firmly believe that building and optimizing modern software is impossible without a fundamental grasp of virtualization, memory allocation, and concurrency.

Consider Docker: it functions almost entirely on OS-level virtualization features like Namespaces, cgroups, and isolated filesystems. Similarly, the highly optimized Memory Manager in PostgreSQL only works because it leverages the robust memory management systems already written into the OS kernel.

This article aims to bring the core concepts of OSTEP to life through practical experimentation. By accompanying the theory with an open-source repository, my goal is to provide a clear, interactive learning experience that demystifies operating systems.

I am not an operating system guru or a Principal Engineer with years of experience, but I hope to become one someday (assuming AI doesn’t replace me first… HeHe). What I can do is dive in, explore, and try to understand these concepts by actually building things. Because of that, my goal here is to present the findings and experiments I explore rather than giving strong opinions — I’ll leave the comment section for those! Any support, feedback, or contributions from the community will be incredibly valuable to me.

Who is this Article For ?

• Anyone curious about low-level system design and how things actually work under the hood.
• Peers and developers looking for a practical, hands-on refresher on core operating system concepts.
• People who hate dry theory and just want to build things practically (though fair warning: we are going to dive into some essential calculations and theory notes to make the practical stuff actually work, bro…).

The Fundamentals

The Operating system as written in OSTEP and i also agree, can be learned with the help of understanding 3 fundamental concepts that forms the backbone of any application today.

• Virtualization :

  The ability of the operating system to give a process the illusion of infinite, private resources.

  Let’s break it down with an analogy. Consider yourself a wealthy investor, and I am your property manager. On paper, I sold you a massive 100-acre farm. In your mind, you own that entire 100 acres all to yourself.

  In reality, I only manage 50 physical acres, and I’m secretly juggling leases for several other investors on that exact same land. But here is the trick: you never inspect the entire 100 acres at the exact same time. Whenever you want to visit a specific acre, I scramble behind the scenes, clear out whatever else was there, and set up your stuff before you walk through the gate.

  To you, the illusion is perfect — you have a massive, private 100-acre estate. Meanwhile, I (the OS) am sweating under the hood, dynamically swapping things around to make a 50-acre reality work for everyone.

• Persistence :

  The ability of the system to permanently retain data once it has been committed. Imagine how frustrating your life would be if you had to set up your mobile phone from scratch every single day because your contacts and settings wouldn’t save. Without persistence, everything a program does vanishes the moment the power cord is pulled. The OS handles the massive responsibility of mapping volatile, short-term memory to permanent, physical storage (like SSDs and hard drives) so your data survives.

• Concurrency :

  The ability of the system to handle multiple tasks or run processes in parallel. While virtualization creates a tidy, isolated world for a single process, modern applications rely on multi-threading, which introduces total chaos. The OS has to manage this concurrency with strict rules to prevent disasters :

  - Mutual Exclusion: Ensuring that when one process or thread is modifying shared data (like a bank balance), no other thread can touch it at the same time.

  - Determinism & Isolation: Ensuring that regardless of the chaotic order in which the OS schedules different threads, the final result of the program remains correct, predictable, and exact every single time.

Wrapping Up

Hopefully, this introduction gives you a clear picture of what this series is all about. This first piece was all about laying the foundation and mapping out the technical road ahead. Because each of these core pillars contains a massive amount of depth, math, and practical nuance, I will be separating them into their own distinct, dedicated articles moving forward.

Next up, we are diving straight into Part 1: The Art of Time Sharing, where we will peel back the layers on CPU virtualization, understand how the OS pulls off seamless context switching, and dive into the math behind different scheduling policies.

Thanks for reading, and I’ll see you in the next one… bro!