This overview is useful because it brings back the basic question: where the application ends and where the operating system begins as the thing that actually controls processes, memory, networking, and devices.
In real engineering work, it makes the cost of syscalls, context switches, and the user-space versus kernel-space boundary visible when a service-level issue is really a system-level one.
In interviews and design discussions, it helps you explain failures and degradation through actual OS mechanisms instead of vague statements like 'the host is slow.'
Practical value of this chapter
Kernel boundary
Clarifies responsibility boundaries between app logic and OS behavior in production.
Syscall cost
Encourages accounting for syscall and context-switch overhead in latency-critical paths.
Resource isolation
Supports service design with realistic CPU/memory limits and overload behavior.
Interview clarity
Provides precise language when architecture issues are actually system-level issues.
Source
Operating system
The role of operating systems, key functions and types of OS.
The operating system is the interface between applications and computer hardware. It manages all the machinery: processes, memory, files, devices, networking and security.
Key OS Responsibilities
- Process and thread scheduling (CPU scheduling).
- Memory and address space management.
- File systems, data access and buffering.
- Managing devices through drivers.
- Network stack and basic security (permissions, isolation, accounts).
User space and kernel space
User space isolates applications, and kernel space contains the kernel and drivers. The transition between them occurs through system calls.
User space vs kernel space
Select a step to see where work is executed and how the OS interacts with hardware.
User space
Kernel space
Device drivers
Device drivers translate OS requests into hardware commands.
Hardware
CPU, RAM, disks, network, peripherals.
Active step
Click “Start” to walk through the program execution flow.
How user programs are executed
Process life cycle
- Loading the executable file and creating a process.
- Allocation of virtual address space and memory pages.
- The kernel scheduler issues a CPU quantum and switches the context.
- System calls transfer execution to kernel space for I/O.
- Interrupts return the result and control to user space.
The role of drivers
- The driver receives a request from the kernel (for example, writing a file or sending a packet).
- Translates a universal OS request into device controller commands.
- Handles interrupts and notifies the kernel that the operation has completed.
Common operating systems
Android
Smartphones and mobile devices.
- Mobile OS based on Linux
- Widely used on smartphones
Windows
Desktops, corporate workstations, games.
- Wide compatibility with software and drivers
- Standard in an office environment
iOS / iPadOS
Apple mobile devices and tablets.
- Tight security model
- Deep hardware optimization
macOS
Apple computers, development, creative industries.
- UNIX-like base
- Tight integration with the Apple ecosystem
Linux
Servers, clouds, containers, desktops.
- Open source and many distributions
- Dominates server and supercomputing environments
Embedded / Real-time OS
Embedded systems, industry, automotive.
- Deterministic Delays
- Examples: QNX, VxWorks, RIOT, TinyOS
Practical conclusion
Understanding how the OS manages resources helps design applications to meet real hardware constraints: CPU scheduling, memory limits, storage features, and I/O costs.
Related chapters
- Why foundational knowledge matters - provides context for why OS behavior influences service architecture decisions.
- Modern Operating Systems (short summary) - extends the topic with scheduling, memory, file systems, and OS security internals.
- Linux: architecture and popularity - shows the practical side of OS concepts in production infrastructure.
- Virtualization and virtual machines - extends isolation and resource-management concepts at hypervisor level.
- Containerization - connects namespaces/cgroups with modern platform operating models.
- RAM and persistent storage - adds memory hierarchy, page cache, and storage-latency context.
- Structured Computer Organization (short summary) - provides hardware foundations needed to reason about OS limits and capabilities.