Many of the approaches that analyze software evolution consider a static perspective of a system. Static analysis approaches focus on the evolution of static software entities such as packages, classes and methods. Without knowledge of the roles software entities play in system features, it is difficult to interpret the motivation behind changes and extensions in the code. To tackle this problem, we propose an approach to software evolution analysis that exploits the relationships between features and software entities. Our definition of a feature is a unit of observable behavior of a software system. We define history measurements that summarize the evolution of software entities from a feature perspective. We show how we use our feature perspective of software evolution to interpret modifications and extensions to the code. We apply our approach on two case studies and discuss our findings.

Agile software development methods such as eXtreme Programming have brought renewed attention to testing during the software development process, both as a quality assurance method and as a form of live documentation. It is for this reason that a software system’s testsuite is an ideal starting point for gaining knowledge about its inner workings. In this paper, we propose to use sequence diagrams to visualize information that is dynamically obtained from testsuites. We employ abstraction techniques such as constructor hiding and stack depth limitation to make the diagrams more scalable. We use JPACMAN as a case study to validate our results by consulting with domain experts, and use their feedback to fine-tune our techniques. 1.

This paper describes our experiences of applying dynamic analysis solutions on an industrial legacy application written in C, with the help of Aspect Orientation (AO). We use a number of dynamic analysis techniques that can help in alleviating the problem of (1) establishing the quality of the available regression test and (2) regaining lost knowledge of the application. We also show why our aspect language for C, aspicere, is well-suited for using dynamic analysis in legacy environments. Finally, we present the case study itself, the results we have obtained and the validation thereof by the original developers and current maintainers of the application. We also mention some typical pitfalls that we encountered while dealing with legacy applications in a reengineering context. 1

Most of today’s dynamic analysis approaches are based on method traces. However, in the case of objectorientation understanding program execution by analyzing method traces is complicated because the behavior of a program depends on the sharing and the transfer of object references (aliasing). We argue that trace-based dynamic analysis is at a too low level of abstraction for objectoriented systems. We propose a new approach that captures the life cycle of objects by explicitly taking into account object aliasing and how aliases propagate during the execution of the program. In this paper, we present in detail our new meta-model and discuss future tracks opened by it. 1

Software system analysis for extracting system functionality remains as a major problem in the reverse engineering literature and the early approaches mainly rely on static properties of software. In this paper, we propose a novel technique for dynamic analysis of software systems to identify the implementation of the software features that are specified through a number of feature-specific task scenarios. The execution of task scenarios and application of data mining algorithm sequential pattern discovery on the generated traces allow us to extract common functionality associated with the corresponding feature-specific task scenarios. The extracted patterns are used to identify the groups of core functions that implement software features. The proposed approach can be used for program comprehension and feature to source code assignment. A case study on the Unix Xfig drawing tool has been provided.

Software engineers new to a project are often stuck sorting through hundreds of classes in order to find those few classes that offer a significant insight into the inner workings of the software project. To help stimulate this process, we propose a technique which can identify the most important classes in a system, or the key classes of that system. Software engineers can use these classes to focus their understanding efforts when starting to work on a new software project. Those key classes are typically characterized with having a lot of “control ” within the application. In order to find these controlling classes, we present a detection approach that is based on dynamic coupling and webmining. We demonstrate the potential of our technique using two open source software systems, which have a rich documentation set. During the case studies we use dynamically gathered coupling information and vary between a number of coupling metrics. The case studies show that we are able to retrieve 90 % of the classes deemed important by the orginal maintainers of the systems, while maintaining a level of precision of around 50%. key words: program comprehension, dynamic analysis, webmining, coupling 1.

Without a clear understanding of how features of a software system are implemented, a maintenance change in one part of the code may risk adversely affecting other features. Feature implementation and relationships between features are not explicit in the code. To address this problem, we propose an interactive 3D visualization technique based on a combination of static and dynamic analysis which enables the software developer to step through visual representations of execution traces. We visualize dynamic behaviors of execution traces in terms of object creations and interactions and represent this in the context of a static classhierarchy view of a system. We describe how we apply our approach to a case study to visualize and identify common parts of the code that are active during feature execution. 1

An important part of many software maintenance tasks is to gain a sufficient level of understanding of the system at hand. The use of dynamic information to aid in this software understanding process is a common practice nowadays. A major issue in this context is scalability: due to the vast amounts of information, it is a very difficult task to successfully navigate through the dynamic data contained in execution traces without getting lost. In this paper, we propose the use of two novel trace visualization techniques based on the massive sequence and circular bundle view, which both reflect a strong emphasis on scalability. These techniques have been implemented in a tool called Extravis. By means of distinct usage scenarios that were conducted on three different software systems, we show how our approach is applicable in three typical program comprehension tasks: trace exploration, feature location, and top-down analysis with domain knowledge.

During initial program comprehension, software engineers could benefit from knowing the most need-to-beunderstood classes in the system under study in order to kick-start their software reconnaissance. Previously we have used webmining techniques on runtime trace data to identify these important classes. Here, we reprise this webmining technique and make a thorough comparison of its effectiveness when collecting static information of the software system under study. Apache Ant and Jakarta JMeter, two medium-scale open source Java software systems, serve as case studies. From publicly available developers notes we conclude that the webmining technique in combination with dynamic analysis provides the best results with a level of recall of 90% when comparing with the developers ’ opinion. 1

Program comprehension is an important concern in software maintenance because these tasks generally require a degree of knowledge of the system at hand. While the use of dynamic analysis in this process has become increasingly popular, the literature indicates that dealing with the huge amounts of dynamicinformationremainsaformidablechallenge. Although various trace reduction techniques have been proposed to address these scalability concerns, their applicability in different contexts often remains unclear because extensivecomparisonsarelacking. Thismakesitdifficultfor end-userstodeterminewhichreductiontypesarebestsuited foracertainanalysistask. In this paper, we proposean assessment methodologyfor theevaluationandcomparisonoftracereductiontechniques. We illustratethemethodologyusingaselectionoffourtypes of reduction methods found in literature, which we evaluate andcompareusingatest set of sevenlargeexecutiontraces. Our approach enables a systematic assessment of trace reduction techniques, which eases the selection of suitable reductions in different settings, and allows for a more effective use of dynamic analysis tools in software maintenance.