Operating Systems, VisualizedSchedule. Page. Lock. Crash.

1. What's actually inside a computer?

Forget software for a moment. The physical machine in front of you has three things that matter for our story: a CPU, some RAM, and a disk. Everything an operating system does is ultimately about juggling those three.

A simple way to picture it: the CPU is the brain, RAM is the desk where it spreads out the papers it's currently working on, and the disk is the filing cabinet down the hall. Anything the CPU wants to use, it first pulls onto the desk. That's why opening a big file feels slow — it's being walked over from the cabinet to the desk.

2. Bits, bytes, and how computers count

Every wire inside the CPU is either carrying voltage or it isn't. We call those two states 1 and 0. One such state is a bit — the tiniest possible piece of information.

Bits alone aren't very useful, so we group them. Eight bits make a byte. One byte can hold a number from 0 to 255, or one ASCII character like ‘A’. Almost everything you measure on a computer is a count of bytes:

• 1 KB ≈ 1,000 bytes — a paragraph of text
• 1 MB ≈ 1 million bytes — a phone photo
• 1 GB ≈ 1 billion bytes — a movie
• 1 TB ≈ 1 trillion bytes — your laptop's disk

When someone says your laptop has “16 gigs of RAM,” they mean the CPU's desk can hold roughly 16 billion bytes at once. That's a lot of mailboxes (more on those in section 10).

3. How a CPU actually works

A CPU only knows how to do very small things: add two numbers, compare two numbers, copy a byte from here to there, jump to a different instruction. Each one of those is called an instruction. Your entire program — Chrome, Python, this web page — is just millions of those little instructions strung together.

The CPU runs them one at a time, very quickly. The clock is what keeps the beat. A 3 GHz CPU ticks 3 billion times per second, and roughly one instruction happens per tick. That's how a chip the size of a stamp ends up running an entire video game.

Most CPUs have multiple cores. Each core is a complete little CPU on its own. A “8-core” chip can be running 8 instructions at the same instant — eight different programs, or eight parts of the same program. This is real hardware parallelism, not a trick.

4. Registers — the CPU's pockets

Inside each core there are about 16–32 tiny storage slots called registers. Each one holds one number. That's it — a few dozen numbers total. But they're the fastest memory that exists in the whole computer, because they're wired directly to the part of the CPU doing the math.

When the CPU adds two numbers, it doesn't reach into RAM. It loads both into registers, adds them in a register, then (eventually) writes the result back to RAM. Think of registers as the CPU's pockets: tiny, but right there, no walking required.

5. Why CPUs have caches (L1, L2, L3)

Here's the catch: RAM is dramatically slower than the CPU. The CPU does an instruction in ~0.3 nanoseconds. Reading from RAM takes ~100 nanoseconds. If the CPU had to wait on RAM for every instruction, it would spend 99% of its time doing nothing.

So chip designers slip in caches — small, fast memories that sit between the CPU and RAM. They're arranged in a hierarchy:

Each level is bigger but slower than the one above. The CPU checks the closest one first; if the data isn't there it tries the next level down. The whole point of writing “cache-friendly” code — the kind that walks an array in order — is to keep the data the CPU needs near the top of this stack.

6. Interrupts — how the CPU notices things

Picture this: the CPU is grinding through a million instructions a millisecond. You press a key. How does the CPU even know?

The keyboard chip raises a signal called an interrupt. That signal yanks the CPU's attention: it stops what it's doing, saves where it was, jumps to a small piece of OS code that handles the keypress, and then resumes. The whole detour takes microseconds.

Almost every external thing you can think of arrives as an interrupt: keyboard, mouse, network packet, disk read finished, hardware timer ticking, USB device plugged in. The OS spends a huge chunk of its life servicing interrupts. Without them, the CPU would have to constantly poll every device — exhausting and wasteful.

7. 32-bit vs 64-bit — what those numbers mean

When someone calls a CPU “64-bit,” they mean two things: its registers are 64 bits wide, and it can address up to 2⁶⁴ bytes of memory.

That second part is why we moved from 32-bit to 64-bit. A 32-bit CPU could only address 2³² bytes — about 4 GB. The moment laptops started shipping with more than 4 GB of RAM (around 2005–2008), 32-bit was done. A 64-bit CPU can theoretically address 16 exabytes — 16 billion gigabytes. We'll be fine for a while.

One side effect: 64-bit pointers are twice as big, so 64-bit programs use slightly more memory. The trade-off is worth it because the alternative is being stuck under 4 GB of RAM per process.

8. CPU architecture families

Not all CPUs speak the same language. The set of instructions a CPU understands is called its Instruction Set Architecture (ISA). Code compiled for one ISA generally won't run on another — this is why an iPhone app and a Windows app aren't interchangeable, even when they do the same thing.

There are a handful of others (PowerPC, MIPS, SPARC) but they're mostly historical or niche. For day-to-day work you'll see x86-64 and ARM the most.

9. Intel vs AMD vs Apple Silicon

Inside the x86-64 family, two companies make almost every chip: Intel (Core i5/i7/i9, Xeon) and AMD (Ryzen, EPYC). Their chips speak the same instruction set, so a compiled binary runs on either — you don't recompile your Linux server when you swap an Intel box for an AMD box. They compete on speed, power efficiency, and price; AMD has been particularly aggressive on core counts in the last few years.

Apple Silicon (M1, M2, M3, M4) is different. It's ARM, not x86. When Apple switched their Macs from Intel to their own ARM chips in 2020, every macOS app had to be recompiled — or run through a translator called Rosetta 2. The payoff was huge: the M1 was faster than Intel chips at a fraction of the power, partly because of ARM's simpler instruction set.

That “simpler instruction set” is the famous RISC vs CISC argument. CISC (Complex Instruction Set Computing — like x86) has lots of fancy instructions that do a lot per tick. RISC (Reduced Instruction Set — like ARM, RISC-V) has fewer, simpler instructions and trusts the compiler to combine them. Modern chips on both sides have borrowed from each other so heavily that the line is fuzzier than it used to be — but RISC generally wins on power efficiency, which is why ARM rules phones and is now eating data centers.

10. What memory really is

Picture a long street with billions of identical mailboxes, numbered 0, 1, 2, 3, … and so on. Each mailbox holds exactly one byte. That's RAM.

Each mailbox number is called an address. When your code does x = 42, what really happens is: the compiler picks an address for x, and your CPU writes the byte 42 into that mailbox. Reading it back is the same in reverse — give the CPU an address, get the byte at that mailbox.

Numbers bigger than 255 take more than one byte. A 32-bit integer occupies 4 mailboxes in a row; a 64-bit double occupies 8. The address you read or write from is the address of the first mailbox in the run.

11. How a program uses memory

When your program runs, the OS hands it a chunk of those mailboxes and the program organises them into four named regions:

When you write int x = 10 inside a function, x lives on the stack and disappears the moment the function returns. When you write malloc(1000) in C or new Foo() in Java, the bytes come from the heap and stay until something explicitly frees them (or, in Java/Python, until the garbage collector decides to). Every memory bug you'll ever debug is a confusion between these regions.

12. From program to running code

What happens between “double-click an icon” and “the app is running”? Roughly five steps:

1. 1. The OS finds the executable file on disk.
2. 2. It allocates a chunk of RAM and copies the code section from disk into it.
3. 3. It sets up the four regions from the previous section (code, globals, heap, stack).
4. 4. It records this whole bundle as a new process with a unique ID (the PID).
5. 5. It tells the CPU: “start running instructions at the entry point of this code.”

That's it — that's how every running thing on your computer got there. The terminal command ps on Linux/macOS (or Task Manager on Windows) shows you all the processes currently in step 5.

13. What a process is, really

A process is a running program plus everything that program needs to actually run: its own private memory, its open files, its current state (which instruction it's on), and a unique number called the PID.

Crucially, every process gets its own private memory. Process A and Process B can both have a variable at memory address 0x1000, and they don't interfere — the OS makes sure those two “0x1000”s point to different bytes of physical RAM. (We'll explain how that magic works in section 16.)

If you open Chrome twice, you get two Chrome processes — same program, two independent runtimes, two PIDs. Modern Chrome actually splits itself into many processes (one per tab and extension) for safety: if a malicious page crashes its process, the other tabs keep working.

14. What a thread is, really

Sometimes one process needs to do several things at once. Imagine a video player: it has to decode video, play audio, and respond to your clicks. If those happened one after the other, the UI would freeze every time a frame decoded.

A thread is one stream of execution inside a process. A process can have many threads, all sharing the same memory and files but each running its own code in parallel (or taking turns on the CPU if there are more threads than cores).

Concrete example: when you open this web page, the browser spins up a UI thread that handles your scrolling, a network thread that fetches the page, and a JavaScript thread that runs the page's code. They share the page's data because they're all in the same process. That sharing is what makes threads powerful — and also what makes them dangerous (see the “Race Conditions” section below).

15. Process vs thread — when to use which

The cheat-sheet:

Real-world examples: Chrome chooses processes-per-tab for safety. nginx and Postgres use one process with many threads (or workers) for speed. There's no universally right answer — it's a trade-off between isolation and performance.

16. Why memory needs to be managed

Now back to the problem we hinted at: your laptop has 16 GB of RAM, and right now there are probably 200+ processes running. They can't all just freely use whatever addresses they want. Two problems:

• Conflict: If process A writes to address 0x1000 and process B also writes to address 0x1000, somebody's data gets stomped.
• Security: Without isolation, any program could read your password manager's memory.

The OS solves both with virtual memory. Every process gets its own private “map” of addresses. Process A's address 0x1000 and Process B's address 0x1000 secretly point to different bytes of physical RAM — the CPU translates between them on every access. Each program thinks it has the whole memory to itself; the OS makes the illusion work.

That's the foundation of everything in the “Walk a Virtual Address” section below. The boring details (page tables, the TLB, page faults) are all in service of this one trick.

17. How the OS gets running — the boot process

When you press the power button, none of the OS is loaded yet. So how does it get there? Roughly:

1. 1. The CPU starts running instructions at a hard-coded address that points to a small program built into the motherboard, called BIOS (or, on newer machines, UEFI).
2. 2. That firmware does a self-test, finds the disks, and looks for a bootloader — usually GRUB on Linux, the Windows Boot Manager on Windows, or boot.efi on macOS.
3. 3. The bootloader loads the kernel into RAM and hands control to it.
4. 4. The kernel initialises hardware (CPU caches, RAM, disks, network), mounts the root filesystem, and starts the first user-space process — init or systemd on Linux.
5. 5. That first process spawns everything else — login screens, background services, your desktop. Eventually you see a login prompt.

The whole sequence usually takes 2–10 seconds on a modern laptop. On servers it can be longer because firmware does more hardware checks.

18. Types of operating systems

Not all OSes do the same job. The constraints they're built for shape almost every design choice:

Many of these share roots. Android's kernel is Linux. iOS shares a lot of code with macOS. The differences are mostly in what runs on top of the kernel — the UI, the app model, the security policies.

19. What the OS actually does — the layered picture

Now we can put it all together. Every line of code you ship sits on top of a stack like this. The closer to the bottom, the more privileged — and the more dangerous when it goes wrong.

When you call malloc() from C, you're calling libc, which asks the kernel for memory. The kernel updates page tables. The hardware MMU does the translation. All of that happens for one line of code. That's the cost of the illusion — and the value of it.

20. Mini glossary

All the terms you'll need for the rest of this page, defined once.

Bit

A single 0 or 1. The smallest unit of data.

Byte

A group of 8 bits. The standard chunk of memory. One ASCII character is 1 byte.

CPU

Central Processing Unit. The chip that runs your code, one instruction at a time per core.

Core

A complete CPU inside the chip. A 'quad-core' CPU has 4 of them, running in parallel.

Register

A tiny storage slot inside the CPU itself. The fastest memory there is.

Cache

Small fast memory between the CPU and RAM. Holds recently-used data so the CPU doesn't keep waiting on RAM.

RAM

Random-Access Memory. The 'desk' the CPU works on. Loses everything on power-off.

Address

A number that identifies one byte in memory. Like a house number on a street.

Program

A file on disk containing instructions. Doesn't do anything until you run it.

Process

A running instance of a program. Has its own memory and a unique PID.

Thread

One stream of execution inside a process. Threads in the same process share memory.

Kernel

The privileged core of the OS. Has full access to hardware. Other code asks the kernel for help.

OS

Operating System. The software that runs the hardware and shares it among programs.

ISA

Instruction Set Architecture. The 'language' a CPU understands — x86, ARM, RISC-V are all ISAs.

x86

The Intel/AMD CPU family. Runs most desktops and servers.

ARM

A different CPU family. Runs phones, recent Macs (Apple Silicon), and increasingly servers.