Free through lesson 3

How Computers Work for Beginners

From strings of bits to arm64 assembly, caches, paging, fork and exec, threads and locking, file descriptors and buffering. Over 30 lessons you'll get to the point where you can measure things yourself and track down why a program is slow, crashes, or gets the numbers wrong. Every address, timing, and line of assembly shown comes from output we actually ran.

Start from lesson 1 Unlock every course

Curriculum

The 30 lessons are split into 6 chapters. We recommend going in order from chapter 1, but feel free to jump to whatever interests you. * C, assembly, and shell commands can't run in the browser, so try them in your own terminal. The output shown was measured on an Apple M1 Max (arm64) with macOS and clang 21. The assembly is arm64; x86-64 uses different instruction names, but the ideas are the same. The lessons on bit operations and floating point also include Python you can run right in the browser.

Chapter 1 — Numbers and Representation (lessons 1–4)

See how strings of 0s and 1s become integers, decimals, and text by looking at actual bytes in memory. Endianness, overflow, floating point, and UTF-8, all checked against output from a real machine.

1

Bits and Bytes (Looking at the Layout in Memory)

The same number can be laid out in memory with its bytes in different orders. Read little-endian straight from memory and measure the sizes of types.

Free
2

Integers Overflow and Wrap Around (Two's Complement and Overflow)

The box has a fixed size, so if you keep adding, you wrap around. Trigger signed vs. unsigned overflow for real and catch it with a sanitizer.

Free
3

Floating Point Can Only Hold Approximate Values

Open up the bits of 0.1 and trace, down to the last bit, why 0.1 + 0.2 isn't 0.3. And why you must never store money in a float.

Free
4

Character Encodings (Opening Up UTF-8 Bytes)

Character count and byte count are different things. Use real bytes to check the shape of a UTF-8 lead byte and why cutting in the middle breaks text.

🔒 Basic

Chapter 2 — CPU (lessons 5–10)

Use clang -S to pull out the instructions your C code turns into, and read them. Registers, branches, function calls, optimization, branch prediction, and system calls, all on real arm64.

5

What the Compiler Produces (Reading arm64 Assembly)

Use clang -S to see what instructions a C function really becomes. Addition boils down to just three things: registers, loads, and stores.

🔒 Basic
6

What Conditionals and Loops Really Are

In assembly, both if and for break down into two instructions: compare and jump. Read how the flags left by cmp relate to b.cond.

🔒 Basic
7

Function Calls and Stack Frames

bl leaves the return address in lr, and the callee saves it on the stack. Functions can call each other in nested fashion because the stack is last in, first out.

🔒 Basic
8

What Optimization Turns Your Code Into

Compare -O0 and -O2 side by side. A loop turns into a closed-form expression and a branch disappears. Why you can't claim "writing it this way is faster" without measuring.

🔒 Basic
9

Pipelines and Branch Prediction (9x Slower When Wrong)

Same code, same number of iterations, yet just sorting the array first makes it 9x faster. Measure what gets thrown away when a prediction misses.

🔒 Basic
10

A System Call Is Not Just a Function Call

The svc instruction enters the kernel. Measure that it costs 379x a function call, and see proof in the disassembly that libc caches getpid.

🔒 Basic

Chapter 3 — Memory (lessons 11–16)

Print addresses to draw a map of code, heap, and stack. Measure how caching and paging pay off, and finish by reading a file as memory with mmap.

11

Drawing a Map of the Address Space

Use real addresses to see roughly where code, strings, globals, the heap, and the stack live. And why do they change every run?

🔒 Basic
12

Stack and Heap (Different Lifetimes)

Some memory disappears on its own, and some stays until you give it back. Spot the bug of returning a local variable's address from the digits of the address.

🔒 Basic
13

What malloc Borrows from the OS

Why malloc(1) returns 16 bytes, and how free doesn't give memory back to the OS. Use vmmap to see "100MB reserved, only 16KB used."

🔒 Basic
14

Caches (Access Order Alone Makes an 8x Difference)

Same elements, same number of additions, yet going along rows vs. columns is 8x different. Vary the stride and pin down the cache line size by measurement.

🔒 Basic
15

Virtual Memory and Paging (Counting Page Faults)

Allocating 64MB doesn't use up physical memory. Touch one byte on every page and count exactly one fault per page.

🔒 Basic
16

Reading Files as Memory with mmap

Count a file without calling read or fread. How only the pages you need get brought in, and when mmap is a poor fit.

🔒 Basic

Chapter 4 — Processes and Threads (lessons 17–22)

Run code to watch fork split one process into two and exec replace its contents. Measure what switching costs, cause a real race condition, and compare the cost of the ways to prevent it.

17

fork (Two Processes Come Out of One Line)

One call, two return values. Run it and watch the same variable change independently in the parent and the child.

🔒 Basic
18

exec (Replacing Yourself with Another Program)

exec never returns. The classic Unix fork + exec + wait pattern, and a measurement of what it costs to start one process.

🔒 Basic
19

Context Switches (Measuring the Cost of Switching)

Make 20,000 round trips over a pipe and work out the cost of a single switch. The voluntary/involuntary counts from getrusage match the number exactly.

🔒 Basic
20

Threads (What's Shared and What's Separate)

Several flows of execution inside the same process. Globals are shared, stacks are separate. Print addresses to see where the boundary is.

🔒 Basic
21

Race Conditions (800,000 Becomes 200,000)

counter++ is three instructions. Add 2 million times across 4 threads and 74% vanishes. Plus the trap where optimization makes it look "correct."

🔒 Basic
22

Mutual Exclusion (The Cost of mutex and atomic)

Measure no protection, a mutex, and atomics under the same conditions. Confirm in numbers that correctness costs tens of times more.

🔒 Basic

Chapter 5 — Files and I/O (lessons 23–27)

Start from the fact that a file descriptor is just a number, then measure the 25x difference buffering makes. Finish by building a shell pipeline yourself with dup2 and waiting on several things from a single thread.

23

A File Descriptor Is Just a Number

Why 0, 1, and 2 are fixed. Opening the same file twice gives different numbers, while dup shares even the file position.

🔒 Basic
24

Buffering (200,000 writes or a few thousand?)

A 25x difference writing the same 6.6MB. Why mixing printf and write reorders output, and how to fix it.

🔒 Basic
25

Pipes and Redirection (Building a Shell Yourself)

Rewire standard input and output with dup2 and build the equivalent of seq 1 100000 | wc -l in C. Including why it never ends if you forget to close something.

🔒 Basic
26

Signals (Asynchronous Interruptions)

They arrive regardless of where you're currently executing. Why you must not call printf in a handler, and the two signals you can't catch.

🔒 Basic
27

I/O Multiplexing (Waiting on Many Things from One Thread)

Wait on two pipes at once with kqueue. How you wake up in the order things become ready, and how it maps to epoll on Linux.

🔒 Basic

Chapter 6 — Wrapping Up (lessons 28–30)

See what the kernel protects by being the one it stops. Sort out what containers actually separate, and finally connect all 30 lessons into a single thread.

28

Privilege Boundaries (What the Kernel Protects)

Write to a page made read-only with mprotect and get stopped. NULL dereferences crashing and processes not corrupting each other are the same mechanism.

🔒 Basic
29

What Containers Actually Separate

The difference from virtual machines is whether the kernel is shared. Sort out what Linux namespaces and cgroups do, and try something similar on macOS.

🔒 Basic
30

From Typing ./hello to the End

Tie everything from the 30 lessons into one thread. Follow, step by step, which lesson comes into play where, from the shell's fork until the exit status comes back.

🔒 Basic

To put these ideas to work in code, continue with C Intro Course. To work with servers from the command line, try Linux for Beginners. For a broad grounding in the terminology as a base for certification exams, see IT Fundamentals for Beginners. A membership unlocks every course.