Visual course · Computer science

How your computer works.

You write a line of code and things happen — but under that line are layers most engineers never see: the CPU that runs it, the way numbers and text are really stored, how memory faults and gets reclaimed, how an SSD remembers, how data is compressed and encrypted, and why the speed of light sets a floor on speed. This course opens each layer in a short, visual episode — the stuff that makes you dangerous in an interview and calmer at 3am.

10 episodes ~60 min Under the hood Free · no sign-up
Your progress0 / 10 complete

What you'll understand

By the end the machine stops being a black box. You'll know what the CPU actually does with an instruction, why floating-point math rounds, how one encoding holds every language, what a segfault and a garbage collector really are, how flash remembers without power, how lossless compression and public-key crypto work, why latency has a physical floor, and what a container is under the hood. It's the mental model that turns "it just works" into "I know why."

CPUFloating pointUTF-8Virtual memoryGarbage collectionFlash / SSDCompressionPublic-key cryptoLatencyContainers
The curriculum

Ten episodes, in order

01
Episode 1 · The CPU

How Your CPU Runs One Line of Code

Your program is really millions of tiny instructions, and the CPU fetches, decodes and executes them billions of times a second. See what physically happens when a single line of your code runs — the fetch-decode-execute heartbeat under everything.

What you'll learn
  • Fetch → decode → execute
  • Registers, the clock, instructions
  • Why one line is many operations
02
Episode 2 · Floating Point

Why 0.1 + 0.2 ≠ 0.3

Type 0.1 + 0.2 into any language and you get 0.30000000000000004. It's not a bug — computers store numbers in binary with finite bits, and most decimals simply don't have an exact binary form. Once you see why, floating point stops surprising you.

What you'll learn
  • Binary fractions + finite precision
  • Mantissa, exponent, IEEE 754
  • When rounding error bites
03
Episode 3 · UTF-8

One File Format for Every Language

One encoding holds every language on Earth — emoji, Arabic, Chinese — while staying perfectly backward-compatible with plain old ASCII. UTF-8's variable-length trick is one of computing's quiet masterpieces, and it explains a lot of "why is my text garbled" bugs.

What you'll learn
  • Code points vs bytes
  • Variable-length encoding
  • Why ASCII is a subset of UTF-8
04
Episode 4 · Segfaults

What a Segmentation Fault Really Is

A segfault is your program reaching for memory it doesn't own, and the operating system slamming the door before it can do damage. Understand virtual memory — the illusion that every process has the whole machine to itself — and the segfault stops being scary.

What you'll learn
  • Virtual memory + address spaces
  • Pages and protection
  • Why the OS kills the process
05
Episode 5 · Garbage Collection

How Memory Cleans Up After You

Languages that don't make you free memory by hand still have to reclaim it somehow — figuring out what's no longer reachable and cleaning it up, ideally without freezing your program. That's garbage collection, and it's a beautiful trade-off between throughput and pause time.

What you'll learn
  • Reachability + mark-and-sweep
  • Generational collection
  • The pause-time trade-off
06
Episode 6 · Flash Memory

How an SSD Remembers With No Power

How does an SSD keep your data with the power off and no moving parts? Flash memory traps electrons in microscopic cells that hold their charge for years — and wears out a tiny bit with every write, which is why wear-leveling exists.

What you'll learn
  • Floating-gate cells + trapped charge
  • Why writes wear flash out
  • Wear-leveling + why SSDs beat disks
07
Episode 7 · Compression

How ZIP Shrinks a File Without Losing Anything

ZIP makes a file smaller and then restores it byte-for-byte — no data lost. The trick is finding redundancy (repeated patterns, common symbols) and encoding it more efficiently. It's the same core idea from text files to the compression baked into every network protocol.

What you'll learn
  • Redundancy + entropy
  • Dictionary + Huffman coding
  • Lossless vs lossy
08
Episode 8 · Public-Key Crypto

How Two Strangers Share a Secret in the Open

How do two strangers agree on a secret while everyone is listening? Public-key cryptography gives everyone a public key to encrypt with and keeps a private key that alone can decrypt — the math trick that makes HTTPS, signatures and secure messaging possible.

What you'll learn
  • Public vs private keys
  • One-way (trapdoor) functions
  • Where it powers HTTPS + signatures
09
Episode 9 · The Speed of Light

The Speed of Light Is Too Slow for Your Computer

Light is fast, but it is not instant — and across a chip, a data center, or a planet, that finite speed becomes the hard floor on latency that no clever code can beat. It's why memory hierarchies exist and why a round-trip to another continent will always cost you.

What you'll learn
  • Propagation delay + distance
  • Why the latency floor is physical
  • Latency numbers to feel
10
Episode 10 · Containers · Finale

What a Container Really Is (It's Not a VM)

The finale ties the layers together: a container isn't a tiny virtual machine at all — it's a normal process the kernel has fenced off with namespaces and cgroups so it believes it has the whole machine to itself. Once you see that, Docker stops being magic.

What you'll learn
  • Namespaces + cgroups
  • Container vs virtual machine
  • Why containers are cheap and fast

Saw under the hood? Keep going.

The layers you just met power everything above them. Follow a web request through them in the Internet course, or open the database that sits on top of the storage you just learned about.