HCI Bibliography Home | HCI Conferences | SV Archive | Detailed Records | RefWorks | EndNote | Hide Abstracts
SV Tables of Contents: 0305060810

Proceedings of the ACM Symposium on Software Visualization

Fullname:SoftVis'03 Proceedings of the ACM Symposium on Software Visualization
Editors:Stephan Diehl; John T. Stasko
Location:San Diego, California
Dates:2003-Sep-16 to 2003-Sep-17
Standard No:ISBN: 1-58113-642-0; ACM Order Number: 102032; ACM DL: Table of Contents hcibib: SV03
  1. Interesting program representations
  2. Integrating SV systems
  3. Visualization for program understanding
  4. Algorithm animation evaluation
  5. Debugging and finding faults
  6. Software visualization for specific domains
  7. All things UML

Interesting program representations

Program animation based on the roles of variables BIBAKFull-Text 7-ff
  Jorma Sajaniemi; Marja Kuittinen
Computer programming is a difficult skill for many students and visualizations may be used to foster learning. This paper presents a program animation system, PlanAni, that is based on the concept of the roles of variables. Roles represent schematic uses of variables that occur in programs over and over again, and a set of nine roles covers practically all variables in novice-level programs. PlanAni has been tested in a teaching experiment comparing traditional teaching with role-based teaching and animation. The results of a semi-structured interview with the teacher indicate that students like to work with the animator and that the system clarifies many concepts in programming.
Keywords: program animation, roles of variables, teaching experiment
Growing squares: animated visualization of causal relations BIBAKFull-Text 17-ff
  Niklas Elmqvist; Philippas Tsigas
We present a novel information visualization technique for the graphical representation of causal relations, that is based on the metaphor of color pools spreading over time on a piece of paper. Messages between processes in the system affect the colors of their respective pool, making it possible to quickly see the influences each process has received. This technique, called Growing Squares, has been evaluated in a comparative user study and shown to be significantly faster and more efficient for sparse data sets than the traditional Hasse diagram visualization. Growing Squares were also more efficient for large data sets, but not significantly so. Test subjects clearly favored Growing Squares over old methods, naming the new technique easier, more efficient, and much more enjoyable to use.
Keywords: causal relations, information visualization, interactive animation
3D representations for software visualization BIBAKFull-Text 27-ff
  Andrian Marcus; Louis Feng; Jonathan I. Maletic
The paper presents a new 3D representation for visualizing large software systems. The origins of this representation can be directly traced to the SeeSoft metaphor. This work extends these visualization mechanisms by utilizing the third dimension, texture, abstraction mechanism, and by supporting new manipulation techniques and user interfaces. By utilizing a 3D representation we can better represent higher dimensional data than previous 2D views. An overview of our prototype tool and its basic functionality is given. Applications of this method to particular software engineering tasks are also discussed.
Keywords: 3D visualization, SeeSoft, file maps, software visualization

Integrating SV systems

EVolve: an open extensible software visualization framework BIBAKFull-Text 37-ff
  Qin Wang; Wei Wang; Rhodes Brown; Karel Driesen; Bruno Dufour; Laurie Hendren; Clark Verbrugge
Existing visualization tools typically do not allow easy extension by new visualization techniques, and are often coupled with inflexible data input mechanisms. This paper presents EVolve, a flexible and extensible framework for visualizing program characteristics and behaviour. The framework is flexible in the sense that it can visualize many kinds of data, and it is extensible in the sense that it is quite straightforward to add new kinds of visualizations.
   The overall architecture of the framework consists of the core EVolve platform that communicates with data sources via a well defined data protocol and which communicates with visualization methods via a visualization protocol.
   Given a data source, an end-user can use EVolve as a stand-alone tool by interactively creating, configuring and modifying visualizations. A variety of visualizations are provided in the current EVolve library, with features that facilitate the comparison of multiple views on the same execution data. We demonstrate EVolve in the context of visualizing execution behaviour of Java programs.
Keywords: JVMPI, Java, object-oriented systems, software visualization, trace-based visualization
Plugging-in visualization: experiences integrating a visualization tool with Eclipse BIBAKFull-Text 47-ff
  Rob Lintern; Jeff Michaud; Margaret-Anne Storey; Xiaomin Wu
The Eclipse platform presents an opportunity to openly collaborate and share visualization tools amongst the research community and with developers. In this paper, we present our own experiences of "plugging-in" our visualization tool, SHriMP Views, into this environment. The Eclipse platform's Java Development Tools (JDT) and CVS plug-ins provide us with invaluable information on software artifacts relieving us from the burden of creating this functionality from scratch. This allows us to focus our efforts on the quality of our visualizations and, as our tool is now part of a full-featured Java IDE, gives us greater opportunities to evaluate our visualizations. The integration process required us to re-think some of our tool's architecture, strengthening its ability to be plugged into other environments. We step through a real-life scenario, using our newly integrated tool to aid us in merging of two branches of source code. Finally we detail some of the issues we have encountered in this integration and provide recommendations for other developers of visualization tools considering integration with the Eclipse platform.
Keywords: configuration management and version control, integration, software development environment, software visualization

Visualization for program understanding

Visualizing Java in action BIBAKFull-Text 57-ff
  Steven P. Reiss
Dynamic software visualization is supposed to provide programmers with insights as to what the program is doing. Most current dynamic visualizations either use program traces to show information about prior runs, slow the program down substantially, show only minimal information, or force the programmer to indicate when to turn visualizations on or off. We have developed a dynamic Java visualizer that provides a view of a program in action with low enough overhead so that it can be used almost all the time by programmers to understand what their program is doing while it is doing it.
Keywords: dynamic software visualization, instrumentation, run-time monitoring
Visualization of program-execution data for deployed software BIBAKFull-Text 67-ff
  Alessandro Orso; James Jones; Mary Jean Harrold
Software products are often released with missing functionality, errors, or incompatibilities that may result in failures in the field, inferior performances, or, more generally, user dissatisfaction. In previous work, we presented the GAMMA technology, which facilitates remote analysis and measurement of deployed software and allows for gathering program execution data from the field. When monitoring a high number of deployed instances of a software product, however, a large amount of data is collected. Such raw data are useless in the absence of a suitable data-mining and visualization technique that supports exploration and understanding of the data. In this paper, we present a new technique for collecting, storing, and visualizing program-execution data gathered from deployed instances of a software product. We also present a prototype toolset, GAMMATELLA, that implements the technique. We show how the visualization capabilities of GAMMATELLA allows for effectively investigating several kinds of execution-related information in an interactive fashion.
Keywords: Gamma technology, remote monitoring, software visualization
A system for graph-based visualization of the evolution of software BIBAFull-Text 77-ff
  Christian Collberg; Stephen Kobourov; Jasvir Nagra; Jacob Pitts; Kevin Wampler
We describe GEVOL, a system that visualizes the evolution of software using a novel graph drawing technique for visualization of large graphs with a temporal component. GEVOL extracts information about a Java program stored within a CVS version control system and displays it using a temporal graph visualizer. This information can be used by programmers to understand the evolution of a legacy program: Why is the program structured the way it is? Which programmers were responsible for which parts of the program during which time periods? Which parts of the program appear unstable over long periods of time and may need to be rewritten? This type of information will complement that produced by more static tools such as source code browsers, slicers, and static analyzers.

Algorithm animation evaluation

Algorithm visualization in CS education: comparing levels of student engagement BIBAKFull-Text 87-94
  Scott Grissom; Myles F. McNally; Tom Naps
Software technology for algorithm visualization (AV) has advanced faster than our understanding of how such technology impacts student learning. In this paper we present results of a multi-university study. We measured the effect of varying levels of student engagement with AV to learn simple sorting algorithms. These levels included: 1) not seeing any visualization, 2) simply viewing visualizations for a short period in the classroom, and 3) interacting directly with the visualizations for an extended period outside of the classroom. Our results show that learning increases as the level of student engagement increases. AV has a bigger impact on learning when students go beyond merely viewing a visualization and are required to engage in additional activities structured around the visualization. In particular, students who responded to questions integrated into the AV tool during their exploration of an algorithm showed the most improvement between a pretest and posttest.
Keywords: algorithm visualization, computer science education, sorting algorithms
Dancing hamsters and marble statues: characterizing student visualizations of algorithms BIBAKFull-Text 95-104
  Teresa Hübscher-Younger; N. Hari Narayanan
Algorithm visualization research for computer science education has primarily focused on expert-created visualizations. However, constructionist and situated theories of learning suggest that students should develop and share their own diverse understandings of a concept for deep learning. This paper presents a novel approach to algorithm learning by visualization construction, sharing, and evaluation. Three empirical studies in which students engaged in these activities are discussed. The resulting learning benefits are quantified, and student visualizations are characterized in multiple ways. Then another study that investigated how specific characteristics of such visualizations influence learning is described. This work demonstrates the effectiveness of having students create algorithm visualizations, identifies characteristics of student-created algorithm visualizations and illuminates the learning benefits derived from these characteristics.
Keywords: algorithms, empirical studies, learning, multimedia, representation, visualization
Designing effective program visualization tools for reducing user's cognitive effort BIBAKFull-Text 105-ff
  M. Eduard Tudoreanu
Program visualization holds great potential for conveying information about the state and behavior of a running program. However, barriers exist to the realization of this potential, and the limited knowledge about the factors that affect program visualization makes the identification of these barriers difficult. We present arguments that the economy of information and tasks related to the visualization environment has a significant impact on the user's performance in solving algorithmic problems. We apply this knowledge to develop an approach for creating application-specific visualizations solely through interactions with program visualizations and textual views of the computation, thus promoting economy of interaction. The approach consists of a multiple technical contributions that are surveyed in the paper.
Keywords: automatic presentation, cognitive economy, program visualization, user studies

Debugging and finding faults

Interactive visual debugging with UML BIBAKFull-Text 115-122
  Timothy Jacobs; Benjamin Musial
Software debugging is an extremely difficult cognitive process requiring comprehension of overall application behavior along with detailed understanding of specific application components. Typical debuggers provide inadequate support for this process, focusing primarily on the details accessible through source code. To overcome this deficiency, we link dynamic program execution state to a Unified Modeling Language (UML) object diagram. We enhance the standard UML diagram with focus + context, graph layout, and color encoding techniques that organize and present objects and events in a manner that facilitates analysis of system behavior. We support debugging using high level abstractions commonly used in system design, while maintaining access to low level details with an interactive display.
Keywords: Unified Modeling Language (UML), software visualization
End-user software visualizations for fault localization BIBAKFull-Text 123-132
  J. Ruthruff; E. Creswick; M. Burnett; C. Cook; S. Prabhakararao; M., II Fisher; M. Main
End-user programming has become the most common form of programming today. However, despite this growth, there has been little investigation into bringing the benefits of software visualization to end-user programmers. Evidence from the spreadsheet paradigm, probably the most widely used end-user environment, reveals that end users' programs often contain faults. We would like to integrate software visualization into these end-user environments to help end users deal with the reliability issues in their programs. Towards this end, we have devised several fault localization visualization techniques for spreadsheets. This paper describes these techniques and reports the results of a formative study -- using tests created by end users -- to investigate how these fault localization techniques compare. Our results reveal some strengths and weaknesses of each technique, and provide insights into the cost-effectiveness of each technique for the interactive world of end-user spreadsheet development.
Keywords: end-user programming, end-user software engineering, end-user software visualization, fault localization, spreadsheets

Software visualization for specific domains

Interactive locality optimization on NUMA architectures BIBAKFull-Text 133-ff
  Tao Mu; Jie Tao; Martin Schulz; Sally A. McKee
Optimizing the performance of shared-memory NUMA programs remains something of a black art, requiring that application writers possess deep understanding of their programs' behaviors. This difficulty represents one of the remaining hindrances to the widespread adoption and deployment of these cost-efficient and scalable shared-memory NUMA architectures. To address this problem, we have developed a performance monitoring infrastructure and a corresponding set of tools to aid in visualizing and understanding the subtleties of the memory access behavior of parallel NUMA applications with large datasets. The tools are designed to be general, interoperable, and easily portable. We give detailed examples of the use of one particular tool in the set. We have used this memory access visualization tool profitably on a range of applications, improving performance by around 90%, on average.
Keywords: NUMA Architectures, distributed systems, interactive locality optimizations, performance visualization
Graph visualization for the analysis of the structure and dynamics of extreme-scale supercomputers BIBAKFull-Text 143-149
  Cheng Zhou; Kenneth L. Summers; Thomas P. Caudell
We are exploring the development and application of information visualization techniques for the analysis of new massively parallel supercomputer architectures. Modern supercomputers typically comprise very large clusters of commodity SMPs interconnected by possibly dense and often nonstandard networks. The scale, complexity, and inherent nonlocality of the structure and dynamics of this hardware, and the systems and applications distributed over it, challenge traditional analysis methods. As part of the 'a la carte team at Los Alamos National Laboratory, who are simulating these advanced architectures, we are exploring advanced visualization techniques and creating tools to provide intuitive exploration, discovery, and analysis of these simulations. This work complements existing and emerging algorithmic analysis tools. This paper gives background on the problem domain, a description of a prototypical computer architecture of interest (on the order of 10,000 processors connected by a quaternary fat-tree communications network), and a presentation of two classes of visualizations that clearly display the switch structure and the flow of information in the interconnecting network.
Keywords: graph visualization, scalable representations, virtual environments
Visualizing software for telecommunication services BIBAKFull-Text 151-ff
  Emden R. Gansner; John M. Mocenigo; Stephen C. North
An active research area in telecommunications concerns how to specify and control the addition of new services, such as call waiting or instant messaging, into existing software. One approach is to rely on a component-based architecture such as Distributed Feature Composition (DFC), by which a new service can be specified as a composition of primitive features over time. Formally, a communication episode is represented by a dynamic graph of software feature boxes, called a usage. This serves as the fundamental model for how services are invoked and how they interact with other services.
   This paper, after providing some background on DFC, discusses a technique for visualizing the usages which arise through DFC specifications. With the visualization, users can monitor and validate service protocols and feature interactions in real time or through playback logs. The principal display component uses a novel variation of force-directed layouts for undirected graphs. The resulting graphical interface has become a principal tool for developers building services using DFC.
Keywords: algorithm animation, graph layout

All things UML

Nice class diagrams admit good design? BIBAKFull-Text 159-ff
  Holger Eichelberger
Analysis and design of programs by using tools has emerged to a standard technique in object-oriented software engineering. Many of these tools claim to implement methods according to the UML standard and some of the tools provide automatic layout of the diagrams drawn by the user or generated automatically from source code. In this paper we propose a set of aesthetic criteria for UML class diagrams and discuss the relation between these criteria, HCI and design aspects of object-oriented software.
   First we describe critics from the viewpoint of HCI to the UML notation and restrict ourself to changes which do not require nonstandard modifications to the UML notation guide, then we list quality relations between class diagrams and object-oriented software models. After that our set of aesthetic criteria, that reflect the highly sophisticated structural and semantic features of UML class diagrams, is explained. Finally, we show that an implementation and measurement of this proposal is realizable using a prototypical graph drawing framework.
Keywords: HCI, UML class diagrams, aesthetics, metrics, software engineering
Visualizing model mappings in UML BIBAFull-Text 169-178
  Jan Hendrik Hausmann; Stuart Kent
Whenever multiple representations or models of a system exist, there is the possibility of defining how they relate. In model driven software development, it is essential that these mappings are defined precisely and automated as far as possible: they form the basis for generation of code and other models from a model, for reconciliation and management of consistency between models, and even for the definition of modeling languages themselves. A standard way of defining software modeling languages is metamodeling, which involves the construction of an object model of the syntax and, optionally, semantics of the language, using the diagrammatic syntax of the Unified Modeling Language (UML). This paper proposes an extension to UML for expressing mappings between models using diagrams, and illustrates how the extension can be used in metamodeling. The extension is inspired by mathematical relations and corrects a deficiency in the concept of association in class diagrams. The notation of object diagrams is also extended to allow particular instances of a relation to be presented.
A new approach for visualizing UML class diagrams BIBAKFull-Text 179-188
  Carsten Gutwenger; Michael Jünger; Karsten Klein; Joachim Kupke; Sebastian Leipert; Petra Mutzel
UML diagrams have become increasingly important in the engineering and reengineering processes for software systems. Of particular interest are UML class diagrams whose purpose is to display class hierarchies (generalizations), associations, aggregations, and compositions in one picture. The combination of hierarchical and non-hierarchical relations poses a special challenge to a graph layout tool. Existing layout tools treat hierarchical and non-hierarchical relations either alike or as separate tasks in a two-phase process as in, e.g., [Seemann 1997]. We suggest a new approach for visualizing UML class diagrams leading to a balanced mixture of the following aesthetic criteria: Crossing minimization, bend minimization, uniform direction within each class hierarchy, no nesting of one class hierarchy within another, orthogonal layout, merging of multiple inheritance edges, and good edge labelling. We have realized our approach within the graph drawing library GoVisual. Experiments show the superiority to state-of-the-art and industrial standard layouts.
Keywords: UML Class Diagrams, graph drawing, graph layout, software visualization
A topology-shape-metrics approach for the automatic layout of UML class diagrams BIBAKFull-Text 189-ff
  Markus Eiglsperger; Michael Kaufmann; Martin Siebenhaller
Class diagrams are among the most popular visualizations for object oriented software systems and have a broad range of applications. In many settings it is desirable that the placement of the diagram elements is determined automatically, especially when the diagrams are generated automatically which is usually the case in reverse engineering. For this reason the automatic layout of class diagram gained importance in the last years. Current approaches for the automatic layout of class diagrams are based on the hierarchic graph drawing paradigm. These algorithms produce good results for class diagrams with large and deep structural information, i.e., diagrams with a large and deep inheritance hierarchy. However, they do not perform satisfactorily in absence of this information. We propose in this work a new algorithm for automatic layout of class diagram which is based on the topology-shape-metrics approach. The algorithm is an adaption of sophisticated graph drawing algorithms which have proven their effectiveness in many applications. The algorithm works as well for class diagrams with rich structural information as for class diagrams with few or no structural information. It improves therefore the existing algorithms significantly. An implementation of the algorithm is used in the reverse engineering tool JarInspector.
Keywords: UML Diagrams, graph drawing