Do we really need software testing? Every person in the development field asks that question at least once. Be it a rookie developer or a client looking to shave a few dollars off their development cost. So we thought why not share the story of how we learned the importance of testing.
You have designed an amazing algorithm. You are about to present it to your potential investors. You have prepared for everything. You have the perfect suit, an awesome presentation. You are ready to blow everyone’s minds.
You are halfway through the presentation and it is going exactly as planned. You have everyone’s attention and you are about to demonstrate the workings of the software. You need to input your first name, Williams. To capitalize the ‘W’ you hold down the shift key but mistakenly press the ‘@’ key right above the ‘W’ key. You click the submit button. Boom!
You and everyone in the room are now looking at an unhandled exception page telling you that validation for ‘First Name’ failed. The page title shows in ugly and huge red letters, “Caught Unhandled Exception.” Sounds scary, doesn’t it?
This is what happened to us many years ago as a team of young rookie developers.
The Fallout
We were able to continue the presentation by going back to the form and entering valid information. However, this little hiccup discouraged
the investors from putting their money into our idea. We received a painstakingly underwhelming response to an otherwise perfect presentation. The one bad thing during the whole presentation was what stuck in their minds.
The Cause
After some sulking and grieving, we put our heads together to determine the cause of our embarrassment. After some investigation into the matter, we learned that all of our forms had similar crash points. Whenever there was an invalid input, submitting the form would cause the application to crash.
Further investigation revealed the actual cause of this mess. A library was not referenced in some of the forms. Hence, input validations applied in some fields were not taking effect. Which means the forms accepted invalid input, which inevitably caused them to crash.
The Solution
So then, we started looking into how we can ensure that something like this never happens again. As we researched and consulted with the experts of the field, it dawned on us quickly that we had skipped one major part of the development process, Software Testing. We could have avoided all of this trouble by using a method of testing called, Negative Testing.
Software Testing
Before we delve further into the details of negative testing, we need to take a step back and answer another question. What is software testing? It is the process of checking whether the results match the expectations. Software testing checks whether the whole system is bug-free.
There are two major strategies:
- Positive Testing helps determine if your software is working as expected. If you are trying to log in, the test checks if the software successfully performs the login action when you enter correct credentials. All intended actions of the software are tested in their ideal conditions.
- Negative Testing is a process that checks if your software can handle invalid input and unexpected user behavior. If you are supposed to enter your email address, it checks what happens if you instead enter your phone number or your name.
As you can probably guess, Negative Testing is exactly what would have saved us from the embarrassment of our software crashing in the middle of a presentation. We would have been able to determine that when entered invalid input such as a special character ‘@’ in a Name field, our application crashed.
Lesson Learned
After that incident, we immediately dedicated resources to develop testing methodologies for our software. Nowadays, not a single piece of code is written in our programs that is not vigorously tested. We always encourage our young developers to understand the value and importance of software testing.
In a time where rapid deployment is the requirement of every project, testing is the difference between an unfinished, immature and error-prone mess and a practical, fluid and smoothly performing software. Hence, to answer our original question, yes! We definitely need software testing for a successful, cost-efficient and scalable software.
