How was software developed during apollo?

From various sources, it can be gleaned that the computer was a ibm system 360, and the language was basically a fortran dialect or fortran.

What I'd like to know, is how did they do it? Did they just write away or plan? Were there reviews? What did test procedures look like back then? What editor was used? Was there a version control system in place? How was change management handled?

  • 1
    $\begingroup$ I'm sorry, but this is far too broad. You can start with the 43-page Apollo Guidance Software Development and Verification Plan report dated 4 Oct 1967. Then continue with Computers On Board The Apollo Spacecraft: The Apollo guidance computer: Software on NASA's history web site. $\endgroup$ – a CVn May 29 '16 at 14:57
  • 1
    $\begingroup$ You may also want to read up on Margaret Hamilton, also Her Code Got Humans on the Moon—And Invented Software Itself and Margaret Hamilton, the Engineer Who Took the Apollo to the Moon. A web search for something like apollo software development should give you plenty more to get started. $\endgroup$ – a CVn May 29 '16 at 14:58
  • 1
    $\begingroup$ Or, if you prefer it presented as video, you can give Moon Machines: The Navigation Computer a view. It is a documentary (about 43 minutes long) that describes the development of the Apollo navigation computer, including its software. $\endgroup$ – a CVn May 29 '16 at 15:07
  • 1
    $\begingroup$ @OrganicMarble You're right. Looking again, I suspect based on the mention of the System/360 that OP is not primarily interested in the onboard software (which also likely was developed in anything but FORTRAN, due to the constraints of the onboard computers in particular). I still do think that the links illustrate just how broad the question is -- even as they relate only to some of the computer systems that made the Apollo missions possible, and possibly not what the OP was primarily interested in. $\endgroup$ – a CVn May 29 '16 at 15:41
  • 1
    $\begingroup$ @JerardPuckett I fear the question would still be too broad even with citations for the claims made in the question itself. It is simply asking for too much. On the other hand, narrowing the question down to one of the (six, by my count) aspects mentioned in the final paragraph could probably make it narrow enough to warrant reopening, in my opinion. $\endgroup$ – a CVn May 30 '16 at 7:23

NASA's history site gives a lot of the answers to your questions:

What I'd like to know, is how did they do it? Did they just write away or plan? Were there reviews?

In the Apollo program, as well as other space programs with multiple missions, system software and some subordinate computer programs are only written once, with some modifications to help integrate new software. However, each mission generates new operational requirements for software, necessitating a design that allows for change. Since 1968, when designers first used the term software engineering, consciousness of a software life cycle that includes an extended operational maintenance period has been an integral part of proper software development.

Even during the early 1960s, the cycle of requirements definition, design, coding, testing, and maintenance was followed ...

What did test procedures look like back then? Was there a version control system in place? How was change management handled?

Three boards contributed directly to the control of the Apollo software and hardware development. The Apollo Spacecraft Configuration Control Board monitored and evaluated changes requested in the design and construction of the spacecraft itself, including the guidance and control system, of which the computer was a part. The Procedures Change Control Board, chaired by Chief Astronaut Donald K. Slayton, inspected items that would affect the design of the user interfaces. Most important was the Software Configuration Control Board, established in 1967 in response to continuing problems and chaired for a long period by Christopher Kraft. It controlled the modifications made to the on-board software. All changes in the existing specification had to be routed through this board for resolution. NASA's Stan Mann commented that MIT "could not change a single bit without permission".

NASA also developed a specific set of review points that paralleled the software development cycle. ...

Designers developed the programs using a Honeywell 1800 computer and later an IBM 36O, but never with the actual flight hardware. The development computers generated binary object code and a listing. The tape [44] containing the object code would be tested and eventually released for core rope manufacture. The listing served as documentation of the code.

For Apollo, MIT developed a special higher order language that translated programs into a series of subroutine linkages, which were interpreted at execution time. This was slower than a comparable assembly language program, but the language required less storage to do the same job. The average instruction required two machine cycle-about 24 milliseconds-to execute.

  • $\begingroup$ Any non-trivial software requires design. Nobody sits at a computer and just starts typing if they want it to work. When human lives are at stake, more formal processes are used. Even today when I write shell scripts, I "design" by writing the comments which describe what needs to happen in order. Sometimes each comment is a single line of code, but more often it becomes a subroutine ... or a complete subsystem for non-trivial projects. Taking notes as you go is very important, since we all loose ideas in sleep. Wouldn't expect that Apollo could support the power requirements for an IBM-360. $\endgroup$ – JohnP Mar 7 '17 at 15:22

Not the answer you're looking for? Browse other questions tagged or ask your own question.