Gaining Code Confidence Through Testing
By: Steven Foote
One of the most interesting paradoxes of programming is this: As you gain experience, the confidence you have in your code tends to decrease. This is not because a programmer's talent decreases over time. No, it is because the longer you program, the greater the quantity and variety of bugs you have seen. With more experience, programmers realize that in systems as complex as software applications, bugs are inevitable. While newer programmers are certain that their code is flawless, experienced programmers know there are flaws, and only worry how many.
The situation may seem dire, but we are not without hope. We have ways to mitigate, minimize, and even prevent bugs. Among these techniques are documentation, proper software design, and software testing. While all of these options are important, I think the most neglected among new programmers is software testing. This article will discuss how a programmer can increase code confidence through software testing.
What Is Software Testing?
For the first few years of my life as a programmer, testing was nearly indistinguishable from debugging. I tested my programs as I was building them, running them in the same way that the programs' end users were supposed to do. I tested only the feature I was building at the moment, and if something was broken I would debug and fix it. This type of software testing is called manual testing, and its value should not be underestimated. However, manual testing has a few very large holes:
Manual testing is slow. You can only test as fast as you can use your program.
Manual testing is limited. You generally test only the feature on which you are currently working—other parts of the system may break due to your changes, and those bugs will be missed.
Manual testing relies on your (fallible) memory. Even if you try to test your entire program after each change, you will almost certainly forget to test certain aspects of it.
Manual testing is great, but to really gain confidence in your code, you need automated testing. An automated test is a piece of software specifically designed to test your software. Generally speaking, there are two kinds of automated tests:
Unit tests are used to test how a single unit of your program works.
Integration tests are used to test how the entire program works with other systems.
In practice, a lot of automated tests lie somewhere in the spectrum between unit tests and integration tests.
All of these types of tests are important, but we will focus on unit tests in this article, because unit tests are the most fundamental automated tests. Automated tests offer some major advantages over manual testing:
Rapid. Automated tests are fast because the computer executes them.
Comprehensive. You can easily run automated tests for your entire program when you make a change, instead of just the part of the program on which you are currently working.
Repeatable. Once you have written a suite of automated tests, they will all be executed every time you want to run your tests. You don't have to worry about forgetting any of the tests.
Why You Need to Test
As I mentioned earlier, I spent my first few years programming without writing any automated tests. I didn't write automated tests because I realize they even existed, and I didn't really understand what use they would have. On smaller, short-term projects, the lack of tests seemed fine; I didn't even recognize the need for tests. But as the size and complexity of my software projects grew, I started to feel the pain.
On one occasion, I was releasing a new version of a Chrome extension with some great new features. Only after I had released the new version did I realize that the new features broke some of the extension's most vital functionality. I quickly fixed the bugs and released another version, only to find I had broken something else. I think I released four versions within an hour before I got the extension working correctly again. By the end of that hour, I had almost no confidence in my code. The lesson I eventually learned from experiences like this is that you should write unit tests, because they will give you the confidence to build new features, fix bugs, and release new versions of your software. Write and execute thorough tests, and you can ship with confidence.
... to read more articles, visit http://sqa.fyicenter.com/art/