Jump to content

They write the stuff !




They write the stuff - what we can learn from the way the Space Shuttle software was developed

As a youngster I watched the movie "The right stuff" about the Mercury Seven. The film deified the picture of an Astronaut in my mind as some kind of superhero. Many years later I read and just absolutely loved an article written by Charles Fishman in Fast Company in 1996, entitled "They write the stuff", which did something similar for the developers who wrote the code which put those guys up there.

Read the article here : https://www.fastcompany.com/28121/they-write-right-stuff

I find myself going back to this article time and again when confronted by the question about how many bugs is acceptable in our code, or even just on what is possible in terms of quality. The article explores the code which ran the space shuttle and the processes the team responsible for this code follows.

This team is one of very few teams certified to CMM level 5, and the quality of the code is achieved not through intelligence or heroic effort, but by a culture of quality engrained in the processes they have created.


In the shuttle group’s culture, there are no superstar programmers. The whole approach to developing software is intentionally designed not to rely on any particular person.

Here are the important numbers for the Space Shuttle code:

Lines of code 420,000
Known bugs per version 1
Total development cost ($200M) $200,000,000.00
Cost per line of code (1975 value) $476.00
Cost per line of code (2019 inflation adjusted value) $2223.00
Development team (count) +-100
Average Productivity (lines/developer/workday) 8.04

The moral of the story here is that the quality everyone desires is indeed achievable, but we tend to severely underestimate the cost which would go along with this level of quality. I have used the numbers from this article countless times in arguments about the trade-off between quality and cost on my projects.

The most important lesson to learn from this case study is that quality seems to depend primarily on the development processes the team follows and the culture of quality which they adhere to.


It’s the process that allows them to live normal lives, to set deadlines they actually meet, to stay on budget, to deliver software that does exactly what it promises. It’s the process that defines what these coders in the flat plains of southeast suburban Houston know that everyone else in the software world is still groping for. It’s the process that offers a template for any creative enterprise that’s looking for a method to produce consistent – and consistently improving — quality.

As Fishman points out, in software development projects most people focus on attempting to test quality into the software, and of course as Steve McConnell pointed out this is "like weighing yourself more often" in an attempt to lose weight. 


“Most people choose to spend their money at the wrong end of the process,” says Munson. “In the modern software environment, 80% of the cost of the software is spent after the software is written the first time — they don’t get it right the first time, so they spend time flogging it. In shuttle, they do it right the first time. And they don’t change the software without changing the blueprint. That’s why their software is so perfect.”

Another lesson to be learned is that the process inherently accepts the fact that people will make mistakes. Quality is not ensured by people trying really hard to avoid mistakes, instead it accepts the fact that mistakes will be made and builds the detection and correction of these mistakes into the process itself. This means that if something slips through it is inappropriate to blame any individual for this mistake, the only sensible thing to do is to acknowledge a gap in the process, so when a bug does make it out into the wild the team will focus on how to fix the process instead of trying to lay blame on the person who was responsible for the mistake.


Importantly, the group avoids blaming people for errors. The process assumes blame – and it’s the process that is analyzed to discover why and how an error got through. At the same time, accountability is a team concept: no one person is ever solely responsible for writing or inspecting code. “You don’t get punished for making errors,” says Marjorie Seiter, a senior member of the technical staff. “If I make a mistake, and others reviewed my work, then I’m not alone. I’m not being blamed for this.”

Over all this article is a great story which is chock full of lessons to learn and pass on.


The full article is archived here : https://www.fastcompany.com/28121/they-write-right-stuff

NASA has a great piece published on the history of the software https://history.nasa.gov/computers/Ch4-5.html

Fantastic read- the interview with Tony Macina published in Communications of the ACM in 1984 -  http://klabs.org/DEI/Processor/shuttle/shuttle_primary_computer_system.pdf






Recommended Comments

  • Member

“Even though this was not critical,” says Keller, “we went back and asked what other lines of code might have exactly the same kind of problem.” They found eight such situations in the code, and in seven of them, the rounding off function was not a problem. “One of them involved the high-gain antenna pointing routine,” says Keller. “That’s the main antenna. If it had developed this problem, it could have interrupted communications with the ground at a critical time. That’s a lot more serious.”

The "high gain antenna pointing routine" sounds just like the problems with the AE-35 antenna reported by HAL9000 in 2001! 😉


Link to comment
Add a comment...

×   Pasted as rich text.   Paste as plain text instead

  Only 75 emoji are allowed.

×   Your link has been automatically embedded.   Display as a link instead

×   Your previous content has been restored.   Clear editor

×   You cannot paste images directly. Upload or insert images from URL.

  • Create New...