Operating Systems
How your computer actually manages itself, built up from absolute zero: system calls, processes, threads, IPC, concurrency and synchronization, deadlock, CPU and I/O scheduling, memory management, virtual memory, and file systems — with the real math behind every idea, ending with a hands-on module where you build a real bootable kernel in C++.
Written byRohan Sharma
Foundations of Operating Systems
3 lessons- 9 min read
What is an operating system, really?
Why your computer needs a manager at all, and the one idea underneath everything an OS does.
- 9 min read
System calls — how programs politely ask the kernel for help
The doorbell every program rings when it needs the OS to do something on its behalf, and why it can't just walk in.
- 8 min read
How a computer wakes up, and how it reacts to surprises
What actually happens in the seconds after you press the power button, and how the OS handles events it didn't ask for.
Foundations of Operating Systems Quiz
8 questions
Processes & Threads
4 lessons- 9 min read
What is a process, really?
The difference between a program sitting on disk and the same program actually running, and everything the OS tracks about it.
- 9 min read
Process states and the art of pausing mid-thought
The five-state life of a process, and the surprisingly expensive trick the OS uses to pause one process and resume another.
- 9 min read
Process creation, fork, and exec
Where new processes actually come from, and the strange but brilliant two-step trick Unix uses to create and start them.
- 10 min read
Threads — many workers sharing one process's kitchen
Why threads exist, how they differ from processes, and the real math behind when multithreading actually speeds things up.
Processes & Threads Quiz
10 questions
Inter-Process Communication
3 lessons- 9 min read
Pipes and shared memory — two ways for processes to talk
Since processes don't share memory by default, how do they exchange data at all? Two founding approaches, and the real trade-off between them.
- 9 min read
Message queues, sockets, and signals
Three more ways processes talk — structured mailboxes, network-style connections, and one-bit emergency alarms.
- 8 min read
Client-server IPC and remote procedure calls
How IPC scales up into the client-server model, and the elegant trick of making a call to another process feel like an ordinary function call.
Inter-Process Communication Quiz
10 questions
Concurrency & Synchronization
4 lessons- 10 min read
Race conditions and the critical section problem
Why two threads doing something as simple as adding 1 to a shared number can silently produce the wrong answer.
- 9 min read
Locks and mutexes — the bathroom key trick
The simplest tool for enforcing mutual exclusion, how it's actually built on hardware, and the real cost of getting it wrong.
- 10 min read
Semaphores and monitors — counting turns and tidy rooms
A more flexible tool than a plain lock for managing limited resources, and a cleaner, safer way to package synchronization altogether.
- 10 min read
The classic synchronization problems, solved from scratch
Producer-consumer, readers-writers, and dining philosophers — the three textbook puzzles that every synchronization tool gets tested against.
Concurrency & Synchronization Quiz
10 questions
Deadlock
4 lessons- 9 min read
What is a deadlock, and the four conditions that cause one
The precise, necessary ingredients for a deadlock to happen, illustrated with traffic gridlock and the dining philosophers.
- 10 min read
Deadlock prevention and avoidance
Two different philosophies for stopping deadlock before it happens — permanently outlawing a condition, versus carefully checking every request in the moment.
- 8 min read
Deadlock detection and recovery
What to do when you let deadlock happen on purpose, and simply deal with the aftermath — spotting it, and cleaning it up.
- 8 min read
Livelock, starvation, and choosing a real-world deadlock strategy
The cousin of deadlock where processes are busy but still stuck, and how real operating systems actually decide which of the four strategies to use.
Deadlock Quiz
10 questions
CPU Scheduling
4 lessons- 8 min read
What are we even trying to optimize? Scheduling goals and metrics
Before comparing scheduling algorithms, you need the actual measuring sticks used to judge whether one is "better" than another.
- 10 min read
FCFS, shortest job first, and priority scheduling
Three foundational scheduling algorithms, the surprising math behind why shortest-first is provably optimal, and the real danger of priority-based scheduling.
- 10 min read
Round robin and multilevel queue scheduling
The algorithm that actually powers most interactive systems, the precise math behind choosing a time quantum, and how real OSes combine multiple algorithms at once.
- 9 min read
Scheduling across multiple cores, and real-time systems
What changes when there's more than one CPU to schedule onto, and what happens when "fast" isn't good enough — it has to be "on time."
CPU Scheduling Quiz
10 questions
I/O & Disk Scheduling
3 lessons- 9 min read
How I/O devices actually work, from the OS's point of view
What a disk really looks like mechanically, why I/O is agonizingly slow compared to the CPU, and the buffering trick that hides it.
- 10 min read
Disk scheduling algorithms — choosing the order that hurts least
Given a pile of disk requests scattered across the platter, the concrete algorithms for minimizing how far the arm has to travel.
- 9 min read
RAID and keeping data alive when disks fail
What happens when the disk itself breaks, and the clever math that lets you survive a failure without losing a single byte.
I/O & Disk Scheduling Quiz
10 questions
Memory Management
4 lessons- 9 min read
Address spaces and contiguous memory allocation
How the OS hands out physical memory to processes, and the frustrating way free space quietly crumbles into useless crumbs over time.
- 10 min read
Paging — cutting memory into interchangeable Lego bricks
The elegant fix for fragmentation, how a page table actually translates addresses, and the real cost of that extra lookup.
- 9 min read
Segmentation and multilevel page tables
An alternative memory model based on meaning rather than fixed size, and the trick that stops a page table itself from becoming an enormous memory hog.
- 8 min read
Dynamic memory allocation — how malloc actually finds you space
What happens inside the heap every time a program asks for memory at runtime, and the internal fragmentation cost hiding in every allocation.
Memory Management Quiz
10 questions
Virtual Memory
3 lessons- 9 min read
Demand paging — running programs bigger than your RAM
The trick that lets a computer run programs whose total memory need exceeds physical RAM, and what actually happens on a page fault.
- 10 min read
Page replacement algorithms — deciding what to kick out
When RAM is full and a new page needs to come in, exactly which existing page should be sacrificed, and the surprising paradox lurking in the answer.
- 8 min read
Thrashing and the working set model
What happens when a system tries to run too much at once, and the elegant idea that tells the OS exactly how much memory a process genuinely needs right now.
Virtual Memory Quiz
10 questions
File Systems
4 lessons- 8 min read
What a file actually is, and how directories find them
The OS's most user-facing abstraction, broken down to what it really is underneath — just organized bytes plus a lot of bookkeeping.
- 9 min read
File allocation methods — where a file's actual bytes live on disk
Three different strategies for tracking which disk blocks belong to which file, and the very familiar fragmentation trade-offs that reappear here too.
- 9 min read
Tracking free space, and surviving a sudden power loss
How the file system knows which blocks are actually free, and the clever logging trick that keeps your files intact even if the power dies mid-write.
- 9 min read
Putting it all together — the full journey of writing a file
A single, concrete walk through everything this entire course covered, following one file write from your keyboard down to the physical disk platter.
File Systems Quiz
10 questions
Building Your Own OS in C++
6 lessons- 12 min read
Setting up your toolchain and booting your very first kernel
Building a real cross-compiler, understanding the Multiboot handoff, and getting a custom kernel to print something on real (emulated) hardware.
- 11 min read
Building a real screen driver, and setting up the GDT
Turning one hardcoded print statement into a proper terminal driver, and understanding the segmentation table every x86 kernel must set up.
- 12 min read
Handling interrupts, the IDT, and a real keyboard driver
Making your kernel react to the outside world instead of just running one straight line of code, ending with real keystrokes appearing on screen.
- 13 min read
Managing physical memory, and turning on paging
Building a real physical memory manager and page table structures, then flipping the one CPU bit that turns on virtual memory for good.
- 12 min read
Real multitasking — implementing your own scheduler and context switch
Giving your kernel the ability to run more than one task at once, using a real timer interrupt and a hand-written context switch in assembly.
- 12 min read
A simple shell, a toy file system, and where to go from here
Tying every piece together into an interactive shell backed by a real, tiny file system, and a concrete roadmap for growing your kernel further.
Building Your Own OS in C++ Quiz
15 questions
Assessments
12 quizzesFoundations of Operating Systems Quiz
Foundations of Operating Systems · 8 questions
Processes & Threads Quiz
Processes & Threads · 10 questions
Inter-Process Communication Quiz
Inter-Process Communication · 10 questions
Concurrency & Synchronization Quiz
Concurrency & Synchronization · 10 questions
Deadlock Quiz
Deadlock · 10 questions
CPU Scheduling Quiz
CPU Scheduling · 10 questions
I/O & Disk Scheduling Quiz
I/O & Disk Scheduling · 10 questions
Memory Management Quiz
Memory Management · 10 questions
Virtual Memory Quiz
Virtual Memory · 10 questions
File Systems Quiz
File Systems · 10 questions
Building Your Own OS in C++ Quiz
Building Your Own OS in C++ · 15 questions
Operating Systems Final Assessment
Final assessment · 22 questions