Skip to content

The Story of Mel

Abstract

On May 21, 1983, astronomer Ed Nather posted a short memoir to Usenet about a colleague he had worked beside two decades earlier: Mel Kaye, a programmer at Royal McBee who wrote machine code of such crystalline cunning that Nather, sent to modify one of Mel’s programs, gave up in admiration. Later reformatted by unknown hands into free verse, “The Story of Mel, a Real Programmer” became the single most famous piece of programming folklore ever written, the hacker community’s epic poem, canonized in the Jargon File. And unlike most legends, it checks out: Mel was real, the machines were real, and the tricks he pulled were real.

The Machines

Royal McBee sold two computers built by Librascope. The LGP-30 (1956) was a desk-sized, drum-memory machine, one of the cheapest general-purpose computers of its era, with 4,096 31-bit words on a spinning magnetic drum as its only memory. Its successor, the RPC-4000 (1960), was “a much-improved, bigger, better, faster — drum-memory computer,” as Nather’s story dryly puts it.

Drum memory made programming a temporal art. Instructions were not available instantly, as in random-access memory: the drum had to physically rotate until the desired word passed under the read head. A naive program spent most of its time waiting. “Optimum programming” meant placing each instruction on the drum at exactly the address that would be arriving under the head when the previous instruction finished, every instruction placed by hand, the whole program choreographed to the rotation of the drum.

The Programmer

Mel Kaye worked at Librascope in Glendale, California. The company’s newsletter, the Librazette, pictures him in August 1956 among the first class of LGP-30 programmers and instructors, and credits him with “the bulk of the programming” on the LGP-30’s ACT-1 compiler (1959). His demonstration showpiece was a blackjack program for the LGP-30, the most popular program the company owned, used to woo customers at trade shows.

Nather, who joined Royal McBee around 1960 and later became an astronomy professor at the University of Texas, met Mel when the company asked Mel to port the blackjack program to the RPC-4000. Mel, in the story’s telling, was a purist: he wrote in raw hexadecimal, scorned the assembler as imprecise, refused to let a compiler place his instructions, and “located his code by the drum”, even exploiting the timing of the drum so that loops needed no explicit test, because by the time the data came around, the loop had done its work.

The story’s centerpiece is what Nather found when he examined an apparently infinite loop in Mel’s code that somehow terminated. Mel had wanted no exit test; he considered it inelegant. Instead, he stored the array-processing instruction at the top of addressable memory and let each pass increment its address field until it overflowed: “The carry would add one to the operation code, changing it to the next one” (a jump instruction) and execution continued at address zero. The loop exited by arithmetic side effect, with no test anywhere.

Nather left the program exactly as Mel wrote it:

I didn’t feel comfortable hacking up the code of a Real Programmer.

From Usenet Post to Epic Poem

Nather posted the story in ordinary prose to the newsgroup net.followup on May 21, 1983, during a discussion sparked by the era’s “Real Programmers Don’t Use Pascal” satire. Somewhere in its viral circulation an unknown editor re-broke the lines into free verse, giving the tale the incantatory rhythm by which it is known today. Eric S. Raymond canonized it in the Jargon File, calling Mel the archetype of the Real Programmer, and it has been reprinted, recited, and analyzed ever since, including a full technical reconstruction on an RPC-4000 emulator that confirmed the machine works exactly as the story requires.

For decades some readers assumed Mel himself was invented. He wasn’t. Research efforts (most extensively the Mel’s Loop project) traced the historical Mel Kaye through Librascope’s archives and confirmed the people, machines, and chronology behind the story.

Why the Story Endures

“The Story of Mel” is the hacker culture’s founding myth of craft: a portrait of total intimacy between one mind and one machine, written at the exact moment (1983) when that intimacy was disappearing under compilers, operating systems, and portability. It is nostalgia, and it knows it. Nather doesn’t argue that Mel’s way was right; his employer needed the program changed, and Mel’s masterpiece was unmaintainable by anyone but Mel. The story lets programmers mourn what abstraction cost while enjoying everything it bought. See The Hacker Culture for the wider folklore tradition.

Dead End: Optimum Programming

The entire art the story celebrates (hand-placing instructions around a spinning drum) was obsolete within years of the events it describes.

Why It Died

Magnetic-core and later semiconductor memory delivered any word at equal, constant cost, making instruction placement irrelevant overnight. Compilers and assemblers, which Mel scorned, produced code that mere mortals could modify, and as the rise of high-level languages showed, programmer time was becoming more expensive than machine time. Mel’s optimizations bound a program to one man and one machine; the industry chose programs that outlive both. The pattern repeats throughout computing history: virtuosity loses to maintainability.

📚 Sources