This paper reports on an experiment in which first year programming students were given explicit encouragement to use Object (Instance) diagrams when tracing code in multiple-choice questions. We conjectured that by providing scaffolding in this technique, students would be helped to understand the code better and that they would then continue to draw their own diagrams in similar situations. This turned out not to be the case. Although generally students who draw diagrams do better in questions that test their understanding of code behaviour and object referencing, our intervention does not appear to have helped students and the students who were exposed to the intervention were not more likely to go on to use the technique themselves.

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.

3D visualizations of software can be used to highlight relationships between system compo-nents, and also allow focussing on the internals of software, particularly when applied to object oriented software. Such visualizations allow software engineers to comprehend larger software systems, due to more information being available through the use of a third dimen-sion. An architecture has been designed to carry out such visualizations. Major features of this architecture are a meta language to describe object oriented systems, a description language to generate generic visualizations, and an automated pipeline for generating visual-izations. Using this architecture, several visualizations have been generated and analysed, to

This paper presents a process for the refinement of safety-critical source code into a more tractable representation. For large software-intensive information systems, the safety engineering view of the system reveals a "long thin slice" of hazard-related software involving a number of different software components. The hazard-related software is documented in the system "safety verification case" which provides a rigorous argument for the safety of the source code. The refinement process creates a representation of the source code which isolates the relevant source code details. A hypothetical chemical factory information system is examined to illustrate aspects of this process and its significance.

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.

We present a rich and highly dynamic technique for analyzing, visualizing, and exploring the execution traces of reactive systems. The two inputs are a designer’s interobject scenario-based behavioral model, visually described using a UML2-compliant dialect of live sequence charts (LSC), and an execution trace of the system. Our method allows one to visualize, navigate through, and explore, the activation and progress of the scenarios as they “come to life” during execution. Thus, a concrete system’s runtime is recorded and viewed through abstractions provided by behavioral models used for its design, tying the visualization and exploration of system execution traces to model-driven engineering. We support both event-based and real-time-based tracing, and use details-on-demand mechanisms, multi-scaling grids, and gradient coloring methods. Novel model exploration techniques include semantics-based navigation, filtering, and trace comparison. The ideas are implemented and tested in a prototype tool called the Tracer.

Event traces are required to correctly diagnose a number of performance problems that arise on today’s highly parallel systems. Unfortunately, the collection of event traces can produce a large volume of data that is difficult, or even impossible, to store and analyze. One approach for compressing a trace is to identify repeating trace patterns and retain only one representative of each pattern. However, determining the similarity of sections of traces, i.e., identifying patterns, is not straightforward. In this paper, we investigate pattern-based methods for reducing traces that will be used for performance analysis. We evaluate the different methods against several criteria, including size reduction, introduced error, and retention of performance trends, using both benchmarks with carefully chosen performance behaviors, and a real application. 1.

This paper is on a project to evaluate the impact of visualizing dynamic data dependences in the context of maintenance activities. Our work is based on previous work in displaying static data dependences and on experience with large sets of dependence displaying strategies that we adapted to deal with problems where dynamic information is crucial. We developed a prototype around a Lisp interpreter and applied it to a highly complex AI program. This permitted us to build efficient visualizations and to evaluate the benefits of using dynamic dependences for program understanding, debuging and correctness checking. In this paper, we present our prototype, detailing especially the different visualizations we introduced to allow users to deal with hard to understand programs, and we discuss how dynamic dependences permit to see what really happens during program executions. 1.

This paper proposes an approach to the safety verification of the source code of a software-intensive system. This approach centers upon the production of a document intended to ensure the inspectability, maintainability and repeatability of the source code safety verification. This document, called a "safety verification case", is intended to be a part of the overall system safety case. Although the approach was designed for large softwareintensive real-time information systems, it may also be useful for other kinds of large software systems with safety-related functionality. The approach involves the construction of a rigorous argument that the source code is safe. The steps of the argument include simplifying the safety verification case structure by isolating the relevant details of the source code, and reducing the "semantic gap" between the source code and the system level hazards through a series of hierarchical refinement steps. Some of the steps in a process based on this appr...

Erklärung gemäß §23 der Diplom-Prüfungsordnung: Hiermit erkläre ich, daß ich die Arbeit selbständig durchgeführt und keine anderen als die angegebenen Quellen und Hilfsmittel verwendet habe. ii 04.02.98 15:27