Vault · 984 words · 4 min read

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.

#TL;DR

In 1969, the US military’s research agency (ARPA) funded a four-node network connecting universities. It used packet switching — chopping messages into small pieces routed independently — instead of dedicated phone lines. A grad student accidentally created the internet’s standards process (RFCs) because he was too nervous to write anything authoritative. Email, the network’s killer app, was never in the plan. ARPANET proved decentralized networks work, but its protocol couldn’t connect different networks — that problem led to TCP/IP.

#”Lo”

On October 29, 1969, a grad student named Charley Kline at the University of California, Los Angeles tried to log into a computer at Stanford, 350 miles away. He typed L, O, G — and the system crashed. The first message ever sent across ARPANET was “Lo”. The internet’s origin story is a bug report.

An hour later he tried again, and the full LOGIN went through. But nobody remembers the success. They remember the crash.

#From Sputnik to the “Intergalactic Computer Network”

It started with panic. In 1957, the Soviet Union launched Sputnik — a beeping aluminum sphere that proved they could put objects in orbit. The US responded by creating ARPA, a defense research agency with money, urgency, and almost no bureaucracy.

ARPA hired J.C.R. Licklider, who in 1962 wrote memos describing an “Intergalactic Computer Network” — that was the actual name — where every research computer in the country could share data as if distance didn’t exist. In 1962, computers couldn’t even talk to the printer down the hall. His vision sounded like science fiction.

The practical push came from Bob Taylor. By 1966, he had three terminals in his Pentagon office, one for each remote computer. Three systems, three sets of commands. He walked into his boss’s office and asked: why not one terminal that connects to all of them? He walked out with a million dollars to build that network.

#Packet Switching

The telephone network used circuit switching — a dedicated wire between two callers, held open even during silences. Wasteful, fragile, and way too expensive for computers that send data in short bursts.

Paul Baran at the RAND Corporation and Donald Davies at the UK’s National Physical Laboratory independently arrived at the same idea: chop messages into small packets, send each one independently, reassemble at the destination. Davies gave it the name that stuck — packet switching.

import random

def packetize(message, size=5):
    return [{"seq": i, "data": message[i*size:(i+1)*size]}
            for i in range(-(-len(message) // size))]

def reassemble(packets):
    return "".join(p["data"] for p in sorted(packets, key=lambda p: p["seq"]))

packets = packetize("Hello from UCLA to SRI")
random.shuffle(packets)  # packets take different routes
print(reassemble(packets))  # → "Hello from UCLA to SRI"

The key insight: the network doesn’t need to understand your message. It just moves packets from A to B. This makes it resilient (no single point of failure), efficient (no wasted bandwidth), and future-proof (it doesn’t care if you’re sending text, images, or things not yet invented).

#The IMP: A 900-Pound Router

ARPA needed hardware to make this work. IBM passed. AT&T passed. A small Cambridge consulting firm called Bolt Beranek and Newman (BBN) took the job with a team of about twelve engineers.

They built the Interface Message Processor (IMP) — a 900-pound Honeywell minicomputer, tall as a refrigerator. The IMP was the ancestor of every router in your house. Each university connected its computer to an IMP, and the IMPs handled all the networking. The host machines didn’t need to know anything about the network itself.

    ┌──────┐              ┌──────────┐
    │ UCLA ├──┐      ┌────┤ Stanford │
    └──────┘  │      │    └──────────┘
         ┌────┴──┐ ┌─┴─────┐
         │ IMP 1 ├─┤ IMP 2 │
         └───┬───┘ └─┬─────┘
         ┌───┴───┐ ┌─┴─────┐
         │ IMP 3 ├─┤ IMP 4 │
         └───┬───┘ └─┬─────┘
    ┌────────┴┐  ┌───┴──┐
    │ UC Santa│  │ Utah │
    │ Barbara │  │      │
    └─────────┘  └──────┘
    The 4-node ARPANET (December 1969)

This separation — the network vs. the computers on the network — meant any machine could join regardless of its operating system or architecture. The first IMP arrived at UCLA on September 1, 1969. By December, all four nodes were live.

#RFC 1: Accidental Governance

There was no official team to design how host computers would talk through the network. Instead, grad students from the four universities met informally. One of them, Steve Crocker, a 24-year-old at UCLA, wrote up their first ideas on April 7, 1969.

He was terrified of overstepping — he wasn’t a professor, he had no authority. So he wrote it in a bathroom at night, used modest language, and titled it “Request for Comments” — not a spec, just an invitation to discuss.

That instinct created the RFC process, which has governed internet standards ever since. The rules for how web pages are fetched, how email is delivered, how data travels across networks — every major internet protocol was defined through the process a nervous grad student invented because he didn’t want to sound bossy.

Through this process, the group built ARPANET’s first host-to-host protocol: the Network Control Protocol. It worked — but it assumed the network would never lose a packet. On four nodes, that was fine. At global scale, it’d be a disaster. That flaw would drive the creation of its successor, TCP/IP.

#The Accidental Killer App

By 1971, ARPANET had 15 nodes. But its most important feature wasn’t planned.

Ray Tomlinson at BBN combined a local messaging program with a file transfer tool. He needed a way to address a user on a specific machine, so he picked a symbol that wouldn’t appear in anyone’s name: @.

He told his colleague: “Don’t tell anyone. This isn’t what we’re supposed to be working on.”

Within two years, email was 75% of all ARPANET traffic. The network built for sharing computing power became a network for human communication. This pattern — users discovering a platform’s real purpose — would repeat throughout internet history.

#What ARPANET Got Right (and Wrong)

ARPANET was decommissioned in 1990, but its ideas live on:

  • Decentralization — no master node, no central controller
  • Packet switching — every byte you’ve ever sent confirms Baran and Davies were right
  • Open collaboration — the RFC process became the most successful standards body in tech
  • Platform over product — the killer app was built by someone doing unauthorized side work

But it also exposed limits. The Network Control Protocol couldn’t route between different networks. There was zero security — everyone was trusted. And only ARPA-chosen institutions could connect.

The next challenge: make any network talk to any other network. That’s where TCP/IP comes in.