Margaret Hamilton (1936–2026): the engineer who named our profession

What happened

Margaret Hamilton died on October 7, 2026, at the age of 90. MIT News confirmed the news in an obituary published by the Institute, where Hamilton spent the formative years of her career at the Instrumentation Laboratory — the group that wrote the onboard flight software for every crewed Apollo mission, including the lunar landings.

Hamilton joined the Lab in 1964 as a programmer on the SAGE air-defense system, moved onto Apollo, and by the time of the lunar missions was Director of the Software Engineering Division, running a team of roughly 100 engineers responsible for the Command Module and Lunar Module onboard code. She is the person who, in the mid-1960s, started calling what her team did "software engineering" — a label she chose deliberately, as she later put it, "to give the people doing it some legitimacy."

After Apollo she co-founded Higher Order Software in 1976 and later Hamilton Technologies in 1986, where she spent decades formalizing her ideas about preventing errors by design under the Universal Systems Language and the Development Before the Fact methodology. She received the Presidential Medal of Freedom in 2016 and the NASA Exceptional Space Act Award — the largest single award NASA had ever given an individual at the time — in 2003.

Why it matters

Most obituaries will reproduce the photograph: a young Hamilton standing next to a stack of printouts of the Apollo Guidance Computer source code, taller than she is. It's a nice image. It's also the least interesting thing about her.

The interesting thing is what happened at 102 hours, 38 minutes into the Apollo 11 mission, roughly three minutes before Eagle touched down in the Sea of Tranquility. A rendezvous radar switch had been left in the wrong position, flooding the AGC with spurious cycle-stealing interrupts. The computer began throwing 1201 and 1202 alarms — "executive overflow, no vacant areas" and "executive overflow, no core sets." On most computers of the era, that would have been a crash. Mission control would have called an abort. The landing wouldn't have happened.

It didn't crash because Hamilton's team had built the AGC's executive as an asynchronous, priority-scheduled, restart-protected operating system — in 1968, on a machine with 2K of RAM and 36K of rope-core ROM, in assembly. When the scheduler ran out of core sets, it didn't fail; it shed the lowest-priority jobs, kept the critical guidance and display tasks running, and used recovery blocks to restart cleanly without losing state. The guidance kept guiding. The display kept displaying. Buzz Aldrin kept getting altitude numbers. Armstrong landed with about 25 seconds of fuel to spare.

That's not folklore. That's a design decision made years earlier, over the explicit objection of people who thought her insistence on hardened error handling was paranoid overkill. There's a frequently retold story about Hamilton wanting to add code to prevent an astronaut from accidentally selecting P01 (a prelaunch program) during flight. She was told astronauts were trained professionals and would never do that. Jim Lovell did exactly that on Apollo 8, and the resulting state had to be recovered from the ground. The next version shipped with the guard.

The through-line of her career is the belief that reliability is not something you test into a system at the end; it is something you design into the system from the start, by making certain classes of error structurally impossible. That idea — now a cliché in every talk about fault tolerance, defense-in-depth, idempotency, and "errors are values" — was heresy when she was arguing for it. Programming in 1965 was something hardware engineers did between "real" work. There was no curriculum. There was no profession. There was no word for it. So she coined one.

What this means for your stack

It's tempting to file Hamilton under "inspirational history" and move on. Don't. If you ship distributed systems, her fingerprints are on your runbook whether you've read her papers or not.

The AGC executive is the ancestor of every priority-based real-time scheduler running in your Kubernetes control plane, your embedded firmware, your Erlang supervisor tree. The 1202 story is the original case study for graceful degradation — the idea that under load, a correct system sheds non-critical work rather than failing catastrophically — which is exactly what your circuit breakers, your load shedders, and your `PriorityClass` manifests are doing when they work. Hamilton's "man-in-the-loop" error recovery, where the system refuses to silently paper over an unexpected state and instead surfaces it with enough context for a human to decide, is the ethos behind every well-designed on-call alert, every structured error, every "fail loud, not quiet" principle in the SRE book.

Her later work on Development Before the Fact is less universally beloved — formal methods never quite went mainstream the way she hoped — but even there, the lineage runs through TLA+, through Rust's type system, through the quiet renaissance of design-by-contract in Pydantic and `assert`-heavy Python shops. The point was always the same: catch the error at the earliest possible moment, ideally before you've written the line that could produce it. If you've ever written a property-based test, you are in her debt.

And when you argue in a design review that error paths deserve as much attention as happy paths, that the retry policy is part of the API, that `panic` is not a strategy — you are, whether you know it or not, repeating an argument she had to win against a room full of hardware engineers who thought software was a bookkeeping task.

Looking ahead

There is a particular kind of pioneer whose work becomes so foundational that it stops being attributed to anyone — it just becomes "how things are done." Hamilton is in that category. The next time your service survives a Thundering Herd because the scheduler dropped the right requests, or your deploy rolls back cleanly because someone insisted on recovery semantics, consider that a small, uncredited piece of what she built in a windowless MIT lab in 1968, in assembly, on a computer less powerful than the chip in a modern bathroom scale. The least we can do is use the word she gave us — software engineering — like we mean it.