# The Tech Tree

> An interactive history of the technologies that built the web.

## Era I: Survival & Connection (1969 - 1980s)

- [Packet Switching: How the Network Carries Anything](https://techtree.dylandang.dev/posts/era-1-packet-switching/): 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](https://techtree.dylandang.dev/posts/era-1-arpanet/): A crashed login, a nervous grad student, and an unauthorized email — how a Cold War research project accidentally laid the foundation for the internet. [Foundational]
- [The 'Lo' Crash: The Internet's First Bug Report](https://techtree.dylandang.dev/posts/era-1-lo-crash/): 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](https://techtree.dylandang.dev/posts/era-1-rfc-1/): 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](https://techtree.dylandang.dev/posts/era-1-codd-paper/): 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](https://techtree.dylandang.dev/posts/era-1-relational-model/): 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. [Foundational]
- [The JOIN: Relationships Through Values, Not Pointers](https://techtree.dylandang.dev/posts/era-1-the-join/): 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](https://techtree.dylandang.dev/posts/era-1-email-origin/): 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](https://techtree.dylandang.dev/posts/era-1-normal-forms/): 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](https://techtree.dylandang.dev/posts/era-1-tcp-handshake/): 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](https://techtree.dylandang.dev/posts/era-1-tcp-ip/): 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. [Foundational]
- [Diffie-Hellman: The Key Exchange That Made RSA Possible](https://techtree.dylandang.dev/posts/era-1-diffie-hellman/): 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](https://techtree.dylandang.dev/posts/era-1-digital-signatures/): 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](https://techtree.dylandang.dev/posts/era-1-rsa/): Rivest, Shamir, and Adleman solved a problem that seemed impossible — letting strangers communicate securely without sharing a secret first. [Foundational]
- [The RSA Math, Line by Line](https://techtree.dylandang.dev/posts/era-1-rsa-math/): 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](https://techtree.dylandang.dev/posts/era-1-tcp-ip-split/): 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](https://techtree.dylandang.dev/posts/era-1-query-optimizer/): 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](https://techtree.dylandang.dev/posts/era-1-acid/): 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](https://techtree.dylandang.dev/posts/era-1-end-to-end-principle/): 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](https://techtree.dylandang.dev/posts/era-1-tcp-congestion-control/): 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?

## Era II: Document Sharing (1989 - 1994)

- [HTTP: The Protocol That Delivered the Web](https://techtree.dylandang.dev/posts/era-2-http/): Tim Berners-Lee's simple request-response protocol turned the internet into a global hypertext system. [Foundational]
- [CGI: The First Dynamic Web](https://techtree.dylandang.dev/posts/era-2-cgi/): A simple standard let web servers run programs instead of just serving files — turning static pages into interactive applications and opening the door to everything that followed. [Foundational]
- [SSL/TLS: Securing the Web](https://techtree.dylandang.dev/posts/era-2-ssl/): Netscape needed online shopping to work. That meant encrypting HTTP — so two engineers built the protocol that now protects every connection on the internet. [Foundational]
- [The URL: Addressing Everything](https://techtree.dylandang.dev/posts/era-2-url/): Berners-Lee's third invention gave every resource on earth a single, stable name — and turned the web from a collection of documents into a navigable space. [Foundational]

## Era III: Interactivity & E-commerce (1995 - 2000s)

- [JavaScript: 10 Days That Changed the Web](https://techtree.dylandang.dev/posts/era-3-javascript/): Brendan Eich's rush job became the world's most ubiquitous programming language. Here's how. [Foundational]
- [CSS: Separating Style From Structure](https://techtree.dylandang.dev/posts/era-3-css/): Cascading Style Sheets ended the era of font tags and gave designers a real language for visual presentation. [Foundational]
- [Cookies: Giving HTTP a Memory](https://techtree.dylandang.dev/posts/era-3-cookies/): Lou Montulli's small text files solved HTTP's statelessness problem — and accidentally created the infrastructure for login sessions, shopping carts, and the ad-tracking economy. [Foundational]
- [The DOM: Making Web Pages Programmable](https://techtree.dylandang.dev/posts/era-3-dom/): The W3C's Document Object Model turned static HTML into a living tree that JavaScript could read, modify, and rebuild — the API that made the interactive web possible. [Foundational]
- [PageRank: The Algorithm That Organized the Web](https://techtree.dylandang.dev/posts/era-3-pagerank/): Two Stanford grad students asked a simple question — what if a link is a vote? — and built the algorithm that made the web's infinite library searchable. [Foundational]

## Era IV: The Scale Problem (2000s - 2010s)

- [REST: Architecture for the Scalable Web](https://techtree.dylandang.dev/posts/era-4-rest/): Roy Fielding's dissertation formalized the architectural style that would become the standard for web APIs. [Foundational]
- [MapReduce: Thinking in Parallel](https://techtree.dylandang.dev/posts/era-4-mapreduce/): Google's programming model for processing massive datasets across thousands of machines changed how we think about distributed computation. [Foundational]
- [Git: Distributed Version Control for the Angry Finn](https://techtree.dylandang.dev/posts/era-4-git/): Linus Torvalds built Git in two weeks out of frustration, and accidentally created the tool that powers all modern software development. [Foundational]
- [OAuth: Delegating Trust](https://techtree.dylandang.dev/posts/era-4-oauth/): The authorization framework that lets you 'Sign in with Google' solved the password-sharing problem and enabled the platform economy. [Foundational]
- [V8 & Node.js: JavaScript Breaks Free](https://techtree.dylandang.dev/posts/era-4-node/): Google's V8 engine made JavaScript fast. Ryan Dahl's Node.js put it on the server. Together they unified web development and created the npm ecosystem. [Foundational]

## Era V: Trust & Centralization (2008 - Present)

- [Blockchain: Trust Without Trustees](https://techtree.dylandang.dev/posts/era-5-blockchain/): Satoshi Nakamoto's Bitcoin whitepaper introduced a mechanism for consensus without central authority — and sparked a revolution in decentralized systems. [Foundational]
- [TypeScript: JavaScript That Scales](https://techtree.dylandang.dev/posts/era-5-typescript/): Microsoft's typed superset of JavaScript brought static analysis to the most dynamic language on earth. [Foundational]
- [Docker: Ship the Whole Machine](https://techtree.dylandang.dev/posts/era-5-docker/): How containerization solved 'works on my machine' and transformed software delivery forever. [Foundational]
- [The Transformer: Attention Is All You Need](https://techtree.dylandang.dev/posts/era-5-transformer/): A 2017 paper from Google replaced recurrence with self-attention — and created the architecture behind GPT, BERT, and the modern AI revolution. [Foundational]