a2ys / Savant
PostsTagsAuthorsAbout

Introduction to Operating Systems — What even is an OS?

Aayush Shukla's avatar Aayush Shukla 18 min read • May 14, 2025

Picture this: you press the power button on your laptop, and after a few moments, you’re greeted with a colorful screen where you can click on icons to open your favorite apps. But have you ever stopped to wonder what’s happening behind that pretty interface? What’s actually making your computer… well, compute?

Table of Contents

The OS: Your Computer’s Master Coordinator

An operating system (OS) is essentially a sophisticated piece of software that acts as the central manager of your computer. Think of it as the mayor of a bustling digital city, coordinating everything from traffic flow to resource allocation.

Without an operating system, your computer would just be a collection of electronic components with no way to communicate with each other or with you. The OS is what bridges the gap between the physical hardware (the actual electronic components) and the applications you use every day (like your web browser, games, or word processor).

From a technical perspective, an OS consists of:

  • Kernel: The core component that has complete control over system resources. It provides low-level services like device drivers, memory management, and process scheduling.
  • System Programs: Utilities that perform common tasks like file management, status information, and configuration.
  • Shell: The interface (command-line or graphical) that interprets user commands and passes them to the kernel.

The OS kernel operates in a privileged mode (often called “kernel mode” or “supervisor mode”) with unrestricted access to hardware, while user applications run in a restricted “user mode.” This separation is enforced by the CPU’s hardware protection mechanisms and is fundamental to system stability and security.

Real-life Examples You Already Know

You’re probably familiar with several operating systems even if you didn’t realize it:

  • Windows 11: Microsoft’s latest OS running on most personal computers
  • macOS: Apple’s operating system for MacBooks and iMacs
  • iOS: Powers your iPhone
  • Android: The system behind most non-Apple smartphones
  • Linux: An open-source OS with various distributions like Ubuntu, Fedora, Debian, Arch Linux, and much more, used in servers, desktops, and embedded systems

When you’re scrolling through Instagram Reels or playing Minecraft, you’re interacting with applications, but it’s the operating system working tirelessly underneath that makes it all possible.

What Does an Operating System Actually Do?

An OS handles a surprisingly wide range of responsibilities. Let’s break down the main functions:

Resource Management

Your computer has limited resources — CPU time, memory space, storage, and more. The OS acts like a fair referee, deciding which programs get what resources and when:

  • CPU Management: Decides which process gets processing time through scheduling algorithms like Round-Robin (giving each process equal time slices), Priority-based (important tasks first), or Completely Fair Scheduler (CFS) used in Linux. The OS also handles context switching — saving and restoring CPU state when switching between processes, which typically takes hundreds of nanoseconds.

  • Memory Management: Allocates working memory (RAM) to different applications using techniques like:

    • Paging: Dividing physical memory into fixed-size frames (typically 4KB) and logical memory into pages of the same size
    • Virtual Memory: Creating an abstraction that allows programs to use more memory than physically available by swapping data between RAM and disk
    • Memory Protection: Using hardware features like Memory Management Units (MMUs) to prevent one process from accessing another’s memory space

  • Storage Management: Controls how files are stored and retrieved through file systems like NTFS (Windows), APFS (Mac), or ext4 (Linux) that handle complex tasks including:

    • Block allocation and tracking
    • Metadata management (file attributes, permissions)
    • Journaling to prevent corruption during system crashes
    • Cache management to speed up disk operations

  • I/O Device Management: Coordinates communication with keyboards, screens, printers, etc. through device drivers that translate general I/O requests into device-specific commands. This includes interrupt handling (when devices need attention) and buffer management (temporary storage for data being transferred).

Imagine trying to manually tell your processor which calculation to perform next, or personally directing where in RAM your Spotify playlist should be stored. The OS handles all this complexity so you don’t have to!

User Interface

The OS provides a way for you to actually talk to your computer:

  • Command-Line Interface (CLI): Text-based interaction (like Terminal on Mac or Command Prompt on Windows)
  • Graphical User Interface (GUI): The visual interface with windows, icons, and menus that most people use today

Application Platform

The OS provides a stable foundation for applications to run on:

  • Gives apps access to hardware through standardized interfaces
  • Ensures applications play nicely together
  • Provides security measures to prevent rogue applications from causing damage

File Management

The OS organizes and keeps track of all your files:

  • Creates and maintains file systems
  • Handles file operations (creating, reading, writing, deleting)
  • Manages file permissions and security

The Core Abstractions of Operating Systems

One of the most brilliant aspects of operating systems is how they simplify complexity through abstractions. Let’s look at three fundamental abstractions that make modern computing possible:

Abstractions: Hiding Complexity Behind Simplicity

An abstraction is like a simplified model that hides complicated details. Think of how you drive a car — you press the gas pedal to go faster without needing to understand the internal combustion process happening in the engine, or how the brakes work. You just know that pressing the pedal makes the car move, and pulling the lever stops it. This is the essence of abstraction: providing a simple interface to complex systems. In programming, this means creating functions, classes, or modules that encapsulate complex logic and expose only the necessary parts to the user.

In OS terms, abstractions hide the messy hardware details behind clean, simple interfaces. This means:

  • Programmers can write code without knowing exact hardware specifications
  • Users can interact with computers without understanding binary code
  • Different applications can run on diverse hardware with minimal changes

From a technical standpoint, operating systems implement several key abstraction layers:

  • Hardware Abstraction Layer (HAL): Provides a consistent interface to various hardware devices, allowing the OS to work with different hardware configurations without major modifications.

  • System Call Interface: Provides a standardized API for applications to request OS services. For example, when an application calls open(), read(), or write() functions, it’s using this interface to access the file system.

  • File Abstraction: Represents all storage as a uniform collection of files, regardless of the physical storage medium (SSD, HDD, network drive, etc.) or underlying file system structure.

  • Device Abstraction: Treats all I/O devices using a consistent model — typically as special files in Unix-like systems (e.g., /dev/sda for disk drives) or through device handles in Windows.

For example, when you save a file, you don’t need to know which specific sectors of your hard drive are being written to — the file system abstraction handles that for you. At a deeper level, this involves the OS translating your high-level “save file” command through multiple abstraction layers until it becomes specific disk controller commands.

Processes: The Living Programs

A process is an OS abstraction that represents a running program. Think of it as an active instance of an application that’s currently executing — a program in action, with its own unique identity and dedicated resources.

What makes processes special:

  • Isolated Memory Space: Each process gets its own private chunk of memory, preventing one application from accidentally (or maliciously) accessing another’s data. This isolation is like giving each application its own private office space in a large building.

  • Program Counter and Registers: A process maintains its own current execution position and state information, allowing the OS to pause it and come back to exactly the same point later.

  • Process Control Block (PCB): The OS maintains a special data structure for each process containing all its vital information — like its ID, state, priority, memory locations, and open files. Think of this as each process’s personnel file.

  • Multiple Execution States: Processes move through various states during their lifecycle, which we’ll explore next.

The Process Lifecycle: From Birth to Termination

Processes have a fascinating lifecycle that the OS manages:

  1. Created (New): When you double-click an application icon, the OS creates a new process. During this brief initial state, the OS allocates memory and resources, sets up the PCB, and loads program code from storage into memory. It’s like setting up a new workspace before an employee starts work.

  2. Ready: After creation, the process enters a “ready” state, where it’s fully prepared to run but is waiting for CPU time. Think of this as employees waiting in line for their turn at a shared tool.

  3. Running: This is when the process is actively executing on the CPU — the application is doing its actual work! Due to CPU sharing, a process typically gets short bursts of running time before being switched out.

  4. Waiting/Blocked: Sometimes processes need to pause while waiting for something external, like data from a file or user input. Instead of wasting CPU time, the OS moves these processes to a “waiting” state. Imagine an employee who can’t continue their work until they receive an important email.

  5. Terminated: When a process completes its execution (or when you close an app), it enters the terminated state. The OS then cleans up all resources allocated to that process, reclaiming memory and closing files — like clearing out a desk after someone leaves.

Process Control: The OS as Traffic Controller

The OS has several mechanisms to manage processes throughout their lifecycle:

  • Process Creation: The OS can spawn new processes either at user request (when you open an app) or when an existing process creates a child process (like when your browser opens a new tab).

  • Process Scheduling: The OS decides which ready processes get CPU time and for how long, using sophisticated scheduling algorithms that balance fairness, priority, and performance.

  • Process Suspension: The OS can temporarily pause a running process, saving its complete state. This happens automatically during multitasking or can be triggered by events like pressing Ctrl+Z in a terminal.

  • Process Resumption: A suspended process can later be resumed from exactly where it left off. The OS restores its saved state and puts it back in the ready queue to await CPU time.

  • Process Termination: Processes can end voluntarily (when a program completes its task) or be forcibly terminated (when you use Task Manager to kill an unresponsive app or when a critical error occurs).

Process Relationships and Communication

Processes rarely exist in isolation:

  • Parent-Child Relationships: Processes often create other processes, forming family trees of related processes. The web browser process might spawn child processes for each tab.

  • Inter-Process Communication (IPC): Processes need to talk to each other, which they do through mechanisms like pipes, shared memory, message queues, and signals — all managed by the OS.

  • Synchronization: The OS provides tools like semaphores and mutexes to help processes coordinate when accessing shared resources, preventing conflicts.

When you open Chrome, Word, and Spotify at the same time, each runs as a separate process with its own memory space and resources. The OS juggles them all, rapidly switching between them to create the illusion they’re all running simultaneously. If Chrome crashes, the OS ensures that the problem is contained within Chrome’s process boundaries, allowing Word and Spotify to continue playing your favorite tunes without missing a beat. Pretty neat, right?

Resources: The Currency of Computing

Resources are all the things programs need to run — like CPU time, memory, disk space, network bandwidth, and access to devices like printers or graphics cards.

The OS is ultimately a sophisticated resource manager that:

  • Tracks available resources
  • Handles resource requests from applications
  • Allocates resources fairly and efficiently
  • Recovers resources when programs finish or crash

At a technical level, resource management involves several complex mechanisms:

  • Resource Accounting: The OS maintains detailed metadata about available and allocated resources, including physical memory pages, disk blocks, I/O channels, and CPU utilization statistics.

  • Resource Scheduling: For time-shared resources like CPU, the OS implements scheduling algorithms with policies that optimize for different goals:

    • Throughput (maximizing total work completed)
    • Response time (minimizing user-perceived delay)
    • Fairness (ensuring all processes get adequate resources)
    • Priority satisfaction (allocating more resources to important processes)

  • Resource Protection: The OS implements access control mechanisms to prevent unauthorized use of resources, including:

    • Capability-based security models
    • Access control lists (ACLs)
    • Role-based access control (RBAC)

  • Resource Deadlock Prevention: The OS must handle situations where multiple processes are waiting for resources held by each other. It uses techniques like:

    • Resource allocation graphs to detect cycles
    • Banker’s algorithm to ensure safe allocation states
    • Timeouts and preemption to break deadlocks

For example, when your video editing software asks for 4GB of RAM, the OS checks if that amount is available and then reserves it specifically for that application. Behind the scenes, this involves page table manipulations, possibly moving other data to swap space, and updating internal resource allocation tables.

OS Design Approaches: Different Architectures for Different Needs

Operating systems aren’t all built the same way. Over decades, several design approaches have emerged:

1. Monolithic Structure

Imagine a massive, integrated system where all OS functions operate in a single, large kernel (the core part of the OS).

Technical Characteristics:

  • All OS services run in privileged kernel mode
  • Direct function calls between components for efficiency
  • Static linking of most system components at compile time
  • Typically organized into logical subsystems internally (memory manager, process scheduler, file system, etc.)
  • System call interface provides the boundary between user applications and kernel services

Pros:

  • Direct communication between components
  • Often better performance due to tight integration
  • No message-passing overhead between modules

Cons:

  • A bug in one part can crash the entire system
  • Hard to maintain as it grows larger
  • Requires complete recompilation for most changes

Example: Traditional Unix and early Linux versions used this approach. Linux, while considered monolithic, has evolved to support loadable kernel modules that can be added without recompiling the entire kernel.

Technical Implementation: In a monolithic kernel like Linux, when a user program executes a system call (like read()), the CPU switches from user mode to kernel mode, the kernel executes the entire operation within its address space, and then returns control to the user program.

2. Layered Structure

Picture a wedding cake with distinct layers, each built on top of the one below, with each layer providing services to the layers above it.

Technical Characteristics:

  • Hierarchical organization with well-defined interfaces between layers
  • Lower layers handle more primitive operations (closer to hardware)
  • Higher layers implement more abstract functions
  • Each layer only uses functions and services of lower layers
  • Typically follows the principle of information hiding between layers

Pros:

  • Better organization and separation of functions
  • Easier to debug and maintain
  • Simplifies design and verification
  • Changes to one layer don’t affect other layers if interfaces remain stable

Cons:

  • Performance overhead from communication between layers
  • Lower layers can become bottlenecks
  • Strict layering can lead to duplication of functionality
  • Determining the optimal number of layers is challenging

Example: THE (Technische Hogeschool Eindhoven) operating system used a strict layered approach with six layers, from hardware management at the bottom to user programs at the top. Modern network protocols like TCP/IP also use a layered design (the OSI model).

Technical Implementation: In a layered system, a request like “open a file” traverses down through layers: user interface → file system manager → logical disk manager → disk driver → hardware controller. Each layer processes the request, adds its own control information, and passes it to the next layer.

3. Modular Structure

Think of a LEGO set where different components (modules) can be added or removed as needed.

Technical Characteristics:

  • Core kernel with dynamically loadable modules
  • Well-defined interfaces and communication protocols between modules
  • Object-oriented design principles often used
  • Support for hot-swapping modules without system restart
  • Configuration and tuning without full recompilation

Pros:

  • Flexible and extensible
  • Easier to maintain and update individual components
  • Facilitates independent development of different parts
  • Allows for customization without modifying core functionality
  • Only necessary modules need to be loaded, reducing memory footprint

Cons:

  • Requires well-defined interfaces between modules
  • Potential performance overhead from communication
  • Complex dependency management between modules
  • Potential for version compatibility issues

Example: Modern Linux is largely modular, allowing kernel modules to be loaded/unloaded. For instance, device drivers, file systems, and networking protocols are implemented as loadable kernel modules (LKMs) with the .ko extension.

Technical Implementation: In Linux, the insmod and modprobe commands load kernel modules, which then register themselves with specific kernel subsystems. The kernel maintains a module dependency tree and reference counts to manage module relationships and ensure safe unloading.

4. Microkernel Structure

Imagine keeping only the absolute essentials in the core kernel and running everything else as separate services.

Technical Characteristics:

  • Minimal kernel handling only critical functions:
    • Low-level memory management
    • Basic inter-process communication (IPC)
    • Elementary process scheduling
  • All other OS services (file systems, device drivers, network protocols) run as user-mode processes
  • Communication via message passing through IPC mechanisms
  • Hardware abstraction layer often included in the microkernel

Pros:

  • Improved reliability (if one service crashes, others continue)
  • Better security through isolation
  • Easier to extend and maintain
  • Smaller trusted computing base (TCB)
  • More portable across hardware platforms

Cons:

  • Performance overhead from message-passing IPC
  • More complex design
  • Increased context-switching overhead
  • Potentially higher latency for system calls

Example: MINIX was designed as a true microkernel system for educational purposes. QNX is a commercial real-time OS with microkernel architecture used in automotive and industrial systems. macOS/iOS is partially based on a hybrid kernel called XNU that combines microkernel design elements with monolithic components.

Technical Implementation: In a microkernel system like MINIX, when an application needs to read a file, it sends a message to the file system server, which processes the request and sends a message to the disk driver, which then interacts with the hardware. The microkernel itself only handles the passing of these messages between processes.

How Security, Networking, and Multimedia Shape Modern OS Design

Modern operating systems have evolved dramatically to address new challenges:

Security Considerations

Security has become a primary design concern for OS developers:

  • Process Isolation: Prevents one app from accessing another’s data through memory protection units (MPUs) and virtual memory techniques. Modern CPUs implement protection rings (with ring 0 for kernel mode and ring 3 for user mode) to enforce privilege separation.

  • User Permissions: Control who can access what through access control mechanisms:

    • Discretionary Access Control (DAC): Owner-based permissions (like Unix’s read/write/execute bits)
    • Mandatory Access Control (MAC): System-enforced policies (like SELinux)
    • Role-Based Access Control (RBAC): Permissions based on user roles

  • Encryption: Protects sensitive data through techniques like:

    • Full disk encryption (BitLocker, FileVault)
    • Secure boot with trusted platform modules (TPMs)
    • Memory encryption to prevent cold boot attacks
    • Encrypted swap to protect data paged to disk

  • Secure Boot: Ensures the system hasn’t been tampered with by verifying digital signatures of boot components and creating a chain of trust from firmware to OS kernel.

  • Regular Security Updates: Patch vulnerabilities through a structured process:

    • Security bulletins to notify users
    • CVE (Common Vulnerabilities and Exposures) tracking
    • Patches distributed through centralized update mechanisms

These security features aren’t add-ons; they’re deeply integrated into the core OS design. Modern operating systems also implement Address Space Layout Randomization (ASLR), Stack Canaries, Data Execution Prevention (DEP), and sandboxing techniques to mitigate various attack vectors.

Networking Integration

Today’s operating systems are built with the assumption that devices will be connected:

  • Network Stack: Built into the kernel with implementation of:

    • Protocol layers (Ethernet, IP, TCP/UDP)
    • Socket interfaces for application communication
    • Protocol-independent mechanisms like Berkeley sockets or Windows Winsock
    • Buffering and flow control mechanisms

  • Seamless File Sharing: Across devices through protocols and services like:

    • Server Message Block (SMB)/Common Internet File System (CIFS) for Windows
    • Network File System (NFS) for Unix/Linux systems
    • Apple Filing Protocol (AFP) and SMB for macOS
    • Distributed file systems like Andrew File System (AFS)

  • Remote Access Capabilities:

    • Secure Shell (SSH) for command-line access
    • Remote Desktop Protocol (RDP) for Windows
    • Virtual Network Computing (VNC) for cross-platform support
    • X11 forwarding for Unix/Linux GUI applications

  • Distributed Computing Support:

    • Remote procedure calls (RPCs) and distributed objects
    • Clustering and load balancing capabilities
    • Distributed locking mechanisms
    • Support for message queuing systems

  • Built-in Network Protection:

    • Stateful packet inspection firewalls
    • Network Address Translation (NAT) for sharing connections
    • Intrusion detection/prevention systems
    • Quality of Service (QoS) for bandwidth management

Remember when you had to install separate software to connect to the internet? Now networking is an integral part of every OS, with sophisticated capabilities like zero-configuration networking (like Apple’s Bonjour), IPv6 support, and software-defined networking interfaces.

Multimedia Support

As computers evolved from text-processing machines to multimedia powerhouses, OS design adapted:

  • Hardware Acceleration for Media:

    • Graphics Processing Unit (GPU) integration for video rendering
    • DirectX (Windows) and Metal (Apple) APIs for hardware-accelerated graphics
    • OpenGL and Vulkan cross-platform graphics acceleration
    • Digital Signal Processor (DSP) utilization for audio processing
    • Video decode/encode acceleration through frameworks like VDPAU, VAAPI, and NVENC

  • Advanced Graphics Subsystems:

    • Compositing window managers (like Windows DWM or macOS Quartz Compositor)
    • Hardware-accelerated 2D and 3D rendering pipelines
    • Multiple display support with different resolutions and refresh rates
    • Color management systems for accurate color reproduction
    • High dynamic range (HDR) and wide color gamut support

  • Media Streaming Capabilities:

    • Low-latency audio streaming through WASAPI (Windows) or CoreAudio (Apple)
    • Video streaming APIs with buffer management
    • Adaptive bitrate techniques for network conditions
    • Time synchronization between audio and video streams
    • Digital Rights Management (DRM) integration

  • Real-time Processing:

    • Priority scheduling for time-sensitive media applications
    • Low-latency audio paths with minimal buffer sizes
    • Hardware-accelerated video conferencing codecs
    • Echo cancellation and noise reduction algorithms
    • Camera and microphone privacy controls

  • Media Format Support:

    • Codec frameworks (DirectShow, Media Foundation, AVFoundation)
    • Container format handling (MP4, MKV, etc.)
    • Metadata extraction and indexing
    • Transcoding capabilities for format conversion
    • Accessibility features like closed captioning

Modern OS multimedia subsystems are remarkably complex, often involving specialized driver models like Windows Display Driver Model (WDDM) or macOS’s IOKit graphics stack, which provide capabilities far beyond the simple bitmap displays of early operating systems.

Bringing It All Together

So, what even is an operating system? It’s the sophisticated conductor of your computer’s orchestra, ensuring all the components work together harmoniously. It’s the mediator between your hardware and software, and the platform that makes modern computing possible.

Next time you start up your device, take a moment to appreciate the incredible complexity working behind the scenes. From managing your CPU cycles to ensuring your files are stored safely, your OS is constantly juggling countless tasks so you can focus on what matters — using your computer to work, create, connect, and play.

In the next post, we’ll dive into how operating systems handle multiple tasks simultaneously without everything descending into chaos.