1969 - 1980s
Era I: Survival & Connection
Packet Switching: How the Network Carries Anything
Circuit switching wastes bandwidth on silence. Packet switching chops messages into independent pieces and lets the network forget the conversation. That one shift is the reason the internet exists.
ARPANET: The Network That Started It All
A crashed login, a nervous grad student, and an unauthorized email — how a Cold War research project accidentally laid the foundation for the internet.
The 'Lo' Crash: The Internet's First Bug Report
Why SRI's computer crashed after Charley Kline typed three letters, what actually broke, and how a buffer overflow in an auto-complete feature became the internet's origin story.
RFC 1, Annotated: The Document That Invented Internet Governance
Steve Crocker wrote RFC 1 in a bathroom at night because he didn't want to sound bossy. The tentative document he produced became the model for every internet standard that followed.
Codd's 1970 Paper, Annotated
Walking through 'A Relational Model of Data for Large Shared Data Banks' — what 'relational' actually means mathematically, which ideas survived into SQL, and which quietly got dropped.
The Relational Model & SQL: Organizing the World's Data
Edgar Codd's 1970 paper gave us a mathematical foundation for databases, and SQL gave us a language to query them. IBM sat on it. Oracle shipped it first.
The JOIN: Relationships Through Values, Not Pointers
Expressing relationships through shared values instead of physical references was the real breakthrough of the relational model. Fifty years later, the four join types, three join algorithms, and one fundamental question still run most of the world's data.
The @ Sign: How Email Was Smuggled Onto ARPANET
Ray Tomlinson combined two existing programs as an unauthorized side project, picked a punctuation mark nobody used in their name, and accidentally built the network's first killer app.
Normal Forms: 1NF → BCNF, With Examples
Codd's design rules for tables — what each anomaly looks like, how the next normal form fixes it, and when to deliberately break the rules for performance.
The Three-Way Handshake, Packet by Packet
Why TCP needs exactly three packets to open a connection, what the SYN and ACK bits actually do, and why the initial sequence number being predictable became a security disaster.
TCP/IP: The Protocol That Connected Everything
Two engineers in a hotel lobby, one impossible problem: make any network talk to any other network. How Cerf and Kahn's 1974 paper became the foundation of the internet.
Diffie-Hellman: The Key Exchange That Made RSA Possible
Before Rivest, Shamir, and Adleman built the lock, Whitfield Diffie and Martin Hellman proved the lock could exist. Their 1976 paper is where public-key cryptography actually begins.
Digital Signatures: Running Public-Key Crypto in Reverse
You sign with your private key. Anyone verifies with your public key. That one asymmetry underlies software updates, TLS certificates, git commits, and every system that has to trust code without trusting the channel.
RSA Encryption: Secrets in Plain Sight
Rivest, Shamir, and Adleman solved a problem that seemed impossible — letting strangers communicate securely without sharing a secret first.
The RSA Math, Line by Line
Euler's theorem, modular inverses, and why `(m^e)^d ≡ m (mod n)` actually works — a walkthrough of the math the RSA post breezes through in a code block.
Why TCP Was Split Into TCP and IP
The original TCP was one protocol that did routing, reliability, and addressing all at once. Jon Postel's 1978 argument for splitting it in two unlocked UDP, real-time video, the hourglass architecture, and almost everything that came after.
The Query Optimizer: How SQL Actually Runs
You write what you want; the database decides how. A tour of how an optimizer parses, rewrites, estimates, and plans a SQL query — and why the same query can be fast on Monday and slow on Friday.
ACID, One Letter at a Time
How databases actually deliver Atomicity, Consistency, Isolation, and Durability — write-ahead logs, MVCC, locking schedules, and the fsync problem that's embarrassed most storage stacks at least once.
The End-to-End Principle: Why the Internet Is Dumb on Purpose
Saltzer, Reed, and Clark's 1984 paper formalized the design decision that made the internet work — put intelligence at the edges, keep the middle stupid, and watch it outlast every smarter network it competed with.
TCP Congestion Control: Nagle to BBR
Forty years of trying to answer one question — how fast should you send packets when you can't see the network you're sending them through?