The term “bug” is fairly common in this age of technology. Most people seem to understand that in the context of software or technology in general, it means something bad or annoying, especially because that’s what a bug is in nature.
Some bugs may go unnoticed, some may simply annoy, and some may do us harm or even kill us. Some bugs are fairly easy to find, while others are very rare and require expertise and perhaps intuition or chance to find. These characteristics actually apply to both bugs in nature and bugs in software.
Both types of bugs are also plentiful. This is an important thing to understand in the context of software development. When embarking on a software development project, it would be unwise to think that there will not be any bugs during the process. Quality Assurance (QA) is an integral part of software development, and it must begin as the project starts. Insufficient QA has led to the untimely and costly termination of many software development projects, or worse.
So, what exactly is a software bug, then? Well, there are many types of software bugs. But in short, it’s an error or something unintentional in the software.
Although rarely a bug may be determined to be desirable, usually it is something to be corrected. A bug may be an incorrect answer to a simple mathematical expression, but it may lead to a devastating result such as shutting down an automobile engine in the middle of high-speed freeway traffic.
During the course of a software development project, something may be reported as a bug that the software developer implemented intentionally. This situation may result from a misunderstanding of the project requirements, or possibly from a change in requirements that wasn’t communicated to the software developer. Either way, this situation underscores the importance of regular and effective communication among the entire software project team.
Now that we understand that we should expect bugs in a software development project, how do we find them? Everyone involved in the project at any level (Development, QA, Management, etc.) should be watching for bugs. Obviously, the developer should test any new code to be sure that it behaves as designed. Even before that, the architect should review the design before it is ever implemented. Any supervisory types who review the design or check development progress should also watch for any defects (another word for bugs).
While other team members have their own special focus on the project, the dedicated project tester has a special responsibility to ensure that the software has been tested thoroughly, and that nothing is missed. The project tester understands the target user and the intended workflow of the software, and exercises the software on various platforms, under various circumstances, and with varying assumptions. A good project tester finds bugs by drawing upon a well-informed understanding of the software and the target user, past experience, and intuition.
The project tester performs various types of testing to ensure that the project requirements are met, including:
- Feature-level or functional testing
- Regression testing
- Release testing
- Usability testing
- Performance testing
- User-level testing
Once a bug is discovered, a report is filed in a central tracking system. The project manager should then verify that what was reported really is a bug, and that it can be reproduced by someone else. It is important that the report include clear steps to reproduce the bug, so that the developer may focus on fixing the bug rather than trying to chase it down.
Some reports may actually be change requests, in which case they may be either postponed for later, or they may be determined important enough to fold back into the development cycle.
After a bug report is verified and it includes sufficient information for the developer to reproduce the bug, it is prioritized. Due to schedule or budget constraints, it may be necessary to focus only on the high-priority issues. It’s important to consider that some less-severe bugs may be high-priority, such as an incorrect spelling of a company’s legal name. At some point, the software should be considered worthy of release.
For a software project to succeed, a top priority should be to minimize bugs in the software development process. The most cost-effective way to handle a bug is to never create it in the first place. After that, it is best to find and fix a bug as close to its creation as possible, while the corresponding source code is fresh in the developer’s mind, and before it propagates to any other part of the system.
There are many aspects of a software development project that when effectively utilized will minimize bugs and help the project to ultimately succeed:
- Regular and effective project team communication
- Requirements gathering and approval
- Software design
- Project plan and schedule
- Programming style guide
- Unit testing
- Project test plan
- Appropriate qualified personnel, including project manager, software architect, user interface designer, developers, and project tester
While bugs should be expected in software development projects, they may be kept to a manageable level by utilizing proven QA techniques right from the project start.