Suppose regression testing reported many defects, and now we need decide about the order in which to correct them. In addition to commonly used defect prioritization based on their business importance, we propose to take into account also dependencies among defects, and to correct defects in an order that reduces the overall debugging effort. A goal here is to start by fixing root causes of failures, i.e., defects that may be causing many other program failures. A related goal is to avoid prematurely fixing defects that depend on other, yet to be fixed defects, as this is likely to incur wastage of time. Our proposed method requires that test cases have been mapped to relevant software requirements. We defined heuristics to infer defect dependencies, and a suitable defect debugging order from these mappings. The process is semi-automatic, supported by a tool called TRAcker. TRAcker accepts test results, performs heuristics-based computations, and recommends a time-efficient defect debugging order from the perspective of defect dependencies. TRAcker’s filtering and visualization features allow a user to participate in the process, so that tool recommendations as well as other factors can be taken into account. We show that defect prioritization on technical and business grounds together contribute to effective debugging.

Software evolution relies on storing component versions along with delta-changes in a repository of a version control tool such a centralized CVS in old days, or decentralized Git today. Code implementing various software features (e.g., requirements) often spreads over multiple software components, and across multiple versions of those components. Not having a clear picture of feature implementation and evolution may hinder software reuse which most often is concerned with feature reuse across system releases, and components are just means to that end. Much research on feature location shows how important and difficult is to find feature-related code buried in program components post mortem. We propose to avoid creating the problem in the first place, by explicating feature-related code in component versions at the time of their implementation. To do that, we complement traditional version control approach with generative mechanisms. We describe salient features of such an approach realized in ART (Adaptive Reuse Technology, http://art-processor.org), and explain its role in easing comprehending software evolution and feature reuse. Advanced commercial version control tools make a step towards easing the evolution problems addressed in this paper. Our approach is an alternative way of addressing the same problem on quite a different ground.