Scrapy
Bytes

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.

Before you can find anything you have to sort everything. Bubble sort, merge sort, quicksort, and what your language actually uses in production.

Find it fast, or wait forever. Linear vs binary search, the overflow bug, interpolation and exponential search, and why Bitcoin uses hashing and sorting together.

Two rules each, everything else follows. LIFO and FIFO, the call stack you already use, ring-buffer queues, priority queues, and the Bitcoin mempool as a max-heap.

A linked list that branches. Binary search trees, balance, traversals, and the three trees running inside every Bitcoin block: Merkle, B-tree, and the recursive call tree.

Everything is connected, not everything is a tree. Nodes, edges, BFS, DFS, Dijkstra, and the graph algorithms routing your packets, your payments, and every Bitcoin transaction.

Series 2 begins. Two strangers, no shared secret, private communication anyway. Symmetric and public key crypto, hashing, signatures, Diffie-Hellman, and the maths that makes Bitcoin secure.

One key creates it, only one key opens it. Key pairs, elliptic curves, secp256k1, scalar multiplication, ECDH, HD wallets, and the Bitcoin address types built on all of it.

Why Scrapy. The mindset behind learning computing from the root up.