Johannes Bohnet

Visual exploration of function call graphs for feature location in complex software systems

Maintenance, reengineering, and refactoring processes of software systems are typically driven and organized in terms of features. Feature change requests need to be translated into changes in source code, which is a highly cost intensive and time consuming task when complex legacy software systems are concerned; their documentation is likely to be outdated and incomplete. In this paper, we propose a prototype tool that supports users in locating and understanding feature implementation in large (>1 MLOC) C/C++ systems. A combination of static and dynamic analysis allows extracting of the function call graph during feature execution and interpreting it within the static architecture of the system. An interactive multi-view visualization enables users to explore that graph. An effective 2 1/2D visualization provides various visual cues that facilitate finding those paths in the function call graph that are essential for understanding feature functionality. Additionally to source code aspects, the dynamic metric of function execution times is exploited, which gives significant hints to feature-implementing functions. Furthermore, information on functions is extended by architectural aspects, thereby supporting users in remaining oriented during their analysis and exploration task as they can give priority to selected architectural components and thereby hide insignificant function calls.

Monitoring code quality and development activity by software maps

Software development projects are difficult to manage, in general, due to the friction between completing system features and, at the same time, obtaining a high degree of code quality to ensure maintainability of the system in the future. A major challenge of this optimization problem is that code quality is less visible to stakeholders in the development process, particularly, to the management. In this paper, we describe an approach for automated software analysis and monitoring of both quality-related code metrics and development activities by means of software maps. A software map represents an adaptive, hierarchical representation of software implementation artifacts such as source code files being organized in a modular hierarchy. The maps can express and combine information about software development, software quality, and system dynamics; they can systematically be specified, automatically generated, and organized by templates. The maps aim at supporting decision-making processes. For example, they facilitate to decide where in the code an increase of quality would be beneficial both for speeding up current development activities and for reducing risks of future maintenance problems. Due to their high degree of expressiveness and their instantaneous generation, the maps additionally serve as up-to-date information tools, bridging an essential information gap between management and development, improve awareness, and serve as early risk detection instrument. The software map concept and its tool implementation are evaluated by means of two case studies on large industrially developed software systems.

Understanding complex multithreaded software systems by using trace visualization

Understanding multithreaded software systems is typically a tedious task: Due to parallel execution and interactions between multiple threads, such a systems runtime behavior is often much more complex than the behavior of a single-threaded system. For many maintenance activities, system understanding is a prerequisite. Hence, tasks such as bug fixing or performance optimization are highly demanding in the case of multithreaded systems. Unfortunately, state-of-the-art tools for system understanding and debuggers provide only limited support for these systems. We present a dynamic analysis and visualization technique that helps developers in understanding multithreaded software systems in general and in identifying performance bottlenecks in particular. The technique first performs method boundary tracing. Second, developers perform a post-mortem analysis of a systems behavior using visualization optimized for trace data of multithreaded software systems. The technique enables developers to understand how multiple threads collaborate at runtime. The technique is integrated into a professional and scalable tool for visualizing the behavior of complex software systems. In case studies, we have tested the technique with industrially developed, multithreaded software systems to understand system behavior and to identify multithreading-related performance bottlenecks.

Locating and Understanding Features of Complex Software Systems by Synchronizing Time-, Collaboration- and Code-Focused Views on Execution Traces

Extending or modifying features of complex software systems is often a highly time-consuming and cost-intensive task as, beforehand, the features have to be located within the code and to be understood in detail. To support developers in performing this task, we propose a technique that takes execution traces and implementation unit structuring as input data and provides various views thereupon. Views focus on different trace characteristics, namely they are time-, collaboration-, and code-focused. Synchronizing the views creates a rich user interface that helps developers to effectively identify and understand feature relevant parts of the implementation.

Visualizing massively pruned execution traces to facilitate trace exploration

Execution traces provide precise pictures of the inner workings of software systems. They therefore support programmers in performing various maintenance tasks. However, exploring traces is difficult due to their size. They typically consist of thousands of participating functions and millions of control flow events. When exploring traces, it is particularly time-consuming to identify those time ranges within the trace that are relevant for the current maintenance task. In this paper, we propose a technique that supports programmers in exploring traces in that it first prunes less relevant calls from the trace and then provides condensed and repetition-aware visualizations that facilitate fast and accurate navigation even within very large traces. Repetitions in the trace are detected by a novel metrics to measure similarity between function calls in a fuzzy and adjustable way. The metrics helps to identify outlier calls in repetitive call sequences and guides programmers on control paths being likely relevant for their comprehension task. The technique is implemented within a prototypical analysis tool that copes with large C/C++ software systems. We demonstrate the concepts by means of a case study with our industrial partner.

Object aware execution trace exploration

To understand software systems it is common practice to explore runtime information such as method calls. System behavior analysis can further be facilitated by additionally taking runtime data dependencies into account. In object oriented systems, a typical data dependency is the information about which objects are accessed by the traced method calls. To support software engineers in handling the massive amount of information that execution traces typically consist of, highly scalable visualizations are needed. In this paper, we propose a trace-visualization technique that (a) explicitly visualizes both, method calls and object accesses, and (b) provides high scalability to handle large execution traces. With regard to the visualization technique proposed, we give a systematic overview of visual patterns that are to be expected and of their meanings with respect to system behavior. Additionally, we present the results of three case-studies to show how our approach facilitates developers in comprehending the behavior of complex C++ software systems.

Projecting code changes onto execution traces to support localization of recently introduced bugs

Working collaboratively on complex software systems often leads to situations where a developer enhances or extends system functionality, thereby however, introducing bugs. At best the unintentional changes are caught immediately by regression tests. Often however, the bugs are detected days or weeks later by other developers noticing strange system behavior while working on different parts of the system. Then it is a highly time-consuming task to trace back this behavior change to code changes in the past. In this paper we propose a technique for identifying the recently introduced change that is responsible for the unexpected behavior. The key idea is to combine dynamic, static, and code change information on the system to reduce the possibly great amount of code modifications to those that may affect the system while running its faulty behavior. After having applied this massive automated filtering step, developers receive support in semi-automatically identifying the root cause change by means of a trace exploration frontend. Within multiple synchronized views, developers explore when, how and why modified code locations are executed. The technique is implemented within a prototypical analysis tool that copes with large (> MLOC) C/C++ software systems. We demonstrate the approach by means of industrial case studies.

Facilitating Exploration of Unfamiliar Source Code by Providing 21/2D Visualizations of Dynamic Call Graphs

For modifying functionality of legacy software systems developers often need to work within millions of lines of unfamiliar code. In this paper we propose a concept that exploits dynamic call graphs for (a) identifying code parts that implement the functionality to be modified and (b) guiding developers while navigating from one source code file to another. The proposed concept is implemented within a tool for analyzing complex C/C++ software systems and has been tested on various million LOC systems. The tool provides a visualization front-end that permits developers to explore the system implementation on 3 levels of abstraction: (I) source code, (2) function interaction, and (3) module interaction. A 21/2D visualization view exploits perspective distortion for displaying both detailed and context information on Junctions and modules, by this, supporting developers during their comprehension tasks.

Visualization of Multithreaded Behavior to Facilitate Maintenance of Complex Software Systems

Maintenance accounts for the major part of a software systems total costs. Therein, program comprehension is an important, but complex activity: Typically, up-to-date documentation is not available, so the main reliable source of information on the implementation represent the artifacts of the systems implementation. Understanding software systems is difficult, in particular, if multithreading concepts are involved because state-of-the art development tools provide only limited support for maintenance activities. In addition, concurrency is often not directly reflected by the source code, i.e., there is only a non-obvious correlation between control structures in the source code and a systems runtime behavior. We present a program comprehension technique that helps to analyze and understand runtime behavior of multithreaded software systems and, thereby, facilitates software maintenance tasks. Our approach contains the following concepts: First, light-weight dynamic analysis records executed method calls at runtime. Second, visualization of multithreading trace data allows developers to explore the system behavior post-mortem. The technique forms part of a scalable tool suite for understanding the behavior of complex software systems. We also show how to apply the technique on industrial software systems to solve common maintenance problems.

Enhancing structural views of software systems by dynamic information

Understanding software systems comprises the analysis of different aspects of the respective systems, such as dynamic and static analysis with all their facets. Consequently, developers study different kinds of information and create different mental models. We introduce a visualization technique that facilitates cross referencing mental models, in particular models that describe the structure and models describing the behavior of software systems. To achieve this goal, we enhance structural views by runtime information depending on the current focus of a sequential view. Animation enables developers to explore how the systems state changes over time, by this, supporting developers in understanding program behavior.