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.

The dynamic analysis approach to feature identification describes a technique for capturing feature behavior and mapping it to source code. Major drawbacks of this approach are (1) large amounts of data and (2) lack of support for sub-method elements. In this paper we propose to leverage sub-method reflection to identify and model features. We perform an on-the-fly analysis resulting in annotating the operations participating in a feature’s behavior with meta-data. The primary advantage of our annotation approach is that we obtain a fine-grained level of granularity while at the same time eliminating the need to retain and analyze large traces for feature analysis.

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.

One way of gaining understanding of a software system is the analysis of dynamic information, i.e., program execution traces. A problem regarding the analysis of such traces is the fact that these are often extremely large: hundreds of thousands and even millions of calls within a single trace are no exception. To aid a user in navigating and understanding these vast amounts of information, we propose to visualize execution traces using two linked views. One is an element interaction view that shows part of a trace, i.e., those calls within a specific time window, using Hierarchical Edge Bundles (HEBs). The other is a more detailed Massive Sequence View that is synchronized with the HEB View and offers detailed information regarding the temporal location and interleaving of the calls within the current time window. This view also introduces a novel way of antialiasing based on the importance of calls. In this paper, we focus on the technical aspects of the visualization and rendering techniques that are necessary to produce scalable visualizations using HEBs and Massive Sequence Views. 1.

Software maintenance activities require a sufficient level of understanding of the software at hand that unfortunately is not always readily available. Execution trace visualization is a common approach in gaining this understanding, and among our own efforts in this context is EXTRAVIS, a tool for the visualization of large traces. While many such tools have been evaluated through case studies, there have been no quantitative evaluations to the present day. This paper reports on the first controlled experiment to quantitatively measure the added value of trace visualization for program comprehension. We designed eight typical tasks aimed at gaining an understanding of a representative subject system, and measured how a control group (using the Eclipse IDE) and an experimental group (using both Eclipse and EXTRAVIS) performed these tasks in terms of time spent and solution correctness. The results are statistically significant in both regards, showing a 22 % decrease in time requirements and a 43 % increase in correctness for the group using trace visualization.

Abstract—In recent years, dynamic program execution traces have been utilized in an attempt to better understand the runtime behavior of various software systems. The unfortunate reality of such traces is that they become very large. Even traces of small programs can produce many millions of messages between different software artifacts. This not only affects the load on computer memory and storage, but it also introduces cognitive load for users, affecting their ability to understand their software. This paper discusses an algorithm which combines data from multiple sources–dynamic execution traces, source code, and debug information–in order to drastically reduce the number of messages that are displayed to the user. We introduce the algorithm and apply it to the Java programming language. The algorithm is employed against several Java software systems to investigate its effectiveness in compacting loops. Its usage is demonstrated in the context of a visualization based on UML

The analysis of execution traces is a common practice in the context of software understanding. A major issue during this task is scalability, as the massive amounts of data often make the comprehension process difficult. A significant portion of this data overload can be attributed to repetitions that are caused by, for example, iterations in the software’s source code. In this position paper, we elaborate on a novel approach to visualize such repetitions. The idea is to compare an execution trace against itself and to visualize the matching events in a two-dimensional matrix, similar to related work in the field of code duplication detection. By revealing these similarities we hope to gain new insights into execution traces. We identify the potential purposes in facilitating the software understanding process and report on our findings so far. 1.

Visualizing collaborations of objects is important for developers understanding and debugging an object-oriented program. Many techniques and tools are proposed to visualize dynamic collaborations involved in an execution trace of a system, however, an execution trace may be too large to be transformed into a single diagram. In this paper, we propose a novel approach to efficiently detecting phases, or high-level behavioral units described in a use-case scenario. Our idea is based on the nature of object-oriented programming; a phase starts with preparing objects for the phase and ends with destroying temporary objects. Our technique uses a LRU cache for observing a working set of objects, and interprets a sharp rise in the frequency of the cache update as a phase transition. We have applied our approach to two industrial applications and found that our approach is promising to visualize a phase corresponding to a feature as a sequence diagram.

Investigating program dependencies such as function calls is challenging for very large systems. We present here an integrated pipeline for extraction and visualization of call-and-hierarchy graphs for C/C++ programs. We present several adaptions and enhancements of a recent visualization method for large call graphs and compare its effectiveness with classical node-link diagrams. Examples are given on large real-world code bases such as bison, Mozilla and oink. 1

Abstract. A feature represents a functional requirement fulfilled by a system. Since many maintenance tasks are expressed in terms of features, it is important to establish the correspondence between a feature and its implementation in source code. Traditional approaches to establish this correspondence exercise features to generate a trace of runtime events, which is then processed by post-mortem analysis. These approaches typically generate large amounts of data to analyze. Due to their static nature, these approaches do not support incremental and interactive analysis of features. We propose a radically different approach called live feature analysis, which provides a model at runtime of features. Our approach analyzes features on a running system and also makes it possible to “grow ” feature representations by exercising different scenarios of the same feature, and identifies execution elements even to the sub-method level. We describe how live feature analysis is implemented effectively by annotating structural representations of code based on abstract syntax trees. We illustrate our live analysis with a case study where we achieve a more complete feature representation by exercising and merging variants of feature behavior and demonstrate the efficiency or our technique with benchmarks.