We are aware of how challenging it can be to code software from scratch. Now imagine that human lives depend on that code, and those lives are the ones of the astronauts who will set the first foot on the Moon. Exciting, and a little scary, isn’t it?
We know a lot about the Apollo 11 mission, about its story, protagonists, and results; but how much do we know about the software that was developed to make all this possible?
The birth of software engineering:
In the 60’s the concept of software engineering was still not clear, and it was a result of a trial-and-error process related to large-size military, civilian, and spaceborne systems development. Without a methodology in place, it was necessary to define the stages in the software development cycle and provide documentation at each step to help control the production of software.
To fulfill this task, NASA developed a specific set of review points that paralleled the software development cycle:
- Critical Design Review (CDR)
- This is a multi-disciplined technical review to ensure that a system can proceed into fabrication, demonstration, and test and can meet stated performance requirements within cost, schedule, and risk.
- First Article Configuration Inspection (FACI)
- A planned, complete, independent, and documented inspection and verification process to ensure that prescribed production processes have produced an item conforming to engineering drawings, DPD, planning, purchase order, engineering specifications, and/or other applicable design documents. This step marked the completion of the development stage and placed the software code under configuration control
- Customer Acceptance Readiness Review (CARR)
- After the completion of all the tests, this review certified that the validation process resulted in the desired software.
- The Flight Readiness Review (FRR)
- This was the last step in clearing the software for flight. The FRR examined tests, demonstrations, analyses, and audits that determined the overall system readiness for a safe and successful flight/launch and for subsequent flight operations. It also ensured that all flight and ground hardware, software, personnel, and procedures were operationally ready.
The Apollo software was already defined in 1963 and the designers agreed to assign to it an extensive list of tasks, such as:
- Controlling aborts.
- Navigation and flight control.
- Attitude determination and control.
- Digital autopilot tasks.
- All maneuvers involving velocity changes.
The development of such complex software faced several issues: Real-time flight software development on this scale was a new experience for both NASA and MIT (Massachusetts Institute of Technology). Memory limitations were a constant problem, while new tricky programming techniques allowed to implement features that would otherwise have been abandoned. Despite valiant validation efforts, software bugs remained in released programs, forcing adjustments by users. By 1966, a May software status memo stated that not only would the programs for the AS504 mission (earth orbit with a LEM) exceed the memory capacity by 11,800 words but that the delivery date for the simpler AS207/208 programs would be too late for the scheduled launch115.
At this point developers had to work creatively, as stated by one of MIT top managers:
“If you are limited in program capacity … you have to fix. You have to get ingenious, and as soon as you start to get ingenious you get intermeshing programs, programs that depend upon others and utilize other parts of those, and many things are going on simultaneously. So it gets difficult to assign out little task groups to program part of the computer; you have to do it with a very technical team that understands all the interactions on all these things.”
When MIT realized that the software release was not on schedule, they made a mistake that many companies still do these days: throw more bodies into the project. As many as 50 people were added to the programming staff, causing an increase in both miscommunications and the time necessary to train newcomers. The prediction of Howard W. “Bill” Tindall proved themselves true:
“The computer programs for the Apollo spacecraft will soon become the most pacing item for the Apollo flights.”
what we learned:
It was by overcoming the problems of the Apollo software, that NASA successfully landed a man on the moon by developing programs certified for the purpose. No one doubted the quality of the software produced by MIT. However, it was the software development process that required an extensive overhaul, and NASA extensively worked on improving it.
As a result, the crucial elements for proper software development turned out to be:
(a) Clear documentation.
(b) A multi-level verification.
(c) Clear definition and management of the requirements.
(d) Creation of a development plan.
(e) It became clear as day that more programmers do not mean faster development.
Point (e) also translated in assigning experienced personnel to a project early, rather than using the start of a project for training inexperienced personnel; many NASA managers of software and hardware were learning on the job while in key positions. A higher management involvement in the early phases of software design will also grant a better cost estimation and control.
As for software development, NASA learned that specifications can be set only if an early effort at total systems engineering is made. Changing specifications long after final requirements should have been fixed caused an increase in costs and problems as retooling, memory shortages, and design insufficiencies.
As NASA stated:
“One, if not the most important lesson, is that software is more difficult to develop than hardware.” (Source)
The choice of memory should be software-driven, and designers should develop the software needed for manned spaceflight near the Manned Spacecraft Center: the arrangement with MIT reduced the overall quality and efficiency due to lack of communication and the geographical distance between NASA and MIT.
The AGC system served well on the earth-orbital missions, the six lunar landing missions, the three Skylab missions, and the Apollo-Soyuz test project. However, its greatest contribution was in the way NASA applied the lessons it learned on this project in the future software development, leading to the standards we all follow today.
For any further read on this topic, I suggest you read a detailed article presented by NASA itself at the following link: https://history.nasa.gov/computers/Part1.html