Inside an Operating System

Why should you care?

You interact with an operating system every day.

You open applications, create files, connect to Wi-Fi, plug in a USB device, and switch between programs without thinking about what makes all of this possible.

But what exactly is happening inside an operating system?

The operating system is much more than a graphical interface.

Behind the desktop is a collection of systems responsible for managing:

• CPU
• Memory
• Processes
• Files
• Hardware
• Networking
• Security
• Applications

Understanding these components gives you the foundation for learning Operating Systems, system programming, backend engineering, and computer architecture.

The Problem

Imagine opening a browser while a music player, code editor, and terminal are already running.

Your computer somehow manages all of them at the same time.

At the same moment, it may also be:

Reading a file
Receiving network packets
Managing RAM
Scheduling processes
Handling keyboard input
Displaying graphics

The hardware cannot simply allow every application to directly control it.

Imagine if every program could freely access your memory or control your disk.

One badly written program could crash the entire machine.

This is where the operating system comes in.

The Concept

The operating system acts as a manager between applications and hardware.

A simplified architecture looks like this:

┌─────────────────────────────┐
│        Applications         │
│ Browser | Editor | Games    │
├─────────────────────────────┤
│        System Calls         │
├─────────────────────────────┤
│           Kernel            │
│                             │
│ Process Management          │
│ Memory Management           │
│ File System                 │
│ Device Drivers              │
│ Networking                  │
│ Security                    │
├─────────────────────────────┤
│          Hardware           │
│ CPU | RAM | Disk | Devices  │
└─────────────────────────────┘

The most important component here is the kernel.

What Is the Kernel?

The kernel is the core component of an operating system.

It runs with high privileges and manages access to hardware resources.

The kernel is responsible for things such as:

• Process and thread management
• Memory management
• Device management
• File systems
• Networking
• Security and access control

For example, when an application wants to read a file, it does not normally communicate directly with the SSD.

Instead:

Application
    ↓
System Call
    ↓
Kernel
    ↓
File System
    ↓
Storage Device

The kernel coordinates the operation.

Simple Explanation

Think of an operating system as a hotel.

The hardware is the hotel building.

The applications are the guests.

The kernel is the hotel management.

Guests cannot simply:

• Enter another guest's room.
• Modify the building's electrical system.
• Take over the entire kitchen.
• Access restricted areas.

Instead, they make requests to management.

Similarly, applications request resources from the operating system.

Application
     ↓
Request
     ↓
Operating System
     ↓
Hardware

This separation keeps the system organized and secure.

User Space vs Kernel Space

One of the most important ideas in operating systems is the separation between user space and kernel space.

User Space

Normal applications run here.

Examples:

Browser
Terminal
Code Editor
Music Player

Applications have restricted access to hardware and operating system resources.

Kernel Space

The kernel runs here.

It has much greater privileges and can interact with hardware and critical system resources.

The simplified relationship is:

User Space
    ↓
System Calls
    ↓
Kernel Space
    ↓
Hardware

This separation is fundamental to system stability and security.

Real-world Analogy

Imagine an airport.

Passengers are applications.

The airport staff are the operating system.

Restricted areas such as:

Control Room
Runway
Security Area

represent privileged system resources.

Passengers cannot simply walk into these areas.

They must go through controlled procedures.

Similarly, an application cannot simply execute privileged hardware operations whenever it wants.

It must use controlled interfaces provided by the operating system.

Processes and Threads

The operating system manages running programs using processes and threads.

A process is an executing program with its own resources and virtual address space.

A process can contain multiple threads.

For example:

Browser Process
│
├── UI Thread
├── Network Thread
├── Rendering Thread
└── Worker Threads

The operating system schedules runnable threads onto CPU cores.

This allows many applications to make progress concurrently.

Memory Management

The operating system manages memory between processes.

Suppose you have:

Browser → 2 GB
IDE     → 1 GB
Terminal → 100 MB
Game    → 4 GB

The operating system has to keep track of all of this memory.

Modern systems use virtual memory.

A simplified model is:

Process A
Virtual Memory
      ↓
      OS
      ↓
Physical RAM

Each process gets its own virtual address space.

This helps prevent one application from directly accessing another application's memory.

File Systems

When you create:

notes.txt

the operating system has to manage much more than the filename.

It needs to track:

• Where the file's data is stored.
• File size.
• Permissions.
• Ownership.
• Timestamps.
• Directory structure.
• Metadata.

The file system provides an abstraction over the underlying storage device.

Instead of thinking about physical sectors, applications can work with concepts such as:

/home/user/notes.txt

The operating system and file system handle the underlying details.

Device Drivers

Your computer contains many hardware devices:

Keyboard
Mouse
GPU
Wi-Fi Adapter
USB Device
Audio Device
Storage Controller

The operating system needs a way to communicate with these devices.

This is where device drivers come in.

A driver provides software interfaces that allow the operating system to communicate with particular hardware.

Simplified:

Application
    ↓
Operating System
    ↓
Device Driver
    ↓
Hardware

Without appropriate driver support, the operating system may not be able to use a device correctly.

System Calls

Applications need controlled access to operating system functionality.

They use system calls.

For example, a program might need to:

Open a file
Read data
Write data
Create a process
Allocate memory
Create a socket

Conceptually:

Application
    ↓
System Call
    ↓
Kernel
    ↓
Resource

System calls form an important boundary between user programs and privileged kernel operations.

Code Example

Consider a simple C program:

#include <stdio.h>

int main() {
    printf("Hello World\n");
    return 0;
}

At the source-code level, it looks like printf() simply prints text.

But internally, several layers are involved.

A simplified flow is:

printf()
   ↓
C Library
   ↓
System Call
   ↓
Kernel
   ↓
Terminal / Device
   ↓
Display

The exact path depends on the operating system, runtime libraries, terminal implementation, and buffering behavior.

The important idea is that your application does not need to understand the hardware details itself.

The operating system provides abstractions.

Common Mistakes

Mistake 1: Thinking the operating system is just the GUI

The graphical desktop is only one part of the overall system.

A Linux system can run without a graphical desktop.

The kernel and other system components can operate without a GUI.

Mistake 2: Thinking applications directly control hardware

Normally, applications use operating system interfaces.

The kernel controls privileged access to hardware and system resources.

Mistake 3: Thinking the kernel is the entire operating system

The kernel is the core of the operating system, but a complete operating system environment also contains many other components.

For example:

Kernel
+
System Libraries
+
System Utilities
+
Services
+
Drivers
+
User Interface

The exact architecture varies between operating systems.

Mistake 4: Thinking every operating system has the same architecture

Windows, Linux, macOS, Android, and other operating systems have different implementations and design choices.

The concepts are similar, but the details differ.

Advanced Notes

Monolithic Kernel

In a monolithic kernel architecture, many core operating system services run inside kernel space.

Linux is commonly described as a monolithic kernel with modular capabilities.

This can provide efficient communication between kernel components while still allowing modules to be loaded dynamically.

Microkernel

A microkernel keeps the kernel itself relatively small and moves more services into user space.

Conceptually:

User Space
├── File Server
├── Network Server
└── Device Services

Kernel
└── Minimal Core

This can improve isolation and modularity, although communication between components can introduce additional complexity and overhead.

Interrupts

Hardware devices sometimes need to get the CPU's attention.

For example:

Keyboard Input
      ↓
Interrupt
      ↓
CPU
      ↓
Operating System
      ↓
Application

Interrupts allow hardware and software events to be handled without continuously checking every device.

Scheduling

A CPU core can execute only a limited amount of work at any given instant.

The operating system scheduler decides which runnable thread should execute.

Simplified:

Thread A ─┐
Thread B ─┤
Thread C ─┼──→ Scheduler → CPU
Thread D ─┤
Thread E ─┘

Scheduling algorithms attempt to balance responsiveness, fairness, throughput, and other goals.

The Bigger Picture

The operating system connects everything we have discussed so far.

Applications
      ↓
Programming Languages
      ↓
Compiler / Runtime
      ↓
System Calls
      ↓
Operating System
      ↓
Kernel
      ↓
CPU + Memory + Devices

The operating system provides abstractions that allow programmers to work with high-level concepts instead of directly controlling hardware.

For example, you can write:

FileInputStream file = ...

instead of manually controlling the physical storage device.

You can create a network connection using an API instead of directly manipulating Ethernet hardware.

You can allocate memory without manually controlling physical RAM addresses.

The operating system hides enormous amounts of complexity behind relatively simple interfaces.

Summary

An operating system is a resource manager and abstraction layer between applications and hardware.

Its core responsibilities include:

• Process management
• Memory management
• File systems
• Device management
• Networking
• Security
• Scheduling

The kernel sits at the center of these responsibilities.

The simplified architecture is:

Applications
     ↓
System Calls
     ↓
Kernel
     ↓
Hardware

The most important idea to remember is:

Applications should not need to understand hardware details. The operating system provides the abstractions and controlled interfaces that allow software to use hardware safely and efficiently.

Once you understand this, concepts such as processes, threads, virtual memory, system calls, file systems, and device drivers stop looking like unrelated topics.

They are all pieces of the same machine.