Operating Systems & Virtualization
Processes, threads, scheduling, memory, concurrency, filesystems and the foundations behind modern virtualization.
Operating systems are one of those subjects that quietly sit underneath almost everything we build.
After years of working with applications, containers, cloud platforms and distributed systems, revisiting operating-system concepts helped me reconnect many practical technologies with the mechanisms that make them possible.
Questions such as these become much easier to reason about once the underlying operating-system model is clear:
What is the difference between a process and a thread? How does the operating system decide which process gets CPU time? Why do race conditions occur? What happens when physical memory is not enough? What exactly is being virtualized inside a virtual machine or a container?
This section collects the resources I use to reconnect those low-level mechanisms with modern software infrastructure.
Topics in This Section
Processes · Threads · CPU Scheduling · Concurrency · Synchronization · Deadlocks · Main Memory · Virtual Memory · Storage · I/O · Filesystems · Protection · Security · Virtual Machines · Containers · Distributed Systems
Operating System Concepts
Abraham Silberschatz, Peter B. Galvin & Greg Gagne
10th Edition — Wiley
Level
Foundation → Advanced
Best for
Operating-system fundamentals, concurrency, memory management and virtualization.
Operating System Concepts is one of the classic academic references for understanding the mechanisms that sit between applications and hardware.
What I find particularly useful is the way the book moves from core execution concepts — processes, threads and scheduling — to synchronization, memory, storage, protection and virtualization.
This makes it especially valuable when trying to understand how apparently separate technologies such as containers, virtual machines, process isolation and cloud workloads are built on top of common operating-system abstractions.
What I Use It For
- understanding processes and threads;
- CPU scheduling and context switching;
- race conditions and synchronization;
- mutexes, semaphores and monitors;
- deadlock detection and prevention;
- physical and virtual memory;
- paging and page replacement;
- storage and I/O;
- filesystem design;
- security and protection mechanisms;
- virtual machines and hypervisors;
- connecting operating-system concepts to containers and cloud infrastructure.
Chapters Worth Reading
Operating-System Foundations
Chapter 1 — Introduction
Operating-system roles, system organisation, hardware interaction and the main abstractions provided to applications.
Chapter 2 — Operating-System Structures
Operating-system services, system calls and structural approaches used to organise the kernel.
Processes, Threads & Scheduling
Chapter 3 — Processes
Process concepts, process states, creation, termination, inter-process communication and the process control model.
Chapter 4 — Threads & Concurrency
Multithreading, user and kernel threads, concurrency models and the relationship between threads and processes.
Chapter 5 — CPU Scheduling
Scheduling criteria and algorithms used to decide which process or thread receives CPU time.
Synchronization & Deadlocks
Chapter 6 — Synchronization Tools
Race conditions, critical sections, atomic operations, mutex locks, semaphores and synchronization primitives.
Chapter 7 — Synchronization Examples
Classical synchronization problems and practical applications of synchronization mechanisms.
Chapter 8 — Deadlocks
Deadlock conditions, resource-allocation graphs, prevention, avoidance, detection and recovery.
Memory Management
Chapter 9 — Main Memory
Memory allocation, address translation, paging and memory-management strategies.
Chapter 10 — Virtual Memory
Demand paging, page faults, replacement algorithms, working sets and the abstraction of memory larger than physical RAM.
Storage, I/O & Filesystems
Chapter 11 — Mass-Storage Structure
Secondary storage, disk organisation, scheduling and storage-management concepts.
Chapter 12 — I/O Systems
Device management, interrupts, buffering, caching and the operating system’s I/O subsystem.
Chapter 13 — File-System Interface
Files, directories, access methods and filesystem abstractions exposed to applications.
Chapter 14 — File-System Implementation
Filesystem structures, allocation methods and directory implementation.
Chapter 15 — File-System Internals
Internal filesystem management and implementation concerns.
Security & Protection
Chapter 16 — Security
Threats, attacks, authentication and mechanisms for securing computing systems.
Chapter 17 — Protection
Access control, protection domains and mechanisms used to control how processes access system resources.
Virtualization & Distributed Systems
Chapter 18 — Virtual Machines
Virtualization concepts, virtual-machine implementation and the role of hypervisors.
Chapter 19 — Networks and Distributed Systems
Networking and distributed-system concepts viewed from the operating-system perspective.
My Suggested Learning Path
Execution Model
Chapters 3–5
Concurrency
Chapters 6–8
Memory
Chapters 9–10
Storage & Filesystems
Chapters 11–15
Security
Chapters 16–17
Virtualization
Chapter 18
From Processes to Containers
One of the most useful reasons to revisit operating systems is that many cloud-native concepts become much easier to understand once their foundations are clear.
Processes
A process represents a running program with its own execution context and resources managed by the operating system.
Virtual Machines
Virtual machines abstract an entire hardware environment, allowing multiple operating systems to execute independently on the same physical host.
Containers
Containers isolate applications at operating-system level while sharing the host kernel, making them lighter than full virtual machines.
Understanding these layers helps explain why containers start quickly, why they generally consume fewer resources than virtual machines, and why their isolation model differs from hypervisor-based virtualization.
How I Use This Book
I rarely approach the book sequentially. I usually start from a practical behaviour I want to understand and move down through the operating-system abstractions behind it.
“Why can two threads corrupt shared state even though each one works correctly in isolation?”
That leads directly to synchronization, critical sections, locks and semaphores.
“Why can an application use more memory than the machine physically has?”
That points toward virtual memory, paging and page-replacement mechanisms.
“Why are containers lighter than virtual machines?”
That leads from process isolation to kernel sharing and eventually to the different layers at which virtualization can be implemented.
Start from an observed system behaviour, then move downward until the operating-system mechanism behind it becomes clear.
Related Areas
Operating-system concepts connect naturally with several other areas in this library.
Containers, Cloud & DevOps
Namespaces, resource isolation, container runtimes, scheduling and infrastructure management.
Cybersecurity & Cryptography
Access control, privilege separation, process isolation and operating-system security mechanisms.
Distributed Systems
Processes, communication, concurrency, resource management and failure handling across multiple machines.