The first thing I need to clarify in this post is, what is and what is not a bug.
A software bug is an error, flaw, failure or fault in a
computer program or system that causes it to produce
an incorrect or unexpected result, or to behave in
A software bug is not is
- Incomplete features: During the software development process features will be under development(1). As long as the incomplete nature of the feature does not introduce errors it is not considered a bug.
- Desired features: Frequently the scope of a software develop project will not allow all the desired features to be included in a release of the software. Again, as long as the lack of the feature does not introduce errors it is not considered a bug.
Incomplete features should already be tracked in the project planning timeline. Desired features should be incorporated into the requirements document for the next generation of the project.
Severity of bugs
Not all bugs are created equal; defining the severity of bugs is necessary for prioritizing the correction of the bugs. There are two common metrics for determining severity. Frequency, how often does the bug occur. Impact, when the bug occurs what happens to the program. The following lists provide examples of how frequency and impact could be defined(2).
- Infrequent: Happens in less than 1% of the executions of the program in the normal work tasks.
- Common: Happens for 1 ~ 5% of users in the normal course of work.
- Prevalent: Occurs for 10% of users in their normal course of work.
- Low: Bugs that are cosmetic flaws or provide unclear information to the user. The user should be able to recover from these bugs without affecting their work.
- Medium: Bugs that provide incorrect data to the user and or significantly impact the performance of the process.
- High: Bugs that crash the program or create a loss of data for the user.
Once the frequency and impact have been determined the ranking of the bug can be defined.
The ranks serve as a guideline for prioritizing bug fixes; with required, the recommended and finally advised bugs being fixed in that order(3).
Bug fixing workflow
There are multiple commercially available tools for bug tracking. A basic workflow should include the following tasks and events.
- Bug detection: The bug is found either through use or captured in an existing test case
- Entry into tracking system: Once detected the bug, with comments and reproduction steps, should be entered into the bug tracking system(4).
- Assignment: The bug is assigned to a software engineer for resolution
- Creation of test / validation of solution: If a test case does not already exist for the bug it should be created. The proposed solution to the bug should be run against both the new test case and the existing test cases to ensure that the fix did not introduce new errors.
Bug tracking and resolution is a problem common to all software development workflows. The process for resolving these issues is the same for Model-Based Development as in traditional C development environments. The critical part of bug resolution, as in all development, is that the bugs are clearly defined in an actionable fashion so that the test and software engineers can under stand the problem and find a solution.
(1)Feature encapsulation will help prevent incomplete features impacting other sections of the project. See the software architecture posts for more information.
(2)These partial definitions for frequency and impact; depending on the type of system being developed the error types and frequencies should be adjusted.
(3)The table providing rankings based on frequency and impact should be adjusted depending on the type of system under development. Additionally the criticality of some systems with in the whole should be taking into account when assigning impact.
(4)Entering bugs into the tracking system is critical for creating development metrics. Without the entry there is no method for determining the efficiency of the overall process.