Prerequisites

Related

Blueprints · 1,214 words · 5 min read

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.

Table of Contents
  1. TL;DR
  2. The Side Project
  3. Why the @
  4. The First Email
  5. How Fast Did It Eat ARPANET?
  6. What Tomlinson Actually Invented
  7. The Unauthorized Side Project Pattern

#TL;DR

In 1971, Ray Tomlinson at BBN took a local messaging program called SNDMSG and a file-transfer tool called CPYNET, glued them together, and added a way to specify which machine a user was on. He needed a separator that couldn’t appear in any reasonable username, so he looked down at his Teletype Model 33 and picked @. He told his colleague not to tell anyone, because it wasn’t his assigned project. Within two years, email was 75% of all ARPANET traffic. The network funded for remote computation had accidentally become a network for human communication — and the pattern repeats every time a new platform finds its real purpose by accident.

#The Side Project

In 1971, Tomlinson was an engineer at Bolt Beranek and Newman, the Cambridge firm that had built the IMPs for ARPANET. His assigned work was the TENEX operating system for the PDP-10, which ran at a growing number of ARPANET sites.

TENEX already had a program called SNDMSG. It dropped a message into another user’s mailbox file on the same machine — basically, it wrote to a shared file. Every time-sharing OS of the era had something like it. Inter-user messaging on a single machine had existed for almost a decade.

Tomlinson had also been writing a new network program called CPYNET, which transferred files between ARPANET hosts. Nothing exotic — a pre-FTP file copy tool. CPYNET worked. SNDMSG worked. And somewhere in there, Tomlinson had an idea that wasn’t on his task list.

“I decided to see if I could take the file-transfer program and put it inside the message program, so that instead of writing to a local mailbox file, it would write to a remote mailbox file.”

It was, in his own telling, not what he was supposed to be working on.

#Why the @

The technical problem was trivial: modify SNDMSG to accept a destination that could include a remote host, then call CPYNET instead of a local file write. The design problem was addressing. SNDMSG already took usernames. Now it needed to distinguish a user from a machine.

Tomlinson needed a separator. It had to:

  • Be a single character.
  • Never legitimately appear in a username.
  • Never be a shell meta-character on the systems of the day.
  • Actually exist on the terminal keyboards people were using.

The terminal in front of him was a Teletype Model 33 — the workhorse terminal of the ARPANET era, also the thing that locked in 7-bit ASCII. Its keyboard had exactly 64 printable characters. Most of the punctuation was already load-bearing: . was in filenames, , was a common list separator, : and ; were used by the operating system’s command parser, / and \ were path separators, _ and - were routinely used in usernames.

The @ sign, on the other hand, was effectively unused. On Tenex, it had no reserved meaning. On every user account Tomlinson had ever seen, nobody had the audacity to put an at-sign in their name. And it had a nice English reading: user at host.

He chose it.

  tomlinson @ bbn-tenexa
  ───────────  ──────────
     user        host

The whole thing was a one-evening hack. Tomlinson later demonstrated it to his officemate Jerry Burchfiel. His exact line, in multiple retellings:

“Don’t tell anyone. This isn’t what we’re supposed to be working on.”

#The First Email

Tomlinson sent the first network email between two PDP-10s sitting next to each other in the BBN machine room, connected via ARPANET. The two machines were physically about ten feet apart. The packet still had to go out to BBN’s IMP and come back.

He doesn’t remember what was in the message. “Probably something like QWERTYUIOP,” he told interviewers later. There was no ceremony. There was no photograph. There was no log, because this wasn’t a funded project. The first message sent over the first network-wide mail system is, for practical purposes, lost.

By the next year, Tomlinson’s modified SNDMSG was available to other BBN users. Within a few months, Larry Roberts at ARPA — the man running the ARPANET program — wrote a mail-reading program called RD because he had too many messages to handle manually. That program itself is a signal. When the head of the program needs a tool to cope with his own inbox, you have a real product.

#How Fast Did It Eat ARPANET?

The numbers people cite come from a 1973 ARPA study that tried to figure out what the network was actually being used for. Planners had assumed — reasonably, given the funding rationale — that ARPANET would mostly be carrying remote login sessions and file transfers for researchers using distant supercomputers.

The study found email was already about three quarters of all traffic.

This was two years after Tomlinson’s hack. There was no marketing. There was no ARPA memo promoting it. The growth was entirely organic, and it blindsided the people running the network.

The 1973 report recommended ARPA take email seriously. The community was going to use it whether ARPA endorsed it or not.

#What Tomlinson Actually Invented

The technical artifact was small. Tomlinson did not invent:

  • Electronic messaging as a concept — local SNDMSG-like tools predated him by years.
  • File transfer — CPYNET existed already.
  • The standardization of mail as a protocol — that came with RFC 561 (1973) and later, definitively, RFC 821 (1982) when SMTP formalized what mail servers should do.

What he did invent was the addressing convention that would survive every mail system built in the fifty years since:

user@host

Username on the left. Host on the right. Delivery decided by looking at what’s after the @. The whole global mail system — from early UUCP bangs (host!user!user) through modern SMTP with DNS-based MX records — eventually standardized on Tomlinson’s syntax. Even systems that rejected everything else about early ARPANET mail kept the @.

Entire European languages had to borrow new words for this character — Italian “chiocciola” (snail), Dutch “apenstaart” (monkey tail), Polish “małpa” (monkey), German “Klammeraffe” (spider monkey). It wasn’t on most European typewriter keyboards before Tomlinson made it universal. It is now, because of him.

#The Unauthorized Side Project Pattern

The ARPANET post calls this “the accidental killer app.” That framing undersells a repeating pattern in computing:

  • Email on ARPANET was an unauthorized side project.
  • The World Wide Web at CERN was an unauthorized side project — Tim Berners-Lee had to pitch it three times under different names before management let him work on it.
  • Gmail inside Google was a 20-percent project by Paul Buchheit.
  • Slack started as an internal tool at a failing game company.

The pattern is consistent: platforms built for purpose A routinely discover their real use is purpose B, and purpose B is almost always more human and less technical than the builders expected. ARPA built a network for sharing scarce CPU cycles. People turned it into a network for sending mail to their friends as fast as they possibly could.

Tomlinson’s modification was small. The lesson wasn’t. If you build a general-purpose platform and give your users enough rope, the killer app will arrive from a direction your funding memo didn’t predict — probably as somebody’s side project, probably with a reasonable-sounding excuse for why it isn’t on the official schedule.

And if that app needs a separator character: the @ sign is already taken.