Berkeley's Unix built the internet's networking stack, invented the tools every admin still uses, and was frozen at its peak by a lawsuit that handed the PC era to Linux. Then it quietly conquered anyway — inside macOS, every PlayStation, and the servers that stream half the internet. This is how.
Computing History
-
The Story of BSD: The Unix That Lost the War and Won the World -
The Story of Ethernet: How a Shared Wire Won the Network Ethernet should have lost. It was a chaotic free-for-all where machines shouted over a shared cable and backed off when they collided, competing against orderly, corporate-backed token schemes that guaranteed fairness. It won anyway. This is the story of how a memo at Xerox PARC, a radio network in Hawaii, and a standards-committee brawl produced the wire in every wall.
-
The Story of SSH: How a Stolen Password Became the Internet's Front Door In 1995 a Finnish researcher's university network was sniffed, thousands of passwords stolen in cleartext off the wire. His weekend fix became SSH, then a company, then a licensing fight, then an OpenBSD fork that now guards essentially every server on earth. This is how remote access got encrypted.
-
The Story of the GNU Project: The Operating System That Refused to Be Owned In 1983 a programmer at MIT decided that the entire commercial software industry had made a moral error, and set out to rebuild a complete operating system from scratch so that no one would ever have to accept it. He almost finished. The story of GNU is the story of the license, the manifesto, and the missing kernel that Linux walked in to fill.
-
The Cray Era and the Death of the Supercomputer For two decades the word "supercomputer" meant one thing: a Cray. Then commodity microprocessors caught up on price/performance, the killer micros arrived, and the custom vector machine died. This is how vector processing worked, why it lost, and what crawled out of the wreckage to become modern HPC.
-
The History of Computer Graphics Computer graphics is the long story of turning an integral nobody can solve in closed form into pixels that ship in 16 milliseconds. From Sketchpad's light pen to Phong's specular highlight, from Kajiya's rendering equation to Pixar's REYES, and from the GeForce 256 to RTX ray-tracing cores, this is how we got from vector scopes to real-time path tracing that still cheats with denoisers.
-
The Internet's Founding RFCs The internet was not specified by a standards body with the force of law. It was built out of numbered memos called Requests for Comments, written deferentially by graduate students and ratified by running code. A tour of RFC 1, 791, 793, and the pigeon joke that explains the whole philosophy.
-
The Lisp Story From a 1958 MIT research note to the metacircular evaluator, the Lisp Machine boom and bust, the Scheme and Common Lisp branches, and the Clojure revival. How a language meant to formalize symbolic reasoning ended up seeding nearly every modern functional idea.
-
The Personal Computer Wars How the Apple II, the IBM PC, and a generation of clones decided the shape of computing for forty years. The architecture was destiny: an open bus, a reverse-engineered BIOS, and a non-exclusive software license handed the future to Microsoft and Intel rather than to IBM.
-
The Story of BlackBerry How a two-way pager from Waterloo became the secure-messaging backbone of enterprise and government, why push email and encrypted PIN messaging made BlackBerry untouchable for a decade, how the iPhone shattered the keyboard, and what Research In Motion actually became.
-
The Story of Chicken Scheme How Felix Winkelmann's idea of compiling Scheme to portable C produced a small, fast, embeddable Lisp that quietly powered Linux scripting and embedded systems. The egg ecosystem, the Cheney-on-the-M.T.A. garbage collector, and the honest lessons of sustaining a niche language.
-
The Story of Gentoo How Daniel Robbins turned a frustration with binary packages into a source-based meta-distribution, gave Linux the USE flag, and accidentally founded an optimization culture that outlived its own benchmarks — and why "compile everything from source" still wins in the corners where it wins.
-
The Story of Java How a language built to run on set-top boxes became the default substrate of enterprise computing, banking, and Android — by betting everything on a portable bytecode and a virtual machine. The arc from Gosling's Green Project through "write once, run anywhere," the Oracle acquisition and the API copyright wars, to the polyglot JVM that outlived Java's own dominance.
-
The Story of MS-DOS and Windows How a $50,000 clone of CP/M rode the IBM PC deal into the most valuable monopoly in software history, fought the 640K barrier for a decade, papered DOS over with a graphical shell, unified consumers and engineers on Windows 95, ran two completely different operating systems in parallel for years, and finally collapsed them into a single NT kernel whose Win32 ABI Microsoft has refused to break for thirty years.
-
The Story of Perl How a linguist's 1987 glue language conquered the early web, the sysadmin's toolbox, and the human genome — then froze its own momentum for fifteen years waiting on a rewrite that became a separate language. The rise, the reign, the Perl 6 schism, and the legacy that still runs in production.
-
The Story of SQL How a 1970 IBM research paper on the relational model produced a declarative query language that outlasted its rivals, survived a decade-long NoSQL insurgency, and quietly absorbed the very systems that tried to replace it.
-
The Story of TeX and LaTeX How a computer scientist's disgust at a bad galley proof in 1977 turned into a decade-long obsession that produced TeX, METAFONT, and literate programming — and why, fifty years and several "modern" competitors later, LaTeX still owns mathematics and physics publishing.
-
The Story of Ubuntu How a South African dot-com millionaire who flew to the ISS forked Debian into "Linux for human beings," mailed free CDs to the planet, lost almost every technical bet he made — Unity, Mir, Upstart, convergence — and still ended up owning the operating system the cloud actually runs on.
-
How Google Was Built The infrastructure decisions that turned a Stanford grad-student crawler into the company that taught the world to build distributed systems: PageRank, GFS, MapReduce, Bigtable, Chubby, Borg, Colossus, Spanner — and why the published papers mattered more than the code.
-
How TCP/IP Actually Won The OSI versus DoD/ARPANET architecture wars, and why the messy four-layer TCP/IP stack beat the rigorous seven-layer OSI model. A look at the 1970s-80s technical and political decisions that shaped every network protocol since.
-
The History of the Web From a 1989 memo a CERN manager called "vague but exciting" to the living standard that runs everything: URIs, HTTP, and HTML; Mosaic and Netscape; the browser wars; the W3C; the XHTML dead end; and the HTML5 rescue.
-
The Story of Linux How a Finnish student's 1991 hobby kernel, posted to a Usenet group with the caveat that it "won't be big and professional like gnu," collided with a free GNU userland, a frozen BSD lawsuit, and the GPL — and became the operating system of the cloud, the supercomputer, and three billion phones.
-
The Story of Python How a Christmas-1989 hobby project descended from a teaching language became the default tongue of scientific computing and machine learning — through a decade-long, self-inflicted version migration, a global interpreter lock it still fights, and a benevolent dictatorship that resigned over a walrus.
-
The Story of C How a small language Dennis Ritchie evolved at Bell Labs to write one operating system on one minicomputer became the portable substrate beneath every kernel, every embedded controller, and the runtime of nearly every other language — and why the bargain that made it fast, undefined behavior, became the defining liability of the 2020s.
-
The Story of Git How a two-week emergency hack, born from a licensing feud over the tool that managed Linux kernel development, became the substrate of nearly all modern software collaboration — through a ruthless design built on content-addressed storage, a directed graph of commits, and a social network that turned the pull request into the unit of work.
-
The Story of Unix How a discarded operating system, salvaged from the wreckage of Multics on a spare PDP-7 at Bell Labs in 1969, became the common ancestor of nearly every computer that matters today — through a fateful rewrite in C, an antitrust decree that gave it away cheap, two decades of lawsuits and fragmentation, and a free kernel that arrived just in time to inherit the world.
-
The Story of Mac OS: From Cooperative Multitasking to Apple Silicon Forty years of the Macintosh operating system, from the memory-protection-free original of 1984, through the Copland death march and the NeXT acquisition that brought Steve Jobs back, to the BSD-and-Mach foundation of Mac OS X and the three processor transitions that ended with Apple Silicon.
-
The Story of Palm: The Smartphone Before the Smartphone How a block of wood in Jeff Hawkins's shirt pocket became the PalmPilot, how Palm built the first computing platform people actually carried everywhere, and how a decade of corporate self-sabotage destroyed a company that had invented the modern smartphone UX years before the iPhone shipped.
-
Bell Labs and the Transistor: The Lab That Built the Modern World How a regulated telephone monopoly funded the most productive industrial lab in history, why the transistor was invented twice in six weeks by people who hated each other, and how an antitrust decree turned New Jersey physics into Silicon Valley.
-
From ARPANET to BGP: Why the Internet Trusts Everyone The internet's routing system still runs on a trust model inherited from a 1969 research project with four nodes. This is the history of that assumption: ARPANET, EGP, the NSFNET handoff, three napkins in Austin, the great hijacks, and the decades-long effort to retrofit authentication onto a running planet.
-
RISC vs CISC: The War That Ended in a Tie The instruction-set war of the 1980s and 90s ended in the strangest way possible: both sides won. How x86 swallowed RISC whole, how ARM grew CISC-grade complexity, and why the ISA matters less than the business model wrapped around it.
-
The Apollo Guidance Computer: 2K of RAM to the Moon The Apollo Guidance Computer flew humans to the Moon with 2,048 words of RAM and software woven into wire by hand. This is the machine, the priority-scheduled executive that survived the famous 1202 alarms, and the engineering discipline it forced into existence.
-
The Capacitor Plague: How Stolen Electrolyte Killed a Decade of Hardware Between 1999 and 2007, millions of motherboards died of the same disease: electrolytic capacitors built on an incomplete stolen formula that brewed hydrogen gas until they burst. The full story — the chemistry, the espionage, Dell's $420 million cleanup, and what it still teaches anyone buying used hardware today.
-
The Morris Worm: The Internet's First Incident Response On November 2, 1988, a graduate student's experiment knocked out roughly a tenth of the internet in a single night. The response was improvised over phone lines and hallway meetings — and nearly everything modern incident response does today was invented in those 72 hours.