Wow, we are just as close to 2070 as we are far from 1970. How did they test software 50 years ago? You’ll be surprised to find out, very similarly to how we do it today. The main difference with testing approaches today is the access to technology is greatly improved.
Nearly every developer has access to tools that provide fast testing feedback for what they are working on. Software testing has evolved with the history of computers.
Table of Contents
Landing on the Moon
We first landed on the moon on July 20, 1969. This required a huge amount of testing across software, hardware and with astronauts. There were no second chances if this stuffed up. A lot of the Software Engineering practices developed for the moon landing have established themselves as decent practices today.
Hamilton led the team that developed the building blocks of software engineering – a term that she coined herself. Her systems approach to the Apollo software development and insistence on rigorous testing was critical to the success of the Apollo Project
Source: NASA
You can access source code for the Apollo 11 project on GitHub too.
Testing Guidelines for Apollo 11
When it came to testing the physical hardware/software, there were 5 guidelines which were applied to all spacecraft tests:
- Building block approach to testing. Each component was verified before integration testing.
- End-to-end testing. The use of mocks and substitutes was minimised.
- Isolation and functional verification of all redundancies. All code paths were proven with end-to-end tests.
- Interface testing and verification. All interfaces were consistent.
- Mission profile simulation. The astronauts were involved with real user testing.
These guidelines still ring true today and actually align with this mobile app testing strategy my team uses. The only difference is today we don’t need to build a space hanger to do end to end testing. Oh and getting users involved with testing reminds me of Soap Opera Testing; what could possibly go wrong?
Software Bugs from History
The Y2K bug from the year 2000 (any old computer that used YY as their year format, e.g. 99 might stuff up when the year 2000 rolled around) is an interesting lesson in how bugs in software shape the industry.
This bug caused a huge investment into updating mainframe computers all around the world and established India as the outsource IT capital of the world.
Globally; $308 billion dollars was spent on compliance and testing and it helped build more robust systems that survived the system crashes from the 9/11 terrorist attacks.
A lot of these business critical mainframe systems were built during the 70’s and 80’s. A lot of finance industries around the world still rely on these systems.
Jerry Weinberg might have something to say
I’m currently reading Jerry Weinberg’s Quality Software Management, which was published in 1992 and he has some references from the 70’s. Once I finish reading the book I’ll put up a summary here too. I reckon it’ll be just as relevant today as it was in 1992.
What lessons from history have influenced your testing approach?
1 comment