HW14: Testing Reflections

I can recall early on in my computer science college education being told about the importance of testing. Oddly enough, I don’t recall ever being taught how to do it, or why it was so important until CSCI 362. While it seems apparent why testing would be important when creating a complex system or product, there are unique circumstances in software development that require more of an explanation to understand its importance to its success or failure. As I was thinking through some of the way’s software testing might be different from testing, say a new bicycle design, it became apparent that software testing would likely be more complicated for a few reasons.

Testing Reflections

Don't Think They Tested For This.

First, the number of possible ways to interact with a software system is practically limitless whereas with a bicycle it is expected that the user will interact with it in a limited number of ways. This may seem like an oversimplification, but the same could be said of a more complex system such as an assembly line or other manufacturing processes. There are a lot of interactions that can take place in these systems, but these interactions are within the limitations of physical and human constraints.

Systems Are Big

The inability to have a physical manifestation of a complex system makes identifying and correcting errors in a software system difficult. This may be why the most successful methods of software testing seem to be systematic in their approach. Test-driven development incrementally develops software while creating tests along the way. This has several advantages and may also be ideal for humans as it limits the number of things we are required to remember and interact with at any given time which relates to a previous reading, The Magical Number 7. Testing in this manner also helps ensure the entire codebase is tested and therefore identifying where things ‘break’ is easier as systems grow larger and larger.

Systems are Complicated

Information is Beautiful Chart

The systems we use each day have become, predictably, increasingly complicated. There are many interactions with different parts of the same system, as well as other systems that may not be controlled by the same developer. As these systems have become more intertwined and complicated, the need for automated tests increases. Most software systems are maintained and updated for extended periods of time, a time during which there are new systems integrated with the old, as well as new technologies that impact what is possible. With automated testing in place, changes made by the developer are tested but almost equally important, changes to other systems the developer may rely on are also tested. There is an interesting article written about the sheer volume of code used in various systems throughout history, the oldest on the chart being Unix v 1.0 (1971) that came in with about 10,000 lines of code. The largest in the charge is Google with over 2 billion. Without adequate testing throughout the development process, it seems like it would be nearly impossible to manage these massive systems.

Side note, if you’re interested in the chart’s raw data, click here. One notable comparison I found was an F-22, which costs roughly $334 million, has 1.7 million lines of code and the average new car from 2013 had about 100 million lines of code.

Conclusion

Testing is integral to the development process and introducing up and coming developers to testing methodologies becomes more and more important with each passing day.