Root Cause Analysis of Defects

Here is a list of potential (common) defect Causes which can be used to divide the root cause of a defect list:

• Unintended Side Effect – The bug is due to an unanticipated side effect from a change somewhere else in the code.  This category can be used when the programmer would say to himself/herself “I had no idea a change in that area would affect something over in this area”. 
  
• Logic / Simple Err – The bug is due to a simple programming error.  This could include bad logic in an if statement, a typo, an uninitialized variable, a missing break statement, not checking for a nill pointer, etc. 
  
• Overlooked Use Case – The bug is due to the software being used in some way that the programmer didn’t expect. 
  
• Code Path Not Done – The bug is due to a code path not being completely implemented.  This could be the result of incomplete work being checked in and tested.  It could be the result of forgetting to come back to fill in some code.  This cause should always be selected if an “Unimplemented” assert was found in the code. 
  
• Misunderstood Rqmt – The bug is due to a misunderstanding of the feature requirements. 
  
• Requirements Changed – The bug is due to a change in the feature requirements at some point while the software was being written.  One example could be a changed UI. 
  
• External Dependency Chg – The bug is due to a change in an external subsystem or application.  This could include API changes or semantic changes in a library. 
  
• Design Flaw – The bug is due to a design flaw in the original implementation. 
  
• Code Rot or Hack – The bug is due to code that has become convoluted in logic or implementation because it has had so many changes done to it.  Another example is a bug due to a partial fix for some other problem that was put in due to lack of time. 
  
• Code Misunderstanding – The bug is due to the programmer not fully understanding the true functionality of the code.  This could be due to the code being overly complex.  Another possibility is that the programmer didn’t fully understand a new architecture that they were helping to implement.  Or perhaps they “cut and pasted” several lines of code without understanding what it did.