Share →
Buffer

In the previous two posts (Part 2 and Part 3) I covered an ideal bug process and the metrics you gather from the process. In this post I’ll start talking about how to use those metrics to really improve the process. I’ll also talk a bit more about who’s responsible for what. The main goal here is to show that it is not a major impact on the development team (if you’re using Team System – if you’re doing this manually it may require more time).

Roles & Responsibilities

The figure below shows who is responsible for transitioning items between states in a perfect world.

Roles_and_Responsibilities

This figure very succinctly states the following:

  1. A user, analyst, developer or tester can file a bug report.
  2. A project manager must assign the bug report to someone to investigate. The person they will assign it to is an analyst.
  3. An analyst can determine if the investigation is complete. They can also close a bug for the reasons noted in the previous section.
  4. A project manager assigns the bug to a developer (or not if the bug is being fixed in a later release).
  5. A developer will set the bug to Active when they start working on it.
  6. A developer determines when the bug is fixed.
  7. Depending on the release process, either a Release Manager or QA Manager will note when the bug is ready for testing (and assign it to a tester). This is because there may be a configuration management (i.e. branching structure) which the code fix needs to be promoted through so that the testers can actually get it in a good build.
  8. A tester will note that the bug is being tested.
  9. A tester will note that the bug fix has been verified. If the bug has not been fixed, a tester can also re-assign the bug to a developer.
  10. A release manager will determine which release the bug fix will be deployed in and prepare the appropriate documentation.
  11. Upon successful release, the project manager will close the bug.

Reports

So, you have this great bug tracking process now and you know what information you can get from each step. How do you get it easily? What reports are most important? Where do you cut down on waste?

Waste

Let’s start with looking at a report showing waste and determine how it might be eliminated. The next figure shows a chart of the average flow time for bugs in a system using the above process.

Bug throughput

This chart is based on the following data:

State Updated Time Time (in hours)
Proposed 8/25/2008 9:30
Under Investigation 8/25/2008 10:30 1
Investigation Complete 8/26/2008 11:00 8.5
Assigned 8/27/2008 10:00 7
Active 8/27/2008 10:15 .25
Fixed, unverified 8/27/2008 16:30 6.25
Ready for Testing 8/29/2008 17:00 16.5
In Testing 9/1/2008 11:00 2
Fixed, verified 9/1/2008 11:30 .5
Scheduled for Deployment 9/2/2008 15:00 11.5
Closed 9/4/2008 13:00 14
Total 67.5

Note that I have included only working hours – no weekends or after hours. While this would normally be an average of these values, I wanted to demonstrate how time is determined. Still, if this were an average, you would note that the average time to fix bugs and deploy them is 67.5 hours or almost three days on average. Where can you reduce the amount of time wasted?

Note

In Lean, batching is considered a bad process. The reason for this is that when you batch it means that someone is waiting to receive all of the times that make up that batch and therefore time is wasted. However, in software development, and specifically when dealing with change and release configuration management there really is no other way because fixes almost always must go in together. Promoting them one at a time would take more time than it would save and is also a major configuration headache.

Looking at the chart and table, the actual time spent working on the bug is 15.25 hours (the hours spent investigating, fixing and testing). The time wasted is 50.25 hours (the hours spent waiting while the bug was waiting to be investigated, between the investigation being completed and the bug being assigned, between the bug being assigned and the bug being worked, between the bug being fixed and it being tested and finally between the time the bug was tested until the time the bug was deployed). Again, going back to the principle of waste in Lean theory, the 50.25 hours is complete waste. Now having said that, let’s take a reality check since not all of Lean can apply to software development. Where can you reasonably shave hours?

The first thing to do is to understand why an item may be in a given state for an extended period of time. Let’s look at a hypothetical process and see what may happen in some of these states where waste is occurring.

The next post in this series will cover the hypothetical process. We’ll also start covering different scenarios and organization size when dealing with issues because this is NOT a one-size fits all process.

Print Friendly
  • Pingback: Team System News : VSTS Links - 11/18/2008()

  • RamS

    Jeff,
    It was great to meet you at the SeaSPIN presentation this evening.
    -Ram

  • montebertrand

    RE: “A tester will note that the bug fix has been verified. If the bug has not been fixed, a tester can also re-assign the bug to a developer.”

    I have always found it better to go back to the PM. It avoids the conflict of testers being able to overload a single developer with work that he doesn’t have bandwidth for … but does this create waste?

  • That’s a good thought Monte and I’ll have to think about it. The thought process here is that the bug that wasn’t fixed would be assigned back to the developer since this was a priority bug for this iteration and it didn’t need to go back to the PM for re-assignment. But I can see that in some cases this is not a bad option at all. I’ll update the post when I get time.

  • Pingback: Practical Process Improvement (Part 5) :: Where Technology Meets Teamwork()