DSKY — Volume 3 — The MIT Instrumentation Laboratory

About This Volume

A machine is only as good as the place that imagines it. Before there was an Apollo Guidance Computer — before the rope memory, the integrated circuits, the green glow of the DSKY in a darkened cabin — there was a laboratory: a brick-and-fluorescent enterprise on the edge of the MIT campus where, for three decades, a stubborn professor had been perfecting the art of knowing exactly where you are without looking out the window. This volume is a portrait of that place and the people inside it. It asks why NASA, in 1961, handed the single most safety-critical piece of the Moon program not to a famous computer company but to a university gyroscope shop — and what kind of culture rose to meet a national crash program it had not asked for.

The technical gambles that flowed out of this lab — the integrated-circuit bet (Volume 4), the woven rope memory (Volume 5), the asynchronous flight software (Volumes 10–11) — each get their own volume. Here we meet the cast and the institution. We will find a place that was older, prouder, and far stranger than “NASA contractor” suggests, and a staff so young that the average engineer building the computer that landed Armstrong and Aldrin was barely out of school.

Doc Draper’s Laboratory

The story begins with one man’s refusal to take anyone’s word for which way was up. Charles Stark Draper — “Doc” to everyone who worked for him — was born in Windsor, Missouri, in 1901, and arrived at MIT to stay. He collected degrees the way other men collect grudges, eventually holding a bachelor’s in psychology, a master’s, and a doctorate in physics, and he turned a 1932 teaching effort into what became known as the Instrumentation Laboratory. From the start the Lab had a single obsession: instruments that could measure a vehicle’s motion precisely enough to navigate by, using nothing but what was bolted inside the vehicle itself.

That obsession has a name: inertial guidance. The idea is almost philosophically pure. A gyroscope, spun up and held in gimbals, resists being turned and so preserves a fixed orientation in space; an accelerometer measures the push of motion. Integrate acceleration once and you get velocity; integrate again and you get position. Give a vehicle a good enough gyro-stabilized platform and good enough accelerometers, and it can know its own velocity and position from the moment it leaves the ground — in a sealed submarine, in a missile screaming through the upper atmosphere, in a spacecraft a quarter-million miles from any landmark — with no radio, no stars, no help from the outside. Draper did not invent the gyroscope, but he made inertial navigation practical, dragging it from a theoretical curiosity to flight hardware, and the title that stuck to him for the rest of his life was “the father of inertial navigation.”

He proved it the way engineers respect most: by betting his own body. Draper’s gunsights and bombsights, gyro-stabilized so they led a moving target automatically, went to sea on Navy ships in the Second World War and demonstrably improved anti-aircraft fire. In the 1950s, to silence skeptics who insisted a self-contained inertial system could not really navigate a transcontinental flight, he flew one. A system called SPIRE guided a B-29 from Massachusetts to Los Angeles in 1953 with the equipment doing the navigating and Draper aboard — coast to coast, no radio fixes, no looking out the window. To a man like Doc Draper, an argument you could not put on an airplane was not an argument at all.

The Polaris Pedigree

A university lab full of gyroscope theory is one thing. A vendor that can deliver compact, rugged, reliable guidance hardware on a deadline, for a program where failure is unthinkable, is something rarer — and it was exactly this second reputation that won the Lab the Apollo contract. The Lab earned it on Polaris.

In the late 1950s the U.S. Navy set out to do something audacious: put nuclear ballistic missiles aboard submarines, so that a hidden, mobile, submerged fleet could deter or retaliate after any first strike. The guidance problem was brutal. A submarine does not sit on a known, surveyed launch pad; it wanders the ocean, and its own position is uncertain. The missile had to be guided by a fully self-contained inertial system, small enough to fit inside the missile, rugged enough to survive an underwater launch and the slam of acceleration, and reliable enough to be trusted with the nation’s deterrent. The Instrumentation Laboratory designed the guidance for Polaris — and it worked.

Polaris mattered to Apollo for reasons that went deeper than prestige. It built an organization, not just a design. It taught the Lab how to take a laboratory prototype and shepherd it through a manufacturing contractor into qualified, deployable hardware. It forged relationships with industry and a working knowledge of military-grade quality discipline. And it put particular people in particular jobs. Ralph Ragan, who had directed the Polaris guidance and navigation program at the Lab, became one of the senior figures steering Apollo; in the program’s earliest days he and the Lab’s Milton Trageser sat down with NASA officials and walked them through what Polaris had proven about building a guidance and navigation system from concept to flight. When NASA looked for someone to guarantee that a spacecraft could find the Moon and come home, the Lab could answer not with a promise but with a track record sitting in submarines under the Atlantic.

There was even a direct technical thread. The Apollo computer’s hardware lineage ran back through the Lab’s Polaris-era digital work; the man who would lead the AGC hardware effort had cut his teeth on the guidance computer for the missile. The Moon program did not begin from a blank page. It began from a submarine.

The Contract Nobody Else Got

On August 10, 1961, the MIT Instrumentation Laboratory signed a letter contract to build the guidance and navigation system for Apollo. It was the first major contract of the entire Apollo program — awarded roughly ten weeks after President Kennedy stood before Congress and committed the nation to a man on the Moon before the decade was out, and months before the spacecraft contractors for the Command Module or the yet-undreamed Lunar Module were chosen. NASA decided who would tell the astronauts where they were before it decided what they would ride in.

It is worth pausing on how unusual that was. The most software- and electronics-intensive subsystem of the program, the one with the least margin for error, went sole-source to a university lab. There was no competition. NASA’s leadership simply judged — on the strength of Polaris and Draper’s reputation — that the Lab was the safest pair of hands in the country, and that the schedule could not afford a procurement contest. The agency’s own history records the easy confidence of the moment: with the Lab signed, officials assumed the hardest part of the navigation problem was in good hands.

What the Lab actually delivered was a division of labor that defined the program. MIT did the design — the architecture, the logic, the software, the system engineering. Manufacture went to industry: Raytheon built the Apollo Guidance Computer itself, and AC Spark Plug the inertial hardware. The finished AGC was a marvel of compression — roughly 70 pounds, drawing about 55 watts, clocked at 2.048 MHz, with a 16-bit word (15 data bits plus one of parity). It was, in the most literal sense, a Cambridge design built in Massachusetts factories and flown to the Moon.

The Cast

If you imagine the people behind a Moon computer as silver-haired sages, the reality at the Instrumentation Lab would surprise you. The senior figures were seasoned; the bulk of the staff who actually wrote the code and drew the logic were astonishingly young — engineers and programmers in their twenties, many fresh from school, learning a discipline that did not yet have a name as they invented it. At its peak roughly 1,700 people at the Lab worked on Apollo. A handful of them shaped everything.

Eldon Hall — the hardware and the gamble

Eldon Hall led the hardware design of the AGC, and his name belongs to one decision above all: he bet the computer on the integrated circuit. In 1959, visiting a Texas Instruments line that was making transistors for Polaris, Hall met Jack Kilby and learned of Kilby’s new invention — several components fabricated together on a single sliver of silicon. The IC was barely out of the lab, untrusted, unproven, made by no one in volume. Hall grasped that building the AGC’s logic from these chips instead of discrete transistors would slash its weight and size and — counterintuitively, given the novelty — improve its reliability, because there were far fewer hand-soldered interconnections to fail. Convincing NASA’s safety reviewers to stake astronauts’ lives on a technology that had never flown anything was its own campaign. He won it. That gamble, and what it did to the electronics industry, is the subject of Volume 4.

Hal Laning — the executive and the interpreter

J. Halcombe “Hal” Laning Jr. was, by the quiet testimony of his colleagues, the genius in the room. A 1947 MIT PhD, he had earlier written one of the first algebraic compilers; for Apollo he designed the computer’s beating heart: the Executive and Waitlist — a real-time operating system, built from nothing, with no prior example to copy. Laning’s scheme was priority-driven and preemptive: every job carried a priority, a high-priority task could interrupt a low-priority one, and the interrupted job could later resume exactly where it had stopped. He also wrote the Interpreter, a software layer that let programmers express the elaborate vector and matrix mathematics of spaceflight in compact pseudo-instructions the tiny machine could store, trading speed for desperately scarce memory.

This was not academic elegance for its own sake. It is precisely why Apollo 11 landed. As Eagle descended, a misconfigured rendezvous radar flooded the computer with work it had no time for, and the famous 1201 and 1202 program alarms lit the cabin. Because Laning’s executive could recognize that it was overloaded, shed the low-priority jobs, and keep the guidance running, the computer never crashed — it triaged and flew on. The architecture he designed in the mid-1960s, colleagues later said, still represents the state of the art for real-time spacecraft computers.

Dick Battin — the navigation

Richard “Dick” Battin led the mission software and the navigation and guidance analysis — the mathematics of actually getting to the Moon and back. Working closely with Laning, Battin and his group turned the brutal celestial-mechanics problem of an Earth-Moon trajectory into algorithms a 70-pound computer could execute: how to take a star sighting and refine your position, how to aim an engine burn, how to thread a return corridor into Earth’s atmosphere. He became as much an educator as an engineer, and the analytic foundations he laid for Apollo’s guidance became a textbook discipline of astronautical navigation.

Ramon Alonso, Albert Hopkins, Hugh Blair-Smith — the architecture

The shape of the machine itself — its instruction set, its logical bones — came from a small architecture group. Ramon Alonso, Albert Hopkins, and Hugh Blair-Smith, building on early work with Laning and Battin, designed the spare instruction set (an early version had a mere handful of base instructions) that became the baseline for the AGC. Blair-Smith’s contribution ran for the life of the program: he wrote and endlessly revised YUL, the assembler that translated the engineers’ code into the bits woven into rope memory, doubling as a version-control and manufacturing aid before such tools had names. Alonso, for his part, was a champion of the woven-wire core rope that stored the programs — the subject of Volume 5.

Margaret Hamilton — the flight software

Margaret Hamilton was hired onto Apollo as a young programmer — by some accounts the first programmer brought onto the project at the Lab — and rose to lead the on-board flight software effort, eventually directing the Software Engineering Division. She is the person most responsible for the philosophy that the software should never simply give up: it should detect when it was being asked to do more than it could, discard the least important work, and protect the mission rather than freeze or corrupt itself. That philosophy is exactly what carried Eagle through the 1202 alarms to the surface. Hamilton also did something subtler and more lasting — she insisted that writing software for machines on which lives depended was a rigorous engineering discipline, and she championed the very phrase, “software engineering,” to demand for it the seriousness then reserved for hardware. Volumes 10 and 11 take up that software in full.

Don Eyles — the landing

Among the youngest of the storied names, Don Eyles joined the Lab in the mid-1960s and was handed a piece of work most senior engineers would have feared: much of the LUNAR LANDING software, the LUMINARY code that flew the Lunar Module’s powered descent. He was in his twenties when his routines guided the first humans to a touchdown on another world, and he later made one of the great offhand remarks of the program — that the computer had turned out smarter than its makers. Eyles would go on to write the software patch that rescued Apollo 14’s landing after a faulty abort switch threatened to wave the mission off the Moon.

The Culture

Drop a sober academic gyroscope laboratory into a presidential crash program with an immovable deadline, and something has to give. What gave at the Instrumentation Lab was the comfortable rhythm of university research. The Lab was, in its bones, a place of careful, instrument-maker rigor — Draper had built a culture that measured things to absurd precision and trusted nothing it had not verified. Now that culture had to ship hardware and software against a calendar set by a dead president’s promise and a Cold War clock.

The strain told in several directions. There was the famous youth of the staff — a workforce green enough that nobody had built a man-rated flight computer before, because nobody anywhere had, and old hands and twenty-five-year-olds were inventing the rules together. There were the inevitable frictions with NASA, which had to manage a sole-source university contractor and which leaned on the Lab repeatedly to stop adding and start freezing the software, as features and memory demands threatened the schedule. There was the awkward seam between a design house and its manufacturers — Raytheon and AC Spark Plug had to build to MIT’s drawings while MIT kept revising them. And underneath ran a productive tension between elegance and pragmatism: Laning’s interpreter and Hamilton’s defensive software were beautiful ideas, but every byte had to be justified to a machine with almost no memory and astronauts’ lives riding on every line.

Yet the rigor mostly held. The Lab’s verification discipline — exhaustive simulation, line-by-line review, the conviction that you tested until you could not find another fault — was its inheritance from the gunsight-and-gyro tradition, and it is why a computer designed by people who had never flown one worked the first time it mattered. The culture that could put Doc Draper on a B-29 to prove a point was the same culture that could put a 70-pound computer on the Moon and trust it.

After the Moon: Draper Laboratory

The Lab’s triumph arrived in the middle of its hardest years — not technically, but politically. By the late 1960s the Vietnam War had turned campuses against military research, and the Instrumentation Laboratory, with its deep Defense Department work on missile guidance, became a target of protest at MIT. The collision was sharp enough that Draper himself stepped back from the directorship around 1970, and in that year the Lab was renamed in his honor: the Charles Stark Draper Laboratory.

The renaming did not settle the matter. Under pressure to divest itself of classified military work, MIT announced that it would separate the Draper Laboratory from the university, and in 1973 the Lab formally spun off to become an independent, nonprofit research corporation — the Charles Stark Draper Laboratory, Inc., still in Cambridge, still doing guidance, navigation, and control, but no longer a division of MIT. It was, in a sense, the academy and the crash program finally parting ways: the discipline born in a teaching laboratory had grown too large, too entangled with national defense, to remain a professor’s shop.

Draper Laboratory endures today, and its DNA is everywhere inertial guidance is trusted with lives. But its single most famous artifact remains the small gray computer it designed for Apollo — and the gamble at the center of that computer, the decision to fly the brand-new integrated circuit, is where we turn next.

Next — Volume 4: The Integrated-Circuit Gamble.