It was 1969. Humans had just walked on the moon. But back on Earth, the world of computing was fractured.

Every operating system was hand-stitched for one machine, like a suit that only fits one person. Write a program on an IBM mainframe, and it could never run on a DEC minicomputer. Write it on a PDP-7, and it was trapped there forever.

That was about to change. In a quiet lab in New Jersey, two programmers were about to build something small, elegant, and radical. Not a bigger machine. Not a faster processor. An idea — a philosophy that would reshape all of computing.

Bell Telephone Laboratories was the research arm of AT&T, the American telephone monopoly. It operated from 1925 onward, and its output was staggering.

The transistor? Bell Labs, 1947. Information theory — the mathematical foundation of all digital communication? Claude Shannon at Bell Labs, 1948. The laser? Bell Labs. Satellite communications? Bell Labs. Radio astronomy? Bell Labs.

In the late 1960s, a corner of this extraordinary environment — Department 1127, the Computing Techniques Research group led by Doug McIlroy — became the birthplace of Unix. Ken Thompson and Dennis Ritchie were there. So was Brian Kernighan. So was Lorinda Cherry, a mathematician and programmer who developed tools like eqn — software that let scientists typeset mathematical equations directly from a terminal.

But the Bell Labs of the 1960s and 1970s was overwhelmingly white and male. This was not accidental — it reflected structural barriers. Most top CS programs admitted few women and fewer people of color. Bell Labs recruited almost exclusively from these programs. The contributions that did come from people outside that narrow slice — like Cherry's — only make the question of what was lost sharper.

Ken Thompson (born 1943, New Orleans) joined Bell Labs in 1966. He was a quiet, unassuming hacker — the kind of programmer who would think about a problem for days, then write the solution in a single explosive burst of coding.

Dennis Ritchie (1941–2011, Bronxville, New York) joined Bell Labs in 1967 with degrees in physics and applied mathematics from Harvard. Where Thompson was the rapid-fire builder, Ritchie was the deliberate designer — modest, self-effacing, someone who expressed himself more clearly in writing than in speech.

But this initial burst was just the beginning. From 1970 onward, Ritchie was deeply involved. McIlroy contributed the pipe mechanism. Kernighan named it and helped document it. Joe Ossanna built text-processing tools. Lorinda Cherry developed mathematical typesetting. The name "Unix" was coined by Brian Kernighan as a pun on Multics: uniplexed versus multiplexed. Unix was Thompson's spark — but it was Bell Labs' fire.

Think About It: Thompson stripped Multics down to its essentials. Multics tried to do everything; Unix did a few things, simply and well. Have you ever noticed that the most useful tools in your life are often the simplest ones?

Doug McIlroy, the head of the department where Unix was born, had been championing an idea since the early 1960s. In a 1964 memo, he wrote: "We should have some ways of coupling programs like garden hoses — screw in another segment when it becomes necessary to massage data in another way."

In 1973, Thompson implemented it. The pipe — represented by the | symbol — allowed the output of one program to flow directly into the input of another. Before pipes, you had to save intermediate files at every stage. Pipes eliminated the friction and made composing small programs feel natural.

Thompson's B language (1969–70), derived from Martin Richards's BCPL (Cambridge, 1966), worked on the word-addressed PDP-7. But when Unix moved to the byte-addressed PDP-11, B's lack of a type system became a problem. Between 1971 and 1973, Dennis Ritchie transformed B into something new: C — named simply because it came after B.

C occupied a unique position. High-level enough that humans could read it. Low-level enough to replace assembly language. It gave you pointers — direct addresses into memory, like GPS coordinates to specific locations in the machine. Powerful, yes. But dangerous: point to the wrong address and your program crashes, or worse.

Portability did not mean "press a button." Writing a C compiler was hard work — weeks or months of effort. But the savings compounded: every new program written in C could run on every platform with a C compiler. Write once, compile anywhere — if you had a compiler.

A legal quirk accelerated Unix's spread. AT&T was barred from selling software under a 1956 consent decree, so Unix was distributed to universities with source code included. At UC Berkeley, Bill Joy created the Berkeley Software Distribution (BSD), an influential variant that would shape networking, free software, and eventually macOS.

Think About It: C trusts the programmer completely — it will let you do anything, including things that crash the machine. Is it better for a tool to be safe or powerful? What are the tradeoffs?

In January 1975, the MITS Altair 8800 — a kit computer based on the Intel 8080, sold for $439 — had no keyboard, no screen, and was programmed by flipping toggle switches. It was, by any practical measure, nearly useless. It changed everything.

In February 1976, Gates published an angry "Open Letter to Hobbyists," arguing that copying software without paying was theft: "Who can afford to do professional work for nothing?" The hobbyist community was furious — many saw software as something to be freely shared. This letter is often cited as the opening shot in the free vs. commercial software debate.

On August 12, 1981, the IBM PC launched with an open architecture. Microsoft supplied MS-DOS, acquired for around $50,000–$75,000 — and crucially retained the right to sell DOS to other manufacturers. This single licensing decision would make Microsoft one of the most valuable companies on Earth.

The idea began with J.C.R. Licklider, a psychologist and computer scientist at ARPA, who imagined an "Intergalactic Computer Network" where researchers everywhere could share data freely. Larry Roberts designed ARPANET's architecture. Leonard Kleinrock at UCLA developed the theory of packet switching. The team at BBN built the routing machines.

On October 29, 1969, UCLA graduate student Charley Kline tried to send "LOGIN" to Stanford Research Institute, 350 miles away. He typed L. Confirmed. O. Confirmed. G. The system crashed. The first message sent over ARPANET was "LO."

Richard Stallman (born 1953, New York) had been a programmer at MIT's AI Laboratory since 1971. In the AI Lab of the 1970s, software was freely shared. If a program had a bug, anyone could fix it. The code was a commons.

Stallman had modified a Xerox printer's software to notify everyone when a jam occurred. When MIT received a newer printer, he asked for its source code. Xerox refused — the code was now proprietary. "It was my first direct encounter with a nondisclosure agreement," Stallman later said, "and it taught me that nondisclosure agreements have victims."

By the early 1990s, the GNU project had produced essential tools — the GCC compiler, the Emacs editor, the bash shell — but lacked a kernel. That missing piece would arrive in 1991, from a Finnish college student named Linus Torvalds. But that is a story for Issue 5.

In December 1979, Steve Jobs visited PARC. Researcher Larry Tesler demonstrated the Alto. Jobs was electrified: "Why aren't you doing anything with this? This is the greatest thing! This is revolutionary!" Not everyone agreed — Adele Goldberg, a key developer of Smalltalk, objected to giving away PARC's crown jewels. She was overruled by management.

The Apple Macintosh launched January 24, 1984 at $2,495, with the legendary "1984" commercial by Ridley Scott. Apple didn't just copy PARC — they added the menu bar, drag-and-drop, and a simplified single-button mouse. Microsoft followed with Windows 1.0 in November 1985 — clunky and limited. It wasn't until Windows 3.0 (1990) that their GUI succeeded commercially.

Think About It: Every interface is a tradeoff. Command lines are fast and precise for experts. GUIs are intuitive for everyone. Today we are asking the same question again: is talking to an AI assistant the next interface revolution? What will that make possible?

Unix and C had proven that software did not have to be trapped on one machine. The Unix philosophy — small tools, piped together, doing one thing well — had shown that the most powerful systems are built from simple, composable parts. (Hold on to that idea. It will matter again, profoundly, in our final chapters.)

But in 1989, the vast majority of personal computers were still isolated. You could write a document, play a game, run a spreadsheet — but sharing anything with another human being meant copying it to a floppy disk and physically carrying it across the room.

Humans had built brilliant, powerful personal machines. They had built a network that could, in theory, connect them all. But the two revolutions had not yet merged. It would take a physicist at a European research lab, trying to solve a very mundane problem — sharing documents with his colleagues — to connect the final wire.