Introduction to Operating Systems

At its most fundamental level, an Operating System (OS) is a collection of software that manages computer hardware resources and provides common services for computer programs. It acts as an intermediary between users/applications and the computer hardware. Without an OS, every programmer would need to write code to directly manipulate disk read-heads, manage voltage levels for memory cells, and handle the intricate timing of network hardware.

The Core Responsibilities

An operating system typically fulfills four primary roles:

1. Resource Manager: The OS allocates resources—such as CPU time, memory space, and file storage—to specific programs and users. It ensures that no single process can monopolize the system or interfere with others.
2. Hardware Abstraction Layer (HAL): It provides a consistent interface to diverse hardware. A program can “write a file” to a disk without knowing whether that disk is a spinning platter HDD, a NAND-flash SSD, or a network-mounted drive.
3. Process Coordinator: It manages the execution of multiple programs simultaneously, a feat known as multitasking. This involves scheduling processes, handling interrupts, and facilitating inter-process communication (IPC).
4. Security and Protection: The OS enforces boundaries. It prevents a browser tab from reading your bank password stored in a password manager’s memory space and ensures that users can only access their own files.

The Dual Mode Operation

A critical concept in modern OS design is the distinction between User Mode and Kernel Mode. This is hardware-supported (via a “mode bit” in the CPU) and is essential for system stability.

• User Mode: Applications (like Chrome, VS Code, or a game) run in User Mode. They have restricted access to hardware. If an application crashes, it only affects that application’s memory space.
• Kernel Mode: The OS kernel runs in Kernel Mode. It has unrestricted access to the hardware and memory. If the kernel crashes, the entire system “Blue Screens” or “Kernel Panics.”

When an application needs to perform a privileged operation (like reading a file or sending a packet), it must perform a System Call. This triggers a transition from User Mode to Kernel Mode, where the OS validates the request, performs the action, and then returns control to the application.

Components of an Operating System

While internal architectures vary, most systems share these core components:

1. The Kernel

The “heart” of the OS. It is the first part of the OS to load and remains in memory. It manages the CPU, memory, and devices. Modern kernels are often categorized as Monolithic (like Linux/Windows) or Microkernels (like Mach/Minix).

2. The Shell and GUI

The user interface. The shell is a command-line interpreter (like bash or PowerShell), while the GUI (Graphical User Interface) provides windows, icons, and menus.

3. System Libraries

These are standard functions that applications use to interact with the kernel (e.g., libc in Unix-like systems or the Win32 API in Windows).

4. Device Drivers

Specialized programs that allow the kernel to communicate with specific hardware devices. The driver “translates” generic OS commands into device-specific instructions.

The Boot Process (Bootstrapping)

How does the OS start? When you press the power button, the CPU is in a primitive state and must be “bootstrapped” into a fully functional environment. This involves a hand-off between several layers of software:

1. BIOS/UEFI: Firmware that performs a Power-On Self-Test (POST) and initializes basic hardware.
2. Bootloader: A specialized program (like GRUB) that loads the OS kernel into memory.
3. Kernel Loading: The kernel takes control, initializes drivers, and sets up memory management.
4. Initialization: The kernel launches the first process (PID 1), which starts the rest of the system.

For a deep dive into these mechanics, see the System Initialization & Booting module later in this course.

Operating systems have evolved from simple “batch processing” systems in the 1950s—which ran one job at a time—to the highly sophisticated, distributed, and real-time systems we use today across laptops, smartphones, and cloud servers. In the following modules, we will dive deeper into the mechanics of how these components work together to create the seamless experience of modern computing.