Operating System Slides 📂 Introduction · 3 of 22 49 min read

OS Generations, System Boot, Services, User Interfaces & System Calls

A visual walk through operating systems — the five generations from vacuum tubes to cloud, the six-stage boot from power button to login, the services an OS provides, the CLI/GUI/touch/voice interfaces, and system calls: the single guarded doorway into the kernel, with animated diagrams throughout.

⚙️

OS Generations, Boot, Services, Interfaces & System Calls

Eighty years of operating systems, the journey from power button to login screen, the services the OS provides, the ways humans and programs talk to it — and the single guarded doorway into the kernel.
Generations System Boot OS Services System Calls

Press Next → or use ← → arrow keys

Section 01

Five Generations of Operating Systems

📡 ANALOGY · FROM TELEGRAMS TO INSTANT MESSAGING
Communication went from telegrams (slow, manual) to landlines, SMS, email and real-time chat. Each leap didn't just add speed — it changed who could communicate and how.

Operating systems evolved the same way. Every generation solved the biggest frustration of the era before it, moving computing steadily closer to ordinary people and further from the raw hardware.
🧭
The Through-Line

Batch fixed one-job-at-a-time waiting. Time-sharing added interactivity. The GUI removed the steep learning curve. Cloud removed the burden of owning hardware. Same direction, five times over.

Section 01 · Diagram

Eighty Years at a Glance

1945–55 💡 Vacuum Tubes No OS · plugboards 1955–65 🎞️ Transistors Batch · FMS, IBSYS 1965–80 🔲 Integrated Circuits Multiprog · UNIX, OS/360 1980–2000 🖥️ PCs & GUI Win · Mac · Linux 2000–now 📱 Mobile & Cloud iOS · Android · K8s
🚀
From Room-Sized to Pocket-Sized

The pulse of light travelling the timeline is the whole story: a room-filling ENIAC with no OS at one end, a phone orchestrated by cloud-scale software at the other — all in a single human lifetime.

Section 01 · Details

What Each Generation Changed

💡
Gen 1 · 1945–55
vacuum tubes
Room-sized ENIAC and UNIVAC. Programmers rewired plugboards by hand. No OS, no compiler; tubes burned out every few minutes.
🎞️
Gen 2 · 1955–65
transistors + batch
Operators fed card decks in batches, run in sequence. The first real OSes — FMS, IBSYS. FORTRAN and COBOL appear.
🔲
Gen 3 · 1965–80
ICs + multiprogramming
IBM OS/360 unifies a product family. MULTICS pioneers time-sharing; UNIX is born (1969). Virtual memory and spooling arrive.
🖥️
Gen 4 · 1980–2000
PCs + GUI
VLSI puts a CPU on one chip. MS-DOS, Macintosh, Windows, Linux. The WIMP desktop from Xerox PARC goes mainstream; TCP/IP networks everything.
📱
Gen 5 · 2000–now
mobile, cloud, AI
iOS and Android make touch the primary input. AWS/Azure/GCP rent computing by the slice; Kubernetes treats thousands of servers as one.
🔮
The Frontier
what's next
AI-assisted schedulers, predictive prefetching, secure enclaves — the OS keeps moving closer to the user and further from the metal.
Section 02

System Boot — From Power Button to Login

🥾 THE BOOTSTRAP PROBLEM
At power-on, RAM is empty. So where does the CPU get its first instruction?

The CPU is hard-wired to fetch from a fixed ROM address (0xFFFFFFF0 on x86-64), where the BIOS/UEFI firmware lives. A tiny bit of ROM loads a small bootloader from disk, which loads the huge kernel, which starts userspace. Each stage bootstraps the next — like pulling yourself up by your own bootstraps.
🔎
Watch It on Linux

dmesg | head -20 shows the kernel's boot messages, systemd-analyze times each stage, and [ -d /sys/firmware/efi ] tells you whether you booted UEFI or legacy BIOS.

Section 02 · Diagram

The Live Boot Sequence

Hardware Firmware (ROM) Disk Kernel space User space You! 1 Power On electricity flows to the board 2 BIOS / UEFI Firmware POST → detect CPU, RAM, disk → pick boot device 3 Bootloader (GRUB / Windows BM) loaded from MBR / ESP → loads the kernel 4 Kernel Initialisation decompress vmlinuz → load drivers → mount root FS 5 Init Process (systemd, PID 1) start services → reach target (multi-user / graphical) 6 Login Prompt / Desktop ✓ the system is ready for you
⛓️
Each Stage Bootstraps the Next

The spark travels top to bottom: hardware wakes firmware, firmware loads the bootloader, the bootloader loads the kernel, the kernel starts init, and init brings you a login screen. Six hand-offs from silicon to desktop.

Section 02 · Firmware

BIOS vs UEFI

FeatureBIOS (legacy, 1975–2015)UEFI (modern, 2005–now)
Bit mode16-bit real mode64-bit
RAM limit1 MBFull RAM & hardware
Boot sourceMBR — first 512 bytesEFI System Partition (.efi)
Max disk size2 TB (32-bit LBA)9.4 ZB (GPT)
SecurityNo Secure BootSecure Boot (signature checks)
InterfaceText menu, keyboard onlyGUI, mouse, network boot
🔐
Why the World Moved to UEFI

UEFI isn't just prettier firmware — it unlocks disks larger than 2 TB, boots in 64-bit from the start, adds network booting, and verifies the bootloader's cryptographic signature with Secure Boot so malware can't hijack the earliest code that runs.

Section 03

The OS Service Constellation

KERNEL the hub 🖥️UI ▶️Exec 🔌I/O 🗂️Files 📡Comm ⚠️Errors ⚖️Alloc 🛡️Protect
✨
Two Families of Services

User-facing: UI, program execution, I/O, file system, communication, error detection. System-facing: resource allocation, accounting, protection & security. Programs reach them through system calls; humans reach them through interfaces.

Section 03 · Details

Every Service, Grouped

ServiceFamilyWhat it does
User InterfaceUserCLI, GUI or touch — human ↔ machine
Program ExecutionUserLoad a binary, run it, terminate cleanly
I/O OperationsUserUniform interface to disk, network, keyboard
File-SystemUserFiles, directories, permissions, search
CommunicationUserPipes, sockets, shared memory, IPC
Error DetectionUserHardware faults, memory errors, bad operations
Resource AllocationSystemShare CPU, RAM, disk among processes
AccountingSystemTrack usage per user for billing/planning
Protection & SecuritySystemIsolate processes, authenticate users
Section 04

Same Task, Four Interfaces

⌨️ CLI $ mkdir p_{01..99} 99 folders · <1 s scriptable · fast 🖱️ GUI 📁 New Folder ×99 click × 99 · minutes discoverable · forgiving 👆 Touch tap · swipe · pinch mobile-first iOS · Android 🎙️ Voice "Hey, make folders…" hands-free Siri · Alexa Same OS — four ways to ask it something
⚡
The Right Tool for the Job

The CLI creates 99 folders in one line in under a second — unbeatable for admins and servers. The GUI is discoverable and forgiving for everyday work. Touch and voice put the OS in your pocket and your living room. There's also the API — the interface programs use, not humans.

Section 05

System Calls — The Doorway to the Kernel

USER SPACE mode bit = 1 · ring 3 ① your code: printf("Hi") ② glibc write() wrapper ③ args → registers ⑧ printf returns, code continues 🚪 syscall trap KERNEL SPACE mode bit = 0 · ring 0 ④ trap → mode switch ⑤ sys_call_table[1] → sys_write ⑥ bytes written to terminal ⑦ return value in RAX → user
🛂
The Only Legal Border Crossing

The syscall instruction (or svc on ARM64) is the only way to flip from user mode to kernel mode. It atomically sets the mode bit and jumps to a fixed kernel entry point. Try to flip that bit yourself and the hardware raises a fault — the OS kills the process.

Section 05 · Layers

API ≠ System Call

LayerWhat it isExample
ApplicationYour programprintf("Hi")
API (library)Portable wrapperglibc write()
System callActual kernel entrysyscall #1 on Linux x86-64
Kernel routineThe handlerLinux sys_write()
HardwareDevice drivertty driver → terminal
📦 How Arguments Reach the Kernel
Registers
Fastest, but limited — up to ~6 args in RDI, RSI, RDX, R10, R8, R9 on Linux x86-64.
Memory block
For many or large arguments: store them in a block and pass the block's address in a register.
Stack
Traditional 32-bit style: push args onto the user stack, the kernel pops them (e.g. old int 0x80).
Section 06

Six Streams Into the Kernel

KERNEL one of six buckets ① Process Control fork · exec · exit · wait ② File Management open · read · write · close ③ Device Mgmt ioctl · request · release ④ Info Maintenance getpid · time · uname ⑤ Communication pipe · socket · send · recv ⑥ Protection chmod · chown · setuid
🪣
Learn Six, Read Any Kernel

Every request from every program lands in one of these six buckets. Once you know them, a syscall table from Linux, Windows or macOS stops being a wall of names and starts making sense.

Section 06 · Details

The Six Categories (Galvin)

CategoryPurposeLinuxWindows
① Process ControlCreate, end, wait, load, runfork, execve, wait, exitCreateProcess
② File ManagementCreate, open, read, write, closeopen, read, write, closeCreateFile, ReadFile
③ Device MgmtRequest/release, get/set attrsioctl, read /dev/*DeviceIoControl
④ Info MaintenanceTime, date, PID, sysinfogetpid, time, unameGetSystemTime
⑤ CommunicationConnections, messages, IPCpipe, socket, send, shmgetCreatePipe, socket
⑥ ProtectionAccess control, permissionschmod, chown, setuidSetFileSecurity
Section 07

System Programs — Between You and the Syscall

You rarely make raw system calls. Instead you run system programs — the utilities bundled with the OS that wrap syscalls in friendly commands.

🗂️
File Manipulation
cp · mv · rm · ls · mkdir
📊
Status Info
date · ps · top · df · uptime
✏️
File Modification
nano · vim · sed · awk
🛠️
Programming Support
gcc · python · make · gdb
🔗
Program Loading
ld · dynamic loader · ldd
🌐
Communications
ssh · curl · ping · mail
⚙️
Background Services
systemd · cron · sshd
🧩
Applications
Browsers, editors, spreadsheets
Section 08 · Practical

Trace echo hi All the Way Down

🔬 Six syscalls hiding behind one word
1
Shell reads your keystrokes with read() from stdin — File Management.
2
Shell parses "echo hi" and calls fork() — Process Control.
3
Child calls execve("/bin/echo", …) — Process Control (kernel loads the binary).
4
echo calls write(1, "hi\n", 3) — File Management (fd 1 = stdout).
5
echo calls exit_group(0) — Process Control (kernel reclaims memory).
6
Parent shell's wait4() returns — Process Control; the prompt reappears.
🔎
Watch Syscalls Live

One word triggers at least six syscalls across two of Galvin's categories. See it yourself with strace on Linux, dtruss on macOS, or Process Monitor on Windows — every interactive command is a little conversation with the kernel.

Section 09

Eight Ideas Worth Remembering

⚙️ GENERATIONS · BOOT · SERVICES · SYSCALLS
1
Each OS generation was born to solve the last one's pain: batch → time-sharing → GUI → cloud.
2
Booting is bootstrapping — tiny ROM code loads a bootloader, which loads the kernel, which starts userspace.
3
BIOS is legacy; UEFI is present — Secure Boot, 64-bit, network boot and disks well beyond 2 TB.
4
OS services split into user-facing and system-facing — reached by syscalls and by interfaces.
5
A system call is the only legal path from user to kernel mode, and the hardware enforces it.
6
API ≠ syscall — the API (glibc, WinAPI) is what you write; it wraps the real kernel entry so your code stays portable.
7
Every syscall fits one of six categories — learn them and any kernel's table becomes readable.
8
Watching a program's kernel entries with strace is the fastest way to truly understand an OS.
FINAL

From Power Button to Kernel Doorway

5OS generations
6Boot stages
9OS services
4Human interfaces
6Syscall categories
1Legal door to the kernel
🎯
You Can Now Follow the Whole Path

From the history that shaped operating systems, through the six-stage boot, the services they offer and the interfaces we use, all the way down to the single guarded syscall instruction — you can now trace any command from a keystroke to the kernel and back.

📚
Where To Go Next

Try strace on your own commands, read man 2 syscalls, and time your boot with systemd-analyze blame. Then dive into process scheduling and memory management to see what the kernel does once you're inside.

⚙️ End of tutorial · Press ← to review, or click Restart

1 / 18