What is an Operating System? Definition, Functions, and Types

An operating system (OS) is system software that acts as an intermediary between hardware and application programs. This guide defines an operating system, covers its 6 core functions, explains kernel architecture types, identifies the 5 major operating systems with market share data, and describes process scheduling algorithms and virtual memory management.

What Is an Operating System?

An operating system is a layer of software that manages computer hardware resources and provides a controlled environment in which application programs execute. Without an OS, every application would need to include its own hardware drivers, memory management code, and input/output routines. The OS abstracts this complexity, exposing standardized APIs (Application Programming Interfaces) that applications use to request hardware services.

Three defining responsibilities separate an OS from other software: resource allocation (deciding which process gets CPU time, RAM, and I/O bandwidth), isolation (preventing processes from corrupting each other’s memory or monopolizing hardware), and abstraction (presenting hardware devices as uniform, standardized interfaces regardless of the underlying manufacturer’s specifications).

6 Core Functions of an Operating System

An operating system performs 6 core functions that together enable application software to run on diverse hardware:

1. Process Management

Process management creates, schedules, and terminates processes. A process is a program in execution, with its own memory space, register state, and file handles. The OS scheduler decides which process uses the CPU at any moment, switching between processes at intervals as short as 1–10 milliseconds on a typical desktop OS.

Linux supports up to 32,768 concurrent processes by default (configurable to 4,194,304). Windows supports up to 2,097,152 processes in theory, limited in practice by RAM.

2. Memory Management

Memory management allocates RAM to processes and reclaims it when processes terminate. Modern OSes implement virtual memory, giving each process an isolated address space.

A 64-bit OS presents each process a theoretical address space of 16 exabytes (2⁶⁴ bytes), regardless of physical RAM installed. The OS maps virtual addresses to physical RAM through page tables, with page sizes typically 4KB.

3. File System Management

File system management organizes data on storage devices into hierarchical directory structures. The OS mediates all read and write operations, enforcing access permissions so unauthorized processes cannot read or overwrite protected files. Windows uses NTFS as its primary file system (max file size 16TB); Linux defaults to ext4 (max file size 16TB); macOS uses APFS.

4. Device Management

Device management communicates with hardware peripherals through device drivers. A driver is a software module that translates OS-level I/O requests into the specific command sequences required by a particular hardware device.

The OS maintains a device driver model that allows hardware manufacturers to write drivers conforming to a standard interface. Windows has a Hardware Abstraction Layer (HAL); Linux uses a unified device model under the /sys filesystem.

5. Security and Access Control

Security management enforces access control policies through user accounts, permissions, and privilege levels. Modern OSes operate in at least two privilege rings: kernel mode (ring 0), where the OS core runs with unrestricted hardware access, and user mode (ring 3), where applications run with restricted access.

An application running in user mode cannot directly access hardware or other processes’ memory. Attempting to do so triggers a privilege violation exception, which the OS handles by terminating the offending process.

6. User Interface

The OS provides a user interface layer — either a Graphical User Interface (GUI) or Command Line Interface (CLI) — through which users and administrators interact with the system. Windows 11 and macOS Ventura provide full GUI desktop environments.

Linux distributions provide both: GNOME and KDE Plasma as GUIs, and Bash/Zsh as CLI shells. Servers often run headless (no GUI) to reduce memory overhead; a GUI desktop environment can consume 200–600MB of RAM compared to a minimal CLI server installation at 64–128MB.

OS Architecture Layers

A modern OS organizes its components into 4 layers from hardware to user interaction:

1. Hardware layer: Physical CPU, RAM, storage, and peripherals. The OS does not belong to this layer but manages it.
2. Kernel layer: The core OS component running in privileged mode. Handles process scheduling, memory management, device drivers, and system calls.
3. System libraries and APIs: Standard libraries (glibc on Linux, ntdll.dll on Windows) that translate application requests into kernel system calls.
4. User space: Applications and user-facing processes running in unprivileged mode, isolated from direct hardware access.

Kernel Architecture Types

The kernel is the core of the OS. Three kernel architecture designs differ in how much code runs in privileged kernel mode:

Monolithic Kernel

A monolithic kernel runs all OS services — process management, memory management, file systems, and device drivers — in a single large block of code in kernel mode. All components share the same address space and can call each other directly. Advantages: low inter-component call overhead.

Disadvantage: a bug in any driver crashes the entire kernel. Linux uses a monolithic kernel with loadable modules. The Linux kernel 6.x source contains approximately 27 million lines of code.

Microkernel

A microkernel runs only the most essential services in kernel mode: CPU scheduling, inter-process communication (IPC), and basic memory management. All other services — file systems, network stacks, device drivers — run as isolated user-mode server processes.

A bug in a driver crashes only that driver process, not the kernel. Disadvantage: IPC overhead between user-mode servers reduces performance. seL4 and QNX use microkernel architectures. seL4 has a formally verified kernel of approximately 9,000 lines of C code.

Hybrid Kernel

A hybrid kernel places performance-critical components in kernel mode while moving less critical services to user mode. Windows NT (the basis for all Windows versions since NT 3.1) uses a hybrid kernel, with most device drivers running in kernel mode for performance but with an executive layer separating kernel services. macOS XNU is also hybrid: a Mach microkernel core plus BSD Unix components running in kernel mode for performance.

5 Major Operating Systems

Five operating systems dominate global usage across desktop, mobile, and server markets:

Process Scheduling Algorithms

The OS scheduler uses algorithms to determine CPU time allocation. Three foundational scheduling algorithms appear in all OS textbooks and real implementations:

First-Come, First-Served (FCFS)

FCFS executes processes in the order they arrive in the ready queue. Average waiting time is high when short processes queue behind long ones — the convoy effect. FCFS is non-preemptive: once a process starts, it runs until it blocks or terminates.

Batch processing systems used FCFS. No modern interactive OS uses pure FCFS for CPU scheduling.

Round Robin (RR)

Round Robin assigns each process a fixed CPU time slice called a quantum, typically 10–100 milliseconds. When a process exhausts its quantum, the OS preempts it and moves it to the back of the ready queue. The next process runs.

RR provides equal CPU distribution, ideal for interactive systems. Linux’s Completely Fair Scheduler (CFS) implements a proportional variant of round robin weighted by process priority (nice values from −20 to +19).

Priority Scheduling

Priority scheduling assigns each process a numeric priority. The scheduler always runs the highest-priority runnable process. Real-time processes receive the highest priorities.

Windows uses priority levels 0–31, with real-time priorities at 16–31. Linux real-time priorities range from 1–99 under SCHED_FIFO and SCHED_RR policies. Priority inversion — a low-priority process blocking a high-priority process via a shared lock — is a known hazard addressed by priority inheritance protocols.

Virtual Memory and Paging

Virtual memory allows each process to use more memory than physically installed RAM by mapping pages to disk storage when RAM is full. The OS divides virtual and physical memory into fixed-size pages, typically 4KB. A page table maps each virtual page to a physical frame.

When a process accesses a virtual page not currently in RAM, a page fault occurs. The OS loads the required page from the page file (Windows) or swap partition (Linux) and resumes execution. Page fault resolution takes 1–10 milliseconds — roughly 1,000× slower than a RAM access.

The Translation Lookaside Buffer (TLB) is a CPU hardware cache for page table entries. A TLB hit resolves a virtual-to-physical address translation in 1 clock cycle.

A TLB miss requires a page table walk taking 10–100 clock cycles. Modern CPUs have TLBs with 64–1,024 entries covering the most recently accessed pages.

Types of Operating Systems

Operating systems are categorized by use case and architecture into 5 types:

• Batch OS: Processes jobs sequentially without user interaction during execution. IBM z/OS on mainframes processes large transaction batch workloads overnight.
• Time-sharing OS: Shares CPU among multiple interactive users using time slicing. UNIX was the first widely deployed time-sharing OS, supporting hundreds of simultaneous terminal users on a single PDP-10.
• Real-time OS (RTOS): Guarantees response to events within defined time bounds. FreeRTOS and VxWorks are RTOSes used in embedded systems and industrial control where missed deadlines cause physical harm.
• Distributed OS: Manages multiple networked computers as a single unified system. Google’s Borg and Kubernetes are production distributed OS platforms managing millions of containerized workloads across data center clusters.
• Network OS: Provides network services as its primary function. Cisco IOS and Juniper Junos are network operating systems running on routers and switches, handling packet forwarding at terabits per second.

Key Takeaways

• An operating system manages hardware resources and provides services to application programs through 6 core functions: process management, memory management, file system management, device management, security, and UI.
• Three kernel architectures exist: monolithic (Linux), microkernel (seL4, QNX), and hybrid (Windows NT, macOS XNU).
• Windows 11 holds ~72% desktop market share; Linux dominates servers at ~96% of cloud infrastructure; Android holds ~72% mobile share.
• Virtual memory uses paging to give each process a 16-exabyte address space (64-bit), mapped to physical RAM via page tables and the TLB.
• The Linux kernel 6.x contains approximately 27 million lines of code; seL4’s verified microkernel contains approximately 9,000 lines.
• Round Robin scheduling with quantum sizes of 10–100ms is the basis for modern interactive OS schedulers including Linux CFS.

Frequently Asked Questions

Responsiveness varies sharply between platforms, and a comparison of the fastest operating system options explains why a lean kernel and fewer background services produce quicker boot and load times.

Last Thoughts on Operating Systems

The operating system is the foundation on which all software runs. Its 6 core functions — process management, memory management, file system management, device management, security, and UI — abstract hardware complexity into standardized interfaces that application developers rely on.

Kernel architecture choices between monolithic, microkernel, and hybrid designs involve direct trade-offs between performance, fault isolation, and verifiability. Understanding how an OS allocates CPU time, manages virtual memory through paging, and communicates with hardware through drivers is foundational knowledge for software development, systems administration, and computer science education.