It took 410,000 people to put Apollo 11 on the Moon, but to the general public there are but three visible heroes: Neil Armstrong, Buzz Aldrin, and Michael Collins. There was however, one other hero — a fourth crew member, seldom recognized in the common narrative of humankind’s lunar landing. It was known as AGC: the Apollo Guidance Computer.

Heavy Math

To say that inertial guidance was critical to landing on the Moon is the understatement of the Space Age. Imagine tracking the position of the Lunar Module (LEM) during landing, while simultaneously handling the navigation and thrust of the engine until an astronaut assumed manual control — and doing all these guidance calculations while taking into account the constantly changing mass of LEM as it burned off 17,400 pounds of fuel in 12 minutes. That, my friends, is some heavy duty math.

Well before the Apollo 11 mission, the math existed to handle the most complicated problems of physics and engineering, as did the inertial guidance technology first demonstrated in 1953 by Doc Draper in a B-29 Superfortress traveling from Massachusetts to California. The challenge was to improve the computers required to manage the technology. The end result would have to meet exacting metrics for performance, size, and reliability.

At the time of the Apollo program, routine computing was done by creating stacks of punch card input, which were run in batches through a computer while the person who needed the work done waited hours (or days) for the result. This was obviously not going to work in handling the inertial guidance tasks required by a lunar landing. NASA assigned MIT’s Instrumentation Lab (IL) with the task of coming up with something that would.

IL was the MIT R&D department created and managed by Doc Draper, and it was given the responsibility for the design and engineering of the equipment necessary to guide Apollo to the Moon and back, including inertial navigation units and any necessary telescopes, sextants, and other star-sighting equipment, the computers that would run all of these, and the programming to run the computers — which, of course, included all the navigational equations this entailed. In the end, MIT would do the design and debugging, but AC Spark Plug (remember spark plugs?) would build the inertial units, Sperry would build the accelerometers, and Raytheon would build the computers. A company called Kollsman Instrument built the star-sighting instruments.

MIT’s Design Innovations

As impossible as it may seem from the vantage point of today’s computing environment, the Apollo computer handled all of its critical inertial guidance tasks with less computing power than a typical microwave oven has today. There were simply no other computers like it in the world. At a time when IBM owned two-thirds of the computer market and mainframe computers were scaling down from room-size to merely closet-size, the Apollo computers measured one cubic foot — a single box that a person could carry.

NASA was able to accomplish this technology miracle thanks to its pioneering use of the world’s first integrated circuits (ICs) in the Apollo 11 command module and LEM. From that standpoint, it was the first organization to give computer chips responsibility for human life. Thanks to its use of IC technology, NASA introduced the world to the concept of “real time computing” — an essential requirement in situations and environments demanding nanosecond decision making. In actual fact, the AGCs had built-in decision-making ability, which meant that they could look at all the work that needed to be done at any given moment in flight and organize the execution of tasks in order of their importance — executive decision-making capability. The AGCs also had the ability to restart, wiping their memory clean in the case of a failure and picking up where they had been when restarting.

The use of ICs (including the first microprocessors) also made it possible to reduce computer size — the target for which had been set in a rather haphazard way. t was the job of North American Aviation to build the Apollo command module, and during the design process they needed to know the dimensions of the AGC. North American called MIT to find out, but at that point the computer under development was essentially a bunch of equipment on a rack, with the design imperative of shrinking it down as much as possible. When pressed for specifics, MIT tossed out a wild guess of 1 cubic foot — and North American held them to it. In the end, the space taken up in the Apollo command and lunar landing modules by the AGC measured 1.04 cubic feet. Lucky guess or sheer genius? You make the call.

Rope Core Memory

MIT came up with another innovation in its quest to reduce the size of its guidance and navigation computer — one that it first developed for a Mars probe in the late 1950s that never actually flew. Most of the computer’s memory was “fixed” (what we used to call “read-only memory”, or ROM, back in the day). In the case of the Mars probe computer and the those eventually used for the Apollo program, the general purpose programming was “woven” into modules using wires threaded through tiny magnets. This new type of computer memory was called “core rope” memory, and had performance benefits as well.

Besides speed and size, another critical aspect of the AGC’s success metrics was reliability. Computers at the beginning of manned space flight were not reliable. While John Glenn was in orbit, the primary computer in Mission Control failed for 3 minutes (out of a 4 hour and 55 minute mission). Anything approaching this could be catastrophic for the Apollo missions. The Instrumentation Lab had found that the standard for reliability of electronic components for the aviation industry was one failure in 10,000 hours. For spaceflight computers with thousands of computer chips, this simply wasn’t good enough. IL wanted a reliability of one failure in 100,000 hours and undertook an exhaustive study based on the 400,000 chips it had purchased. When the study was completed in 1967, those components had achieved an impressive 330 million hours without a failure — the equivalent of 10,000 of them running continuously for four years!

The First User Interface

Another “first” associated with the AGC was what we refer to today as a “user interface” — and what was known at the time as DSKY. Like today’s personal computers, DSKY had a keyboard, but it had only numbers and no letters. Measuring eight inches square and seven inches deep, it also had an early version of the function keys that would become familiar to all computer users over the next couple of decades. While the vast majority of the operations the AGC would manage were “hard wired” and autonomous, DSKY gave the astronauts a way to not only interact with the navigation and guidance computer, but assert some control over its functioning. This would prove to be critical on July 20, when Neil Armstrong piloted LEM to the lunar surface.

Thanks to NASA and the Apollo program, America’s nascent semiconductor industry matured to make chips of near perfect quality — and to make them cheaper, faster, and better with each successive year. To appreciate how far and fast the industry has come, consider this: the AGC, arguably the most advanced computer in the world in 1969, could execute 85,000 instructions per second. By comparison, the iPhone X (introduced in 2018) can handle 5 trillion instructions per second. Amazingly, the AGC accomplished its tasks with two-millionths of one percent of the computing capacity now residing in the phones in our pockets.

While the legacy of the Moon landing will likely be debated for years to come, we can be sure of one thing: the race to the Moon didn’t usher in the Space Age as we may have once imagined it in the ‘60s…but it did usher in the Digital Age — and this has indeed proven a great leap for mankind.