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

The Five Generations of Operating Systems

Animated Timeline — 80 Years of OS Evolution

1.1 Generation 1 (1945–1955) — Vacuum Tubes, No OS

Machines like ENIAC and UNIVAC I filled entire rooms. A programmer physically rewired plugboards or fed punched cards for every program. There was no operating system, no library, no compiler — just the programmer and raw hardware. Machine failures happened every few minutes because vacuum tubes burned out.

1.2 Generation 2 (1955–1965) — Transistors and Batch Systems

Transistors replaced tubes, making machines smaller and more reliable. Programs were still submitted as decks of punched cards, but an operator collected them into batches and ran them one after another. This gave birth to the first real operating systems — FMS (Fortran Monitor System) and IBM's IBSYS. FORTRAN and COBOL emerged as programming languages.

1.3 Generation 3 (1965–1980) — Integrated Circuits, Multiprogramming

Integrated circuits dramatically shrank hardware. IBM's OS/360 introduced the idea of one OS running across an entire product family. MULTICS pioneered time-sharing; its lessons produced UNIX at Bell Labs in 1969. Key concepts born here: multiprogramming, virtual memory, spooling, time-sharing, minicomputers.

1.4 Generation 4 (1980–2000) — Personal Computers and GUI

VLSI put a full CPU on a single chip. MS-DOS (1981), the Apple Macintosh (1984), Windows 3.1 (1992), and Linux (1991) put a computer on every desk. Xerox PARC's WIMP interface (Windows, Icons, Menus, Pointer) became mainstream. TCP/IP networking made network operating systems possible.

1.5 Generation 5 (2000–Present) — Mobile, Cloud, and AI

iOS (2007) and Android (2008) made touch the primary input. Cloud OS platforms (AWS, Azure, GCP) turned data centers into rentable slices. Container orchestration (Kubernetes) treats thousands of servers as one machine. AI-assisted schedulers, predictive prefetching, and secure enclaves define the current frontier.

System Boot — From Power Button to Login Screen

When you press the power button, your computer has no idea what an OS is. Getting from "electricity flowing" to "here's your desktop" is a carefully choreographed boot sequence. Galvin calls the small program that starts it all the bootstrap program.

Animated Boot Flow — Six Stages, Each Bootstrapping the Next

2.1 BIOS vs UEFI — The Firmware Layer

2.2 Practical — Observe Your Own Boot Sequence

# Linux — see kernel messages from the boot sequence
$ dmesg | head -20
[    0.000000] Linux version 6.5.0-15-generic (gcc 11.4.0)
[    0.000000] Command line: BOOT_IMAGE=/vmlinuz root=UUID=... ro quiet
[    0.043210] ACPI: Early table checksum verification disabled
[    0.145678] smpboot: CPU0: Intel(R) Core(TM) i7-12700H
[    0.789012] usb 1-1: new high-speed USB device number 2

# How long each stage took
$ systemd-analyze
Startup finished in 2.851s (kernel) + 4.213s (userspace) = 7.064s
graphical.target reached after 4.198s in userspace

# Which services were the slowest to start
$ systemd-analyze blame | head -5
 2.410s  NetworkManager-wait-online.service
 1.184s  snapd.service
  978ms  plymouth-quit-wait.service
  542ms  systemd-journal-flush.service
  318ms  udisks2.service

# Are you booted via UEFI or BIOS?
$ [ -d /sys/firmware/efi ] && echo "UEFI" || echo "BIOS"
UEFI

Operating System Services — What the OS Provides

Galvin groups OS services into two families: services that help the user, and services that ensure efficient system operation. Both reach programs through system calls and reach humans through interfaces.

Animated Overview — All OS Services Orbiting the Kernel

User & OS Interface — CLI, GUI, Touch, Voice

Every OS exposes at least one interface for humans. Most modern OSes provide several so users can pick the right tool for the task.

Animated Comparison — Same Task, Different Interfaces

System Calls — The Programmer's Doorway to the Kernel

A system call is the programmatic way a user process asks the OS kernel to do something on its behalf. It is the only legal path from user mode to kernel mode — hardware enforces this via a special instruction (syscall on x86-64, svc on ARM64).

Animated Mode Switch — What Really Happens on write()

5.1 API vs System Call — What You Write vs What Actually Happens

5.2 How Parameters Are Passed to a Syscall

The Six Categories of System Calls (Galvin)

Every syscall, regardless of OS, falls into one of six functional groups. Learn these six and any kernel's syscall table becomes readable.

Animated View — Syscall Categories Feeding the Kernel

6.1 Process Control — fork() and exec() in C

// Classic Galvin fork-exec-wait pattern
#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>

int main() {
    pid_t pid = fork();           // SYSCALL — clone the process

    if (pid == 0) {
        printf("Child PID %d\n", getpid());
        execlp("ls", "ls", "-l", NULL);   // SYSCALL — replace child image
    } else {
        int status;
        wait(&status);          // SYSCALL — parent waits
        printf("Child finished with status %d\n", status);
    }
    return 0;
}

6.2 File Management — Reading a File with Raw Syscalls

#include <fcntl.h>
#include <unistd.h>

int main() {
    int  fd = open("/etc/hostname", O_RDONLY);   // SYSCALL 1
    char buf[64];
    int  n  = read(fd, buf, sizeof(buf));         // SYSCALL 2
    write(1, buf, n);                              // SYSCALL 3  (fd 1 = stdout)
    close(fd);                                     // SYSCALL 4
    return 0;
}

6.3 Communication — Pipe Between Parent and Child

#include <stdio.h>
#include <unistd.h>

int main() {
    int fd[2];  pipe(fd);                     // SYSCALL — create pipe
    if (fork() == 0) {
        close(fd[0]);
        write(fd[1], "Hello parent!\n", 14);
    } else {
        char buf[64];
        close(fd[1]);
        int n = read(fd[0], buf, sizeof(buf));
        write(1, buf, n);
    }
    return 0;
}

6.4 Watch Every System Call a Program Makes

# strace shows every syscall + args + return value
$ strace -e trace=openat,read,write,close cat /etc/hostname

openat(AT_FDCWD, "/etc/hostname", O_RDONLY)  = 3
read(3, "mohit-laptop\n", 131072)            = 13
write(1, "mohit-laptop\n", 13)               = 13
close(3)                                     = 0
+++ exited with 0 +++

# Aggregate — how many syscalls of each type
$ strace -c ls / > /dev/null
% time     seconds  usecs/call     calls    errors syscall
------ ----------- ----------- --------- --------- ----------------
 28.14    0.000203           7        27           mmap
 19.35    0.000140           6        22           openat
 12.06    0.000087           4        22           close
  9.98    0.000072           3        21           read
  7.34    0.000053           2        19           fstat
------ ----------- ----------- --------- --------- ----------------
100.00    0.000723                    120         0 total

System Programs — Between the User and the Syscall

Users rarely make syscalls directly. Instead, they use system programs — utilities bundled with the OS that wrap syscalls in friendly commands. Galvin lists eight common categories.

Practical — Trace echo hi All the Way Down

Golden Rules — What to Remember