Operating Systems
— Complete DIT Notes

What Is an Operating System?

An OS is the software layer that sits between your hardware and every program you run. It allocates CPU time, manages memory, controls storage, and enforces security — so applications never have to talk to hardware directly.

OS design evolved through stages: Batch (jobs queued, no interaction) → Multiprogramming (multiple jobs held in memory, CPU switches between them) → Time-Sharing (multiple users, fast switching creates the illusion of simultaneity) → Real-Time (guaranteed response times for critical systems like medical devices or industrial control).

Kernel Architecture & System Calls

The kernel is the core of the OS — the part that actually talks to hardware. A Monolithic kernel (Linux) runs almost everything — drivers, file systems, memory management — in one privileged space for speed. A Microkernel (older QNX, parts of Windows NT) keeps only the bare essentials in privileged space and runs the rest as separate services, trading some speed for stability and security.

Programs never touch hardware themselves — they ask the kernel through system calls (e.g. open(), read(), fork()). This is the boundary between User Mode (where your applications run, restricted) and Kernel Mode (full hardware access, trusted code only).

Process Concepts

Every running program is a process, tracked by the kernel through a Process Control Block (PCB) — a data structure holding its ID, state, register values, memory pointers, and priority.

A process moves through five states: New (being created) → Ready (waiting for CPU) → Running (executing) → Waiting (blocked on I/O) → Terminated. It can bounce between Ready and Running many times before finishing.

CPU Scheduling

Since one CPU core can only run one instruction at a time, the OS uses schedulers to decide execution order. The long-term scheduler decides which processes enter the Ready queue; the short-term scheduler decides which Ready process runs next — this happens constantly, via context switching (saving one process's state, loading another's).

Threads & Concurrency

A thread is a lightweight unit of execution inside a process — multiple threads in one process share the same memory space, unlike separate processes which are isolated. A single-threaded app does one thing at a time; a multi-threaded app (e.g. a web browser) runs several tasks concurrently within the same process. A basic hazard to know: a deadlock happens when two processes each hold a resource the other needs, and neither can proceed.

Address Spaces & Linking

A process works with a logical (virtual) address space — addresses it thinks it owns. The Memory Management Unit translates these to physical addresses in real RAM. Dynamic loading loads a routine into memory only when it's called; dynamic linking connects a program to shared libraries at run time instead of baking them in at compile time.

Swapping & Fragmentation

Swapping temporarily moves an inactive process out of RAM to disk to free space for others. With contiguous allocation, memory develops internal fragmentation (wasted space inside an allocated block) and external fragmentation (free memory scattered in unusable small chunks) — solved by periodic compaction, which shuffles processes together to consolidate free space.

Paging, Segmentation & Virtual Memory

Paging splits memory into fixed-size pages, tracked in a per-process page table; a TLB (Translation Lookaside Buffer) caches recent translations for speed. Segmentation instead divides memory by logical unit (code, stack, heap) with variable sizes. Virtual memory combines these ideas with demand paging — pages load only when actually needed, triggering a page fault if a needed page isn't in RAM. When RAM is full, a page replacement algorithm decides what to evict.

Files, Attributes & Access Methods

Every file has attributes — name, type, size, permissions, timestamps. Files support operations like create, read, write, delete, and can be accessed sequentially (read start to finish, like a tape) or via direct/random access (jump straight to any byte, like a disk).

Directory Structures

A single-level directory holds all files in one flat list (fine for tiny systems, unusable at scale). A two-level directory gives each user their own directory. A tree-structured directory — what every modern OS uses — allows unlimited nested subdirectories.

Command Line Fundamentals

Windows CLI comes in two flavours — the legacy Command Prompt (CMD) and the modern, scriptable PowerShell. Linux uses Bash almost universally, built around pipelines (|) that feed one command's output into the next, and redirection (>, >>) to send output to a file instead of the screen.