Bit
Root

Decimal, binary, octal, hex, plus the weirder ones. Why programmers move between bases, and how.

Two symbols. Infinite meaning. Counting, shifting, two's complement, IEEE 754 floats.

The agreement that turns bit patterns into language. 7-bit ASCII, control codes, and the leap to UTF-8.

The physical switches that are the bits. CMOS transistors, NAND universality, adders.

Wire it all together. Fetch-decode-execute, registers and ALUs, pipelines, caches, branch prediction.

Where state lives. RAM vs ROM, stack vs heap, virtual memory, and how Rust, C and GC'd languages manage it.

One CPU, hundreds of programs. Kernel vs user mode, syscalls, processes, threads, schedulers, virtual memory.

What `let x = 42` actually does. Stack vs heap, primitive vs dynamic, alignment, and lifetime, in Rust and C.

A number that means somewhere. Why pointers power every data structure, and the five classic bugs. C raw pointers vs Rust ownership.

Two phases of every program. What gets decided when, why pushing work earlier matters, and how the split shows up in every layer above.

Houses on a numbered street. Contiguous memory, O(1) indexing, cache locality, and the structure underneath every other data structure.

A chain of nodes, each one pointing at the next. The data structure that trades cache locality for cheap inserts, and the one every other pointer-y structure is built from.

A fingerprint for anything. Hash functions, hash maps, collision handling, cryptographic hashes, Merkle trees, and the chain in blockchain.

One word, three scales. A node in a data structure, a node on a network, a node in a blockchain. The same essential pattern, applied from bytes to billion-dollar systems.

Where one machine becomes many. IP addresses, packets, TCP/IP, routing, sockets, and why every previous topic shows up the moment two computers talk.

No single machine knows everything. Many computers, no central authority, eventual agreement. CAP theorem, gossip, Byzantine fault tolerance, and why this is the page right before blockchain.

You can only guarantee two. Consistency, availability, partition tolerance: pick any two. The silent tradeoff every database, app, and blockchain quietly made without telling you.

CAP told you what breaks. PACELC tells you what you choose every second. Latency vs consistency on every request, even when the network is perfectly healthy.

The capstone. From one transistor in 1947 to a financial network nobody owns. How every previous topic stacks into Bitcoin, end to end, with nothing missing.

A function that calls itself, until it doesn't. The most elegant idea in programming and the fastest way to crash a server. The base case is survival.

Same answer, 317 years apart. Big O is not about speed, it is about how code scales. The lens that makes the whole curriculum coherent, from arrays to Bitcoin's security.