Understanding software through dynamic analysis has been a popular activity in the past decades. One of the most common approaches in this respect is execution trace analysis: among our own efforts in this context is EXTRAVIS, a tool for the visualization of large traces. Similar to other trace visualization techniques, our toolhasbeenvalidatedthrough anecdotal evidence, but should also be quantitatively evaluatedto assessitsusefulnessforprogramcomprehension. This paper reports on a first controlled experiment concerning trace visualization for program comprehension. We designedeighttypicaltasksaimedatgaininganunderstanding 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 in terms of correctness and time spent. The results are statistically significant in both regards, showing a 21% decrease in time and a 43% increase in correctness for the latter group.

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—Ajax-enabled web applications are a new breed of highly interactive, highly dynamic web applications. Although Ajax allows developers to create rich web applications, Ajax applications can be difficult to comprehend and thus to maintain. For this reason, we have created FireDetective, a tool that uses dynamic analysis at both the client (browser) and server side to facilitate the understanding of Ajax applications. Using an exploratory pre-experimental user study, we see that web developers encounter problems when understanding Ajax applications. We also find preliminary evidence that the FireDetective tool allows web developers to understand Ajax applications more effectively, more efficiently and with more confidence ★. I.

Software maintenance and evolution can be made easier if program comprehension techniques are used. Understanding a software system would typically necessitate a combination of static and dynamic analysis techniques. The aim of this workshop is to gather together researchers working in the area of program comprehension with an emphasis on dynamic analysis. We are interested in investigating how dynamic analysis techniques are used or can be used to enable better comprehension of a software system. The objective is to find common case studies, compare existing techniques, and find possible symbioses for existing solutions. Building upon the two previous editions of the workshop, we aim to set up a forum for exchanging experiences, discussing solutions, and exploring new ideas. 1

This research demonstration presents the tool, Dynamic Interactive Views for Reverse Engineering (Diver). Diver supports software understanding through a trace focused user interface. The trace focused user interface is a method of re-organizing the user interface of integrated development environments so that developers can focus their attention on artifacts related to the run-time behaviour of the software that they are investigating. The tool combines concepts from research in software visualization, dynamic analysis, software reconnaissance, and task focused user interfaces.

The highly dynamic and loosely coupled nature of a serviceoriented software system leads to the challenge of understanding it. In order to obtain insight into the runtime topology of a SOA system, we propose a framework-based runtime monitoring approach to trace the service interactions during execution. The approach can be transparently applied to all web services built on the framework and reuses parts of information and functionality already available in the framework to achieve our goals. Categories and Subject Descriptors

Abstract—When trying to understand a system that is based on the principles of Service-Oriented Architecture (SOA), it is typically not enough to understand the individual services in the architecture, but also the interactions between the services. In this paper, we present a technique based on dynamic analysis that can be used to obtain insight into how services work together to perform overall business functionality. In particular, our technique connects traces from individual services together, so that the user can obtain a global understanding of how the entire SOA works. I.

Abstract not found

Researchers and practitioners are usually eager to develop, test and experiment with new ideas and techniques to analyze software systems and/or to present results of such analyzes, for instance new kind of visualizations or analysis tools. However, often these novel and certainly promising ideas are never properly and seriously empirically evaluated. Instead their inventors just resort to anecdotal evidence to substantiate their beliefs and claims that their ideas and the realizations thereof are actually useful in theory and practice. The chief reason why proper validation is often neglected is that serious evaluation of any newly realized technique, tool, or concept in reverse engineering is time-consuming, laborious, and often tedious. Furthermore, we assume that there is also a lack of knowledge or experience concerning empirical evaluation in our community. This paper hence sketches some ideas and discusses best practices of how we can still, with moderate expenses, come up with at least some empirical validation of our next project in the field of reverse engineering.

Abstract — In addition to studying the construction and evolution of software services, the software engineering discipline needs to address the operation of continuously running software services. A requirement for its robust operation are means for effective monitoring of software runtime behavior. In contrast to profiling for construction activities, monitoring of operational services should only impose a small performance overhead. Furthermore, instrumentation should be non-intrusive to the business logic, as far as possible. We present the Kieker framework for monitoring software runtime behavior, e.g., internal performance or (distributed) trace data. The flexible architecture allows to replace or add framework components, including monitoring probes, analysis components, and monitoring record types shared by logging and analysis. As a non-intrusive instrumentation technique, Kieker currently employs, but is not restricted to, aspect-oriented programming. An extensive lab study evaluates and quantifies the low overhead caused by the framework components. Qualitative evaluations provided by industrial case studies demonstrate the practicality of the approach with a telecommunication customer self service and a digital photo submission service. Kieker is available as open-source software, where both the academic and industrial partners contribute to the code. Our experiment data is publicly available, allowing interested researchers to repeat and extend our lab experiments.