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'06 Proceedings of the ACM Symposium on Software Visualization
Editors:Eileen Kraemer; Margaret Burnett; Stephan Diehl
Location:Brighton, United Kingdom
Dates:2006-Sep-04 to 2006-Sep-05
Standard No:ISBN: 1-59593-464-2; ACM Order Number: 102062; ACM DL: Table of Contents hcibib: SV06
  1. Session 1
  2. Session 2
  3. Session 3
  4. Session 4
  5. Session 5
  6. Session 6
  7. Challenge abstracts
  8. Poster abstracts

Session 1

The Clack graphical router: visualizing network software BIBAKFull-Text 7-15
  Dan Wendlandt; Martin Casado; Paul Tarjan; Nick McKeown
We present Clack, a graphical environment for teaching students how Internet routers work and other core networking concepts. Clack is a router written as a Java Applet, and routes live network traffic in real-time. Students can look inside the router to see how packets are processed, and watch the dynamics of the queues. They can modify and enhance the router, making it handle packets as they wish. Clack provides multiple views of the operational router including the full network topology, the router's software components, and the packet-level view of traffic as it passes through the router. Clack's detailed visual interface to the software internals of a functioning router, as well as its ability to modify and observe live Internet traffic, provide a unique environment to aid in networking education.
   Over the last two years, Clack has been used in the classroom at six universities. Feedback from the students through anonymous, formal evaluations has been positive. In this paper we describe the goals and design of Clack as well as our experiences using it in the classroom.
Keywords: education, networking, router design, software visualization
Narrative algorithm visualization BIBAKFull-Text 17-26
  Marina Blumenkrants; Hilla Starovisky; Ariel Shamir
Visualization of algorithms has been shown to be a useful aid for educational purposes. In this work we focus on the creation of algorithm visualizations based on viewing the visualization as a narrative. This view promotes the creator to form a central plot and define abstract participating players. Following this view, the basic elements defining a visualization, namely visual metaphors and temporal transitions -- are naturally addressed. The players which signify abstract notions in the algorithm define the depictions, and the story defines the transition over time. This encourages the creator to focus on the mapping process that is the basis of any visual depiction, and helps create a more engaging visualization. We present a study comparing two visualizations, a narrative one and a non-narrative one that supports the effectiveness of the narrative approach.
Keywords: algorithm-animation, algorithm-visualization, narrative
Experimental evaluation of animated-verifying object viewers for Java BIBAKFull-Text 27-36
  Jhilmil Jain; James H., II Cross; T. Dean Hendrix; Larry A. Barowski
Although many visualization techniques have been shown to be pedagogically effective, they are still not widely adopted. The reasons include: lack of suitable methods of automatic-generation of visualizations, lack of integration among visualizations, and lack of integration with basic integrated development environment (IDE) support. To effectively use visualizations when developing code, it is useful to automatically generate multiple synchronized views without leaving the IDE. The jGRASP IDE provides object viewers that automatically generate dynamic, state-based visualizations of objects and primitive variables in Java. Such seamless integration of a lightweight IDE with a set of pedagogically effective software visualizations is unique and is currently unavailable in any other environment. Multiple instructors have reported positive anecdotal evidence of their usefulness. We conducted formal, repeatable experiments to investigate the effect of these viewers for singly linked lists on student performance and we found a statistically significant improvement over traditional methods of visual debugging that use break-points.
Keywords: algorithm animation, data structures, program visualization

Session 2

Execution patterns for visualizing web services BIBAKFull-Text 37-45
  Wim De Pauw; Sophia Krasikov; John F. Morar
Web Services are well on their way to becoming the Lingua Franca for distributed computing. Although tools for building and monitoring web services applications are more powerful and easier to use than ever, they do not yet fully address the horizontal complexity of mature applications built as large nets of interconnected web services. We present a pattern-based visualization that enables business owners, application designers, programmers, and operations staff to quickly understand the behavior of complex web services applications. We describe a novel pattern extraction algorithm that captures important trends from web services execution traces. We demonstrate a new way to visualize these patterns that shows the behavior of web services applications at different levels of abstraction. Finally, we explain how this can help developers with performance analysis by showing both the averages and variations in the data contained in each pattern.
Keywords: patterns, visualizing averages and deviations, web services, web services transaction

Session 3

Visualizing live software systems in 3D BIBAKFull-Text 47-56
  Orla Greevy; Michele Lanza; Christoph Wysseier
The analysis of the runtime behavior of a software system yields vast amounts of information, making accurate interpretations difficult. Filtering or compression techniques are often applied to reduce the volume of data without loss of key information vital for a specific analysis goal. Alternatively, visualization is generally accepted as a means of effectively representing large amounts of data. The challenge lies in creating effective and expressive visual representations that not only allows for a global picture, but also enables us to inspect the details of the large data sets. We define the focus of our analysis to be the runtime behavior of features. Static structural visualizations of a system are typically represented in two dimensions. We exploit a third dimension to visually represent the dynamic information, namely object instantiations and message sends. We introduce a novel 3D visualization technique that supports animation of feature behavior and integrates zooming, panning, rotating and on-demand details. As proof of concept, we apply our visualization technique to feature execution traces of an example system.
Keywords: 3D visualization, dynamic analysis, feature traces, reverse engineering
A data-driven graphical toolkit for software visualization BIBAKFull-Text 57-66
  Camil Demetrescu; Irene Finocchi
In this paper we describe the MONNALISA graphical toolkit, a library of classes written in the VINCI language. VINCI is a multi-paradigm extension to C that combines declarative, imperative, and object-oriented specifications in a reactive framework. The library includes classes for visual, interactive, and layout objects, and arbitrarily complex compound objects can be created in terms of existing classes. MONNALISA is based on a data-driven approach, where graphical objects can depend upon the state of other objects, of a process memory image, or even of the underlying runtime environment. We present examples of how MONNALISA can be used for creating automatic interactive visualizations of different aspects of the dynamic behavior of a piece of software.
Keywords: data flow execution model, graphical libraries, multi-paradigm programming languages, reactive environments, software visualization

Session 4

Transparency, holophrasting, and automatic layout applied to control structures for visual dataflow programming languages BIBAKFull-Text 67-75
  Simon Gauvin; Omid Banyasad
Control flow within dataflow visual programming languages such as Prograph is difficult to understand due to hidden dependencies created by the control structures that desperate code blocks into independent views. We have created a model arising from research on ReactoGraph -- a derivative of Prograph -- that allows code in a general class of dataflow programming languages to be controlled based on nested graph structures. These structures, aimed at removing hidden dependencies, provide a reasonable alternative to Prograph's case control structures. However, they have also been found to introduce some usability problems such as low tolerance to code layout modification and difficulties scaling the number of code elements as nesting depth increases. In this paper we present a novel use of various software visualization techniques applied to these nested control structures in order to enable effective modification and scalability of code for improved comprehension and programming performance.
Keywords: HCI, control flow, control structures, data flow, visual language
Taxonomy of algorithm animation languages BIBAKFull-Text 77-85
  Ville Karavirta; Ari Korhonen; Lauri Malmi
In this paper, we present a taxonomy of algorithm animation languages, and apply it to evaluate a set of current languages. The taxonomy can be used by algorithm visualization system designers as a tool to compare visualization system languages with each other as well as for designing and implementing new systems and language features. In addition, the taxonomy provides guidelines to the features that are needed for transferring animations from one system to another. This is an ongoing project that supports the work started by the ITiCSE visualization working group in 2005.
Keywords: scripting languages, software visualization

Session 5

Using social agents to visualize software scenarios BIBAKFull-Text 87-94
  Thomas A. Alspaugh; Bill Tomlinson; Eric Baumer
Enabling nonexperts to understand a software system and the scenarios of usage of that system can be challenging. Visually modeling a collection of scenarios as social interactions can provide quicker and more intuitive understanding of the system described by those scenarios. This project combines a scenario language with formal structure and automated tool support (ScenarioML) and an interactive graphical game engine featuring social autonomous characters and text-to-speech capabilities. We map scenarios to social interactions by assigning a character to each actor and entity in the scenarios, and animate the interactions among these as social interactions among the corresponding characters. The social interactions can help bring out these important aspects: interactions of multiple agents, pattern and timing of interactions, non-local inconsistencies within and among scenarios, and gaps and missing information in the scenario collection. An exploratory study of this modeling's effectiveness is presented.
Keywords: ScenarioML, interactive animation, scenario analysis, social autonomous characters
Visual exploration of function call graphs for feature location in complex software systems BIBAKFull-Text 95-104
  Johannes Bohnet; Jürgen Döllner
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.
Keywords: dynamic analysis, feature analysis, feature location, program comprehension, reverse engineering, software visualization
Visualization of areas of interest in software architecture diagrams BIBAKFull-Text 105-114
  H. Byelas; A. Telea
Understanding complex software systems requires getting insight in how system properties, such as performance, trust, reliability, or structural attributes, correspond to the system architecture. Such properties can be seen as defining several 'areas of interest' over the system architecture. We visualize areas of interest atop of system architecture diagrams using a new technique that minimizes visual clutter for multiple, overlapping areas for large diagrams, yet preserves the diagram layout familiar to designers. We illustrate our proposed techniques on several UML diagrams of complex, real-world systems.
Keywords: UML diagrams, architecture visualization, areas of interest, metrics
Multiscale and multivariate visualizations of software evolution BIBAKFull-Text 115-124
  Lucian Voinea; Alexandru Telea
Software evolution visualization is a promising technique for assessing the software development process. We study how complex correlations of software evolution attributes can be made using multivariate visualization techniques. We use a combination of color and textures to depict up to four artifact attributes at the same time in one view using the same spatial layout. Next, we describe an interactive navigation method of the attribute space that can extend the correlation capabilities to four or more attributes. A second issue we address is how to use clustering to reduce the complexity of evolution visualizations. We propose two new methods, isometric and isorelevance, to generate relevant abstraction levels in a hierarchical clustering of software evolution artifacts. The isometric method generates partitions with similar size elements. The isorelevance method generates partitions with elements of similar relevance. We propose a novel widget, the cluster map, which visualizes all partitions in a clustering and supports users when making size/relevance compromises when choosing a partition. We illustrate the applicability of the proposed techniques with two usage scenarios on the evolution of two real-life industry size projects.
Keywords: CVS, evolution visualization, software visualization

Session 6

Visualizing program execution using user abstractions BIBAKFull-Text 125-134
  Steven P. Reiss
A practical system that uses visualization for understanding the execution of complex programs must offer the user views of the execution that are specific to the program being understood and the particular problem at hand without significantly slowing down or perturbing the system being examined. This paper describes a visualization data model and its implementation that accomplishes this. The model starts with program events that can be instrumented efficiently and with little overhead. It uses extended finite state automata to model program behaviors in terms of events. It builds time-varying data structures based on these automata. The data structures are then made available to various visualizations through a set of mappings that let the user dynamically control the visualization. The model and its implementation have been demonstrated on a range of specific understanding problems with a variety of different visualizations.
Keywords: dynamic software visualization, instrumentation, run-time monitoring
Mondrian: an agile information visualization framework BIBAKFull-Text 135-144
  Michael Meyer; Tudor Gîrba; Mircea Lungu
Data visualization is the process of representing data as pictures to support reasoning about the underlying data. For the interpretation to be as easy as possible, we need to be as close as possible to the original data. As most visualization tools have an internal meta-model, which is different from the one for the presented data, they usually need to duplicate the original data to conform to their meta-model. This leads to an increase in the resources needed, increase which is not always justified. In this work we argue for the need of having an engine that is as close as possible to the data and we present our solution of moving the visualization tool to the data, instead of moving the data to the visualization tool. Our solution also emphasizes the necessity of reusing basic blocks to express complex visualizations and allowing the programmer to script the visualization using his preferred tools, rather than a third party format. As a validation of the expressiveness of our framework, we show how we express several already published visualizations and describe the pros and cons of the approach.
Keywords: graph visualization, model transformation, software visualization

Challenge abstracts

3D visualisation of code structures in Java software systems BIBAFull-Text 145-146
  Alexander Fronk; Armin Bruckhoff; Michael Kern
The project ViSE3D aims at visualising in three dimensions code structures of Java software systems. We have developed several visualisation tools for code comprehension and analysis as well as for both re- and reverse-engineering purposes. 3D space allows to display a large amount of data with optimal visual ingress, and using specific layout algorithms optimises space utilisation with respect to interpretability of the code structures displayed. In this challenge report, we explore the Eclipse source code with our tool VisMOOS.
How do changes in buggy Mozilla files propagate? BIBAKFull-Text 147-148
  Lucian Voinea; Alexandru Telea
We demonstrate the use of the CVSgrab tool for assessing change propagation in the Open Source browser Firefox.
Keywords: CVS, evolution visualization, software visualization

Poster abstracts

A tool for visualizing schemas for semistructured data BIBAFull-Text 149-150
  John Hosking; Nodira Khoussainova; Gillian Dobbie
We describe a tool that permits modelling and visualization of schemas for semistructured data using the ORA-SS notation. The tool supports multiple overlapping views of an ORA-SS model providing schema generation and normal form checking.
A transparent interface to state-space search programs BIBAKFull-Text 151-152
  Steven L. Tanimoto; Stefano Levialdi
We present a visual interface for a variety of programs that employ state-space search methods. The interface displays a tree of the states visited so far, and it permits user interaction through manipulation of the tree. The interface is implemented in a domain-independent Python module. We give illustrations of its application in three domains: classical problem solving, image processing, and composition of musical motifs. The interface exemplifies a class of techniques for bringing a form of transparency to computer systems.
Keywords: collaborative problem solving, computer-aided design, interactive search, state-space search, transparent interface, tree layout
A visualization software for the network simplex algorithm BIBAFull-Text 153-154
  Thanasis Baloukas; Konstantinos Paparrizos
The teaching experiences of the network simplex algorithm to postgraduate students at our department, lead us to develop a visualization software which aims to support the instructor in his effort to explain the algorithm to the students. In addition we believe that the software will help students in their endeavor to understand the aforementioned algorithm which is quite complex, as it involves many concurrent mathematical and visual transformations.
Adding procedures and pointers to the ALVIS algorithm visualization software: a preliminary design BIBAKFull-Text 155-156
  Christopher D. Hundhausen; Jonathan L. Brown; Sean Farley
Since the late 1990s, we have been developing ALVIS, a new breed of algorithm visualization software that supports a novel, "studio based" approach to teaching introductory programming. In this approach, students, working in pairs, use the ALVIS software to construct their own algorithmic solutions to appropriate algorithm design problems. ALVIS automatically generates accompanying algorithm visualizations, which students can augment with their own visual and storytelling elements prior to presenting them to their peers and instructor for feedback and discussion. We believe the pedagogical value of this approach rests in students' active engagement in constructing and subsequently discussing their algorithmic solutions. Previous versions of the ALVIS software have enabled students to create only single-procedure, array iterative algorithms. We describe here our preliminary work toward expanding ALVIS so that it supports parameterized procedures and pointers. Our ultimate aim is to explore the pedagogical value of using ALVIS as the basis of an entire "studio based" introductory programming course for students without prior programming experience.
Keywords: algorithm visualization, studio-based algorithms course
Animation of control flow for low-level debugging BIBAFull-Text 157-158
  Hao Liu; Feodor Vainstein
The animation of control flow in execution was proposed as the complement to regular binary code debugging tools. It helps users access programs' dynamic information in an intuitive way. A framework called "WYSIWIR" (What You See Is What Is Running) and its 0x86 implementation are introduced in this paper. The preliminary results are quite encouraging.
Drawing activity diagrams BIBAFull-Text 159-160
  Martin Siebenhaller; Michael Kaufmann
Activities and the corresponding activity diagrams belong to the basic concepts of the Unified Modeling Language (UML) which has become the standard modeling language for specifying, visualizing and documenting software systems. Activity diagrams are used for modeling behavioral logic like business processes or workflow. In the modern UML 2, they experienced an increasing importance. While they were considered as a special case of state diagrams in UML 1.x, they are now enriched with additional constructs that widens the range of their applicability. This make them more suitable for areas like economics or bio-informatics.
Evaluating X3D for use in software visualization BIBAKFull-Text 161-162
  Craig Anslow; Stuart Marshall; James Noble; Robert Biddle
There are many technologies that have varying capabilities that could be used to help understand software through visualizations. Determining which technology is best suited for the development and delivery of a particular type of software visualization can be a complex task. We have evaluated the Web3D Consortium's X3D specification -- the open standard for web-based 3D graphics -- against some taxonomies of the types of graphical representations for software visualization. Our evaluation shows that X3D can support the development and delivery of visualizations that people use to understand the structure and behaviour of software.
Keywords: X3D, evaluation, software visualization, web-based 3D graphics
Evolutionary layout of UML class diagrams BIBAKFull-Text 163-164
  J. Wolff v. Gudenberg; A. Niederle; M. Ebner; H. Eichelberger
An evolutionary algorithm that layouts UML class diagrams is developed and described. It evolves the layout by mutating the positions of class symbols, inheritance relations, and associations. The process is controlled by a fitness function that is computed from several well-known and some new layout metrics.
Keywords: UML class diagrams, evolutionary algorithms, graph drawing, layout metrics
Evolutionary layout: preserving the mental map during the development of class models BIBAFull-Text 165-166
  Susanne Jucknath-John; Dennis Graf; Gabriele Taentzer
It is vital for any developer to keep track of changes during his project. Thus, it is common practice to take static snapshots of single class diagrams. But to preserve the mental map, the layout of a class diagrams sequence is necessary.
   Therefore, we present in this paper requirements to layout a sequence of class diagrams and an approach for a layout algorithm to fulfill them. Our main idea was to see a sequence of class diagrams as the evolution of one graph over time. We expressed the graph's evolution via a graph transformations sequence and enriched this with the concept of node aging. We extended also the well-known spring-embedder layout algorithm to layout single graphs from this new sequence with the concept of layout pattern to integrate a-priori-knowledge. The resulting algorithm has been integrated into the AGG-Tool, an environment for Attributed Graph Grammars, and produced good results on various class diagrams and general graph grammars.
Icon graphs: visualizing the evolution of large class models BIBAFull-Text 167-168
  Susanne Jucknath-John; Dennis Graf
Most models are expressed and visualized with UML nowadays and most UML diagrams are based on graphs. Such graphs can get quite large if a project contains more than 600 class files, which is not uncommon. But changes are hard to recognize in a graph with 600 nodes. Therefore, the user has to find a way to build his own mental map based on the original graph. This mental map should give an overview of the original graph size, structure and it should point to changed areas.
   We present in this paper an approach, which gives the user a smaller graph as a mental map. This smaller graph uses packages as foundations for nodes and displays the package's content as the node icon. This had be done beforehand to visualize the evolution of developer dependencies over time, where the node icon presented the package's developer information as a pie chart. A suitable icon to present a package's class diagram can be a smaller version of the class diagram itself, if the layout respects its predecessors to allow the user an overview of its evolution.
Intentional MPI programming in a visual development environment BIBAKFull-Text 169-170
  Donald P. Pazel; Beth R. Tibbitts
BladeRunner is a research project that explores the use of intentional and code generative approaches to facilitate programming in MPI (Message Passing Interface) for parallel and distributed programming. The BladeRunner development environment provides an interactive visual approach based on figures representing higher level abstractions of MPI artifacts. This, along with direct manipulation of visual abstractions, allows the user to both view and express coding intentions clearly and rapidly. As a constructive programming paradigm, direct manipulation of figures translates into coding actions reflected into generated program code. Thus, programming focus is higher level, on visual representations for MPI programming concepts, and evolution of program state reflected in diagrams, instead of syntax or language structure details.
   We describe the BladeRunner prototype tool, built upon the Eclipse open-source platform, and discuss the vision for this work.
Keywords: MPI, cluster computing, code generation, eclipse, high performance computing, intentional programming, model-driven programming, parallel programming
Lightweight visualizations for inspecting code smells BIBAKFull-Text 171-172
  Chris Parnin; Carsten Görg
In this paper we present an approach for using lightweight visualizations to inspect bad coding patterns. We demonstrate how our Visual Studio plugin assists developers in finding relevant methods to inspect.
Keywords: code smells, quality assurance, software visualization
Metaphor-based animation of OO programs BIBAKFull-Text 173-174
  Jorma Sajaniemi; Pauli Byckling; Petri Gerdt
Program visualization and animation have traditionally been done at the level of programming language implementation, or by using some formal graphical notation, e.g., UML; both of which are unfamiliar to novices. We present a metaphor approach to animating object-oriented programs with the goal to provide novices with visually rich visualizations that can develop and consolidate a valid mental model of object-orientation. For this purpose, we introduce new metaphors for such concepts as class, object, object instantiation, method invocation, parameter passing, and object reference. These metaphors are used in a system that provides the animation of a few, carefully selected OO programs for educational use.
Keywords: metaphor, object-oriented programming, program animation
Novel algorithm explanation techniques for improving algorithm teaching BIBAFull-Text 175-176
  Andreas Kerren; Tomasz Müldner; Elhadi Shakshuki
The analysis and the understanding of algorithms is a very important task for teaching and learning algorithms. We advocate a strategy, according to which one first tries to understand the fundamental nature of an algorithm, and then -- after reaching a higher level of awareness -- chooses the most appropriate programming language to implement it. To facilitate the process of understanding of algorithms, their visualization, in particular animation, is considered to be the best approach. Traditional Algorithm Animation (AA) systems usually aim for teaching algorithms in higher education, see for example the chapter introduction of Kerren and Stasko [2002] or the earlier anthology on software visualization [Stasko et al. 1998].
Semantic web data visualization with graph style sheets BIBAKFull-Text 177-178
  Emmanuel Pietriga
Visual paradigms such as node-link diagrams are well suited to the representation of Semantic Web data encoded with the Resource Description Framework (RDF), whose data model can be seen as a directed labeled graph. However, these representations are not fully satisfying: diagrams can quickly become big and over-cluttered, making them hard to understand. This problem can be partly addressed by visually transforming the graphs: filtering information, providing alternative layouts for specific elements, and using all available visual variables to encode information, so as to better take advantage of human perceptual abilities. Graph Style Sheets have been designed for that purpose, allowing the filtering, grouping and styling of information elements through the specification of declarative transformation rules.
Keywords: graph drawing, semantic web, style sheets
Softwarenaut: cutting edge visualization BIBAFull-Text 179-180
  Mircea Lungu; Michele Lanza
Many reverse engineering and program understanding tools support the static analysis of large software systems by providing exploratory analysis and visualization services. Most of these tools use graph-based representations, in which entities are represented as nodes and dependencies between them as edges.
The effect of comparison cueing and exchange motion on comprehension of program visualizations BIBAKFull-Text 181-182
  Bina Reed; Philippa Rhodes; Eileen Kraemer; Elizabeth Thorpe Davis; Kenneth Hailston
We describe an experiment that evaluates the effect of two attributes of an algorithm animation: presence of cueing (flashing) to indicate to the viewer that two data elements have been compared, and type of animation (arcing move or grow/shrink) to indicate that two data elements have exchanged values. We evaluate the impact of these attributes both on perception of the animated changes and on viewer comprehension of the depicted algorithm, as measured by the number of correctly answered questions in two question sets: "traditional" (comprehension) questions and "popup" (perception) questions. No significant effect on comprehension was observed for either flash cueing or exchange motion, though we note that comparison and exchange behaviors were redundantly cued in the animation studied. Significant effects were found for flash cueing and "move" versus "grow" in the perceptual questions displayed in popup windows.
Keywords: empirical study, perceptual attributes, program visualization
The importance of interactive questioning techniques in the comprehension of algorithm animations BIBAKFull-Text 183-184
  Philippa Rhodes; Eileen Kraemer; Bina Reed
The purpose of the study presented in this paper is to analyze the usefulness of various types of pop-up questions used in algorithm animations. Preliminary analysis indicates that providing feedback to pop-up questions increases the participant's ability to correctly answer both pop-up questions and regular test questions while the form of interaction required of the user via pop-up questions lessens the overall performance, though not significantly.
Keywords: algorithm animation, effectiveness, experimentation, software visualization
Time travelling animated program executions BIBAKFull-Text 185-186
  Ken Kahn
Visualizations of program executions are often generated on the fly. This has many advantages relative to off-line generation of animated video files. Video files, however, trivially support flexible viewing via controls that include reverse and fast forward. Here we report on an implementation of time travel that combines the best of both techniques.
   In ToonTalk both the construction and execution of programs are animated. Time travel enables the user to move back in time and replay animated executions. The replay can be paused and the user can skip forward or further back in time. The implementation of time travel is based records of every input event and periodic snapshots of the state of the computation.
Keywords: ToonTalk, program visualization, programming languages for children, time travel
Towards empirically validated software architecture visualization BIBAKFull-Text 187-188
  Jens Knodel; Dirk Muthig; Matthias Naab; Dirk Zeckzer
Visualization is a sound means to facilitate understanding of complex correlations and offers a broad variety of concepts. A problem with the visualization of software architectures is that there are almost no empirical evidences of the benefits of particular visualization concepts. That is why we introduce an approach that explicitly integrates architecture development with the selection, use and validation of visualization metaphors. We successfully applied this approach to realize our software architecture visualization tool and empirically validated the use of the visualization concepts in the software architecture domain. We claim that software architecture visualizations should always be thoroughly assessed, especially by software architects in an industrial environment.
Keywords: SAVE, eclipse, graphical elements, program comprehension, software architecture, software visualization
TrustNeighborhoods in a nutshell BIBAKFull-Text 189-190
  Niklas Elmqvist; Philippas Tsigas
In this short paper, we review the TrustNeighborhoods system for 2D and 3D visualization of trust relationships on the Internet for novice and intermediate-level users. Intended to convey a tangible mental model of security, the system is based on the concept of "circles of relationship" as a model for computer usage proposed by Ben Shneiderman, and uses a strong visual metaphor of a multi-layered city or fortress representing the computer network. Trust relationships are shown using an intuitive geographic relation. The tool has both 2D and 3D modes, one intended for configuration and trust management, the other for non-intrusive situational awareness of security for the local computer.
Keywords: security visualization, trust visualization
Two-dimensional C++ BIBAFull-Text 191-192
  Johannes Reichardt
The present visual language supports the imperative programming style and claims to improve program comprehension by resemblance. It can be characterized as follows: 1) Its scope is the static description of code, data and flow control as well as of the surrounding architecture including classes, components, modules, up to systems. 2) Its abstraction level is next to that of C++ including templates and the standard template library and allows straight-forward code generation. 3) The visualization is specified by editing boxes, bars, arrows and textual labels on a drawing area with relatively fixed editing positions. 4) The interface of the visualization is the drawing area itself, enabling further editing or navigating through the program by clicking on the bars, boxes and labels or by defining views via textual or topological queries. 5) The presentation of the visualization is by a (still hypothetical) wall-projection of the virtual drawing area.
Visual snippet editor BIBAFull-Text 193-194
  P. R. Giffen; Andrée Proulx; Jinsil Boo
Visual editors play an important part in business application tooling. A rich visual notation was developed for a set of visual editors included as part of integration application development tooling (IBM® Websphere® Integration Developer 6.0).The Visual Snippet Editor includes unique visual notation to help create code snippets. The snippets are laid out automatically by the editor. Some of the distinguishing visual elements are the grouping arrangement, the shape of the terminals and activities, the syntax color, the icons and the appearance of all first class element and their behaviour.
Visualized adaptive runtime subsystems BIBAFull-Text 195-196
  Jeremy Singer; Chris Kirkham
Virtual execution platforms contain many runtime subsystems that are invoked on-demand as user code executes. We have instrumented an open-source JVM to dump out information on these runtime subsystems, in order to examine how they are used. The monitored components are known as visualized adaptive runtime subsystems. The visualizations in this poster demonstrate five interesting properties of such runtime subsystems.
WADEIn II: adaptive explanatory visualization for expressions evaluation BIBAKFull-Text 197-198
  Tomasz D. Loboda; Peter Brusilovsky
Adaptive visualization and explanatory visualization have been suggested as two approaches to increasing the educational effectiveness of software visualization. This paper presents our work on the integration of adaptive and explanatory visualization. We introduce the motivation behind this research and describe how adaptive, explanatory visualization is implemented in WADEIn II, a system that visualizes the process of expression evaluation in the C programming language.
Keywords: adaptive explanations, adaptive visualization, expression evaluation, program visualization, user modeling