%M C.SV.08.7
%T Visualization for information exploration and analysis
%S Keynote
%A Stasko, John
%B Proceedings of the ACM Symposium on Software Visualization
%D 2008
%P 7-8
%* (c) Copyright 2008 ACM
%W http://doi.acm.org/10.1145/1409720.1409721
%X Making sense of data becomes more challenging as the data grows larger and
becomes more complex. If a picture truly can be worth a thousand words, then
clever visualizations of data should hold promise in helping people with
sense-making tasks. I firmly believe that visual representations of data can
help people to better explore, analyze, and understand it, thus transforming
the data into information. In this talk, I will explain how visualization and
visual analytics help people make sense of data and I will provide many such
examples. I also will describe my present research into visualization for
investigative analysis. This project explores how visual analytics can help
investigators examine a large document collection in order to discover embedded
stories and narratives scattered across the documents in the collection.

%M C.SV.08.9
%T Assessing the benefits of synchronization-adorned sequence diagrams: two
controlled experiments
%S Software visualization for understanding
%A Xie, Shaohua
%A Kraemer, Eileen
%A Stirewalt, R. E. K.
%A Dillon, Laura K.
%A Fleming, Scott D.
%B Proceedings of the ACM Symposium on Software Visualization
%D 2008
%P 9-18
%K UML, concurrency and synchronization, empirical evaluation
%* (c) Copyright 2008 ACM
%W http://doi.acm.org/10.1145/1409720.1409723
%X Learning about concurrency and synchronization is difficult for novices. In
prior work, we developed saUML, a refinement of UML sequence diagrams, to
address these difficulties and found them to be beneficial when compared to
text-only presentations. This paper compares saUML to standard UML sequence
diagrams to judge their relative effectiveness in enhancing a novice
programmer's understanding of programs with different levels of synchronization
complexity. One experiment compared the two notations when used to understand
programs of low synchronization complexity, as judged by their use of only
simple synchronization primitives, such as mutex locks. Here, a beneficial
trend was observed, but it did not rise to the level of statistical
significance. A second experiment compared the two notations on similar tasks
but on programs with more complex synchronization constructs, in this case
condition synchronization using primitives, such as wait and signal. Here, a
significant benefit (p < 0.05) was found to exist.

%M C.SV.08.19
%T Visualization of exception handling constructs to support program
understanding
%S Software visualization for understanding
%A Shah, Hina
%A Görg, Carsten
%A Harrold, Mary Jean
%B Proceedings of the ACM Symposium on Software Visualization
%D 2008
%P 19-28
%K Eclipse plugin, exception handling, interactive visualization, multiple
views, program understanding
%* (c) Copyright 2008 ACM
%W http://doi.acm.org/10.1145/1409720.1409724
%X This paper presents a new visualization technique for supporting the
understanding of exception-handling constructs in Java programs. To understand
the requirements for such a visualization, we surveyed a group of software
developers, and used the results of that survey to guide the creation of the
visualizations. The technique presents the exception-handling information using
three views: the quantitative view, the flow view, and the contextual view. The
quantitative view provides a high-level view that shows the throw-catch
interactions in the program, along with relative numbers of these interactions,
at the package level, the class level, and the method level. The flow view
shows the type-throw-catch interactions, illustrating information such as which
exception types reach particular throw statements, which catch statements
handle particular throw statements, and which throw statements are not caught
in the program. The contextual view shows, for particular type-throw-catch
interactions, the packages, classes, and methods that contribute to that
exception-handling construct. The paper also presents a case study in which we
evaluated a prototype of the visualization system on a small set of developers.

%M C.SV.08.29
%T Visual analysis of importance and grouping in software dependency graphs
%S Software visualization for understanding
%A Pich, Christian
%A Nachmanson, Lev
%A Robertson, George G.
%B Proceedings of the ACM Symposium on Software Visualization
%D 2008
%P 29-32
%K analysis, graph layout, large graphs, multidimensional scaling, ranking,
visualization
%* (c) Copyright 2008 ACM
%W http://doi.acm.org/10.1145/1409720.1409725
%X Understanding dependencies between components is a key task in software
engineering. We present a method for the display and visual analysis of
dependency graphs occurring in large software systems. Our layout approach
takes into account similarity and importance of the system components and
additional grouping information; using efficient algorithms based on linear
algebra, it scales to very large dependency graphs. We apply our method to two
real-world software systems and present the results.

%M C.SV.08.33
%T Algorithm visualization using concrete and abstract shape graphs
%S Software visualization for understanding
%A Parduhn, Sascha A.
%A Seidel, Raimund
%A Wilhelm, Reinhard
%B Proceedings of the ACM Symposium on Software Visualization
%D 2008
%P 33-36
%K algorithm animation, algorithm visualisation, invariants, shape analysis,
shape graphs
%* (c) Copyright 2008 ACM
%W http://doi.acm.org/10.1145/1409720.1409726
%X Traditional algorithm animation attempts to provide visualizations of the
execution of a program on concrete data. In recent years a different approach
has been proposed which attempts to visualize an "abstract execution" on
"abstract data." This is based on Cousots' notion of abstract interpretations,
in particular in the case of programs manipulating pointer structures this is
based on so-called shape analysis. Shape analysis maps all possible heap
configurations that can arise during a program's executions (a potentially
unbounded set) to a finite number of "shape graphs" and it maps steps of the
program to transitions between shape graphs. Every concrete execution of the
program then corresponds to a sequence of transitions among shape graphs, the
"abstract execution." Visualizing such an abstract execution is desirable since
sets of shape graphs in a very strong sense encode invariants of the program
and understanding the effect of a program usually benefits more from grasping
what stays invariant than from seeing what changes.
   In this paper we combine the two approaches and argue for simultaneously
visualizing a concrete and the corresponding abstract execution of a program.
We have built a Visualizer for programs manipulating pointer structures that
realizes this combined abstract/concrete visualization. It uses TVLA to
automatically perform the shape analysis of a program. It allows to present
abstract and concrete views in an extremely customizable way. This paper
however does not present our Visualizer, but focuses on the technique to
combine concrete and abstract visualizations.

%M C.SV.08.37
%T Analyzing the reliability of communication between software entities using a
3D visualization of clustered graphs
%S Software visualization for testing and debugging
%A Zeckzer, D.
%A Kalcklösch, R.
%A Schröder, L.
%A Hagen, H.
%A Klein, T.
%B Proceedings of the ACM Symposium on Software Visualization
%D 2008
%P 37-46
%K force-directed layout, gossip-based protocol, software analysis, software
visualization
%* (c) Copyright 2008 ACM
%W http://doi.acm.org/10.1145/1409720.1409728
%X Modern software systems are typically composed of a large number of
components, and more and more functionality is realized through the
communication between these components. In this paper, we present an approach
that enables assessing the reliability of the components and the communication
between them. A protocol for testing the communication is presented and applied
to several systems. After the execution of this protocol, an error rate is
known for each component and each communication link of the system. This
information is transformed into a graph containing the information about the
components and their known communication relations. Finally, these graphs are
analyzed using a 3D visualization based on a clustered force-directed layout.
Major benefits of this approach include a method for assessing the reliability
of components that are not directly accessible and a visualization that
optimally supports the analysis of graphs in this application domain.

%M C.SV.08.47
%T HDPV: interactive, faithful, in-vivo runtime state visualization for C/C++
and Java
%S Software visualization for testing and debugging
%A Sundararaman, Jaishankar
%A Back, Godmar
%B Proceedings of the ACM Symposium on Software Visualization
%D 2008
%P 47-56
%K object viewer, software visualization
%* (c) Copyright 2008 ACM
%W http://doi.acm.org/10.1145/1409720.1409729
%X Data structure visualization can increase program understanding in an
educational context and help with visual debugging. Existing data structure
visualization tools are limited in interactivity, providing mostly static
views; flexibility, by restricting the layout strategies users can apply;
scope, by focusing on only a single language; and fidelity, by abstracting away
the actual runtime layout and size of a program's data. This paper presents the
design and implementation of HDPV, a system for interactive, faithful, in-vivo
runtime state visualization for native C/C++ programs and Java programs. We
discuss how HDPV can be used for a number of use cases ranging from
understanding simple, recursive programs, to understanding the visual effect of
programming errors such as buffer overflows.

%M C.SV.08.57
%T Representing unit test data for large scale software development
%S Software visualization for testing and debugging
%A Cottam, Joseph A.
%A Hursey, Joshua
%A Lumsdaine, Andrew
%B Proceedings of the ACM Symposium on Software Visualization
%D 2008
%P 57-66
%K MPI, project management, testing, visualization
%* (c) Copyright 2008 ACM
%W http://doi.acm.org/10.1145/1409720.1409730
%X Large scale software projects rely on routine, automated testing to gauge
progress towards its goals. The diversity and quantity of these tests grow as
time and project scope increase. This is as a consequence of both experience
and expanding audience. It becomes increasingly difficult to interpret testing
results as the testing suites multiply and diversify. If interpretation becomes
too difficult, testings results could become ignored all together.
Visualization has proven to be an effective tool to aid the interpretation of
large amounts of data. We have adapted visualization techniques based on small
multiples to communicate the health of the software project across several
levels of abstraction. The collective set of techniques we refer to as the
SeeTest visualization schema. We applied this visualization technique to the
Open MPI test results in order to assist developers in the software release
cycle. Through the visualizations, developers found a variety of surprising
mismatches between their data and their intuitions. This exploration did not
involve collecting any data not already being collected, merely presenting it
in manner that better supported their needs. In this paper, we detail the
development of the representation we used and give more particular analysis of
the insights gained by the Open MPI community. The techniques presented in this
paper can be applied to other software projects.

%M C.SV.08.67
%T An interactive reverse engineering environment for large-scale C++ code
%S Software visualization for maintenance
%A Telea, Alexandru
%A Voinea, Lucian
%B Proceedings of the ACM Symposium on Software Visualization
%D 2008
%P 67-76
%* (c) Copyright 2008 ACM
%W http://doi.acm.org/10.1145/1409720.1409732
%X Few toolsets for reverse-engineering and understanding of C++ code provide
parsing and fact extraction, querying, analysis and code metrics, navigation,
and visualization of source-code-level facts in a way which is as easy-to-use
as integrated development environments (IDEs) are for forward engineering. We
present an interactive reverse-engineering environment (IRE) for C and C++
which allows to set up the fact extraction process, apply user-written queries
and metrics, and visualize combined query results, metrics, code text, and code
structure. Our IRE tightly couples a fast, tolerant C++ fact extractor, an open
query system, and several scalable dense-pixel visualizations in a novel way,
offering an easy way to analyze and examine large code bases. We illustrate our
IRE with several examples, focusing on the added value of the integrated,
visual reverse-engineering approach.

%M C.SV.08.77
%T A catalogue of lightweight visualizations to support code smell inspection
%S Software visualization for maintenance
%A Parnin, Chris
%A Görg, Carsten
%A Nnadi, Ogechi
%B Proceedings of the ACM Symposium on Software Visualization
%D 2008
%P 77-86
%K code inspection, code smells, lightweight visualization, refactoring
%* (c) Copyright 2008 ACM
%W http://doi.acm.org/10.1145/1409720.1409733
%X Preserving the integrity of software systems is essential in ensuring future
product success. Commonly, companies allocate only a limited budget toward
perfective maintenance and instead pressure developers to focus on implementing
new features. Traditional techniques, such as code inspection, consume many
staff resources and attention from developers. Metrics automate the process of
checking for problems but produce voluminous, imprecise, and incongruent
results. An opportunity exists for visualization to assist where automated
measures have failed; however, current software visualization techniques only
handle the voluminous aspect of data but fail to address imprecise and
incongruent aspects. In this paper, we describe several techniques for
visualizing possible defects reported by automated inspection tools. We propose
a catalogue of lightweight visualizations that assist reviewers in weeding out
false positives. We implemented the visualizations in a tool called NOSEPRINTS
and present a case study on several commercial systems and open source
applications in which we examined the impact of our tool on the inspection
process.

%M C.SV.08.87
%T Classifying desirable features of software visualization tools for
corrective maintenance
%S Software visualization for maintenance
%A Sensalire, Mariam
%A Ogao, Patrick
%A Telea, Alexandru
%B Proceedings of the ACM Symposium on Software Visualization
%D 2008
%P 87-90
%* (c) Copyright 2008 ACM
%W http://doi.acm.org/10.1145/1409720.1409734
%X We provide an evaluation of 15 software visualization tools applicable to
corrective maintenance. The tasks supported as well as the techniques used are
presented and graded based on the support level. By analyzing user acceptation
of current tools, we aim to help developers to select what to consider, avoid
or improve in their next releases. Tool users can also recognize what to
broadly expect (and what not) from such tools, thereby supporting an informed
choice for the tools evaluated here and for similar tools.

%M C.SV.08.91
%T Cluster analysis of Java dependency graphs
%S Software visualization for maintenance
%A Dietrich, Jens
%A Yakovlev, Vyacheslav
%A McCartin, Catherine
%A Jenson, Graham
%A Duchrow, Manfred
%B Proceedings of the ACM Symposium on Software Visualization
%D 2008
%P 91-94
%K anti-pattern detection, cluster analysis, dependency analysis, refactoring
%* (c) Copyright 2008 ACM
%W http://doi.acm.org/10.1145/1409720.1409735
%X We present a novel approach to the analysis of dependency graphs of
object-oriented programs. We propose to use the Girvan-Newman clustering
algorithm to compute the modular structure of programs. This is useful in
assisting software engineers to redraw component boundaries in software, in
order to improve the level of reuse and maintainability. The results of this
analysis can be used as a starting point for refactoring the software. We
present BARRIO, an Eclipse plugin that can detect and visualise clusters in
dependency graphs extracted from Java programs by means of source code and byte
code analysis. These clusters are then compared with the modular structure of
the analysed programs defined by package and container specifications. Two
metrics are introduced to measure the degree of overlap between the defined and
the computed modular structure. Some empirical results obtained from analysing
non-trivial software packages are presented.

%M C.SV.08.95
%T Gef3D: a framework for two-, two-and-a-half-, and three-dimensional
graphical editors
%S Software visualization interaction and layout
%A von Pilgrim, Jens
%A Duske, Kristian
%B Proceedings of the ACM Symposium on Software Visualization
%D 2008
%P 95-104
%K 3D visualization, graphical editing
%* (c) Copyright 2008 ACM
%W http://doi.acm.org/10.1145/1409720.1409737
%X Three-dimensional software visualization is a commonly used and very helpful
approach when two-dimensional representations of complex systems become too
cluttered. But 3D visualizers usually are developed separately from existing
development tools. Often they do not allow editing of the displayed models
which may be desirable in many cases, as for example in model driven
development (MDD), in which models are first class artifacts.
   With Gef3D we present a 3D framework which is based on the widely used
two-dimensional graphical editing framework Eclipse GEF. It enhances this
framework, enabling programmers to easily implement 3D editors. Furthermore
existing 2D editors can be adapted to be used in 3D multi editors by projecting
the 2D content on planes. In this article we explain the architecture and
certain design patterns of Gef3D in order to give researchers and developers
interested in 3D software visualization an overview of how to use GEF3D and of
the features provided by the framework. We show how Gef3D is applied to embed
an existing UML class editor into a 3D editor, and present a special use case:
the visualization of traces in the area of MDD.

%M C.SV.08.105
%T Automatic layout of UML use case diagrams
%S Software visualization interaction and layout
%A Eichelberger, Holger
%B Proceedings of the ACM Symposium on Software Visualization
%D 2008
%P 105-114
%K UML, automatic layout algorithms, drawing rules, model-driven development,
use case diagrams
%* (c) Copyright 2008 ACM
%W http://doi.acm.org/10.1145/1409720.1409738
%X Model-based and model-driven development will receive increased attention in
future software production processes. Currently, UML and the related Model
Driven Architecture attract lot of interest in this area, but so far most tools
rely on manual visualization techniques and only few tools support automatic
visualizations e.g. of intermediary transformation results to support the
understanding and debugging of model-driven transformation processes. Aside
from structural models or control flow specifications, in particular UML use
case diagrams are frequently used to visualize high level views on system
functionality and are also considered as source and target models in upcoming
model-driven production chains. To support use case diagrams in future software
development, in this paper we present guidelines for the layout of UML use case
diagrams, a deterministic layout algorithm supporting these guidelines and a
prototypical implementation of the algorithm.

%M C.SV.08.115
%T Improving an interactive visualization of transition systems
%S Software visualization interaction and layout
%A Ploeger, Bas
%A Tankink, Carst
%B Proceedings of the ACM Symposium on Software Visualization
%D 2008
%P 115-124
%K 3D visualization, cone trees, graph drawing, transition systems
%* (c) Copyright 2008 ACM
%W http://doi.acm.org/10.1145/1409720.1409739
%X A transition system can be used to model the behaviour of a software system.
A popular way of analysing this behaviour is by studying the corresponding
transition system. An interactive visualization technique for showing the
global structure of a transition system has been proposed by Van Ham et al.
This technique clusters states and forms these clusters into a 3D structure
similar to a cone tree, with the emphasis on symmetry. The technique has been
used by analysts to study real-world systems. In this paper we solve a number
of problems related to the symmetry of the visual representation and the
misrepresentation of cluster sizes. This results in more effective and less
misleading visualizations. In addition, we also extend the original technique
by providing simulation facilities and a more effective state and cluster
marking technique. These enhance the way in which a user can interact with the
visualization.

%M C.SV.08.125
%T Streamsight: a visualization tool for large-scale streaming applications
%S Joint paper session with VL/HCC
%A De Pauw, Wim
%A Andrade, Henrique
%A Amini, Lisa
%B Proceedings of the ACM Symposium on Software Visualization
%D 2008
%P 125-134
%K distributed processing, dynamic visualization, stream processing
visualization, visualizing topologies
%* (c) Copyright 2008 ACM
%W http://doi.acm.org/10.1145/1409720.1409741
%X Stream processing is becoming a new and important computing paradigm.
Innovative streaming applications are being developed in areas ranging from
scientific applications (e.g., environment monitoring), to business
intelligence (e.g., fraud detection and trend analysis), to financial markets
(e.g., algorithmic trading strategies). Developing, understanding, debugging,
and optimizing streaming applications is non-trivial because of the adaptive
and dynamic nature of these applications. The sheer complexity and the
distributed character of a large number of cooperating components hosted on a
distributed environment further complicate matters. In this paper we describe
Streamsight, a new visualization tool built to examine, monitor, and help
understand the dynamic behavior of streaming applications. Previously developed
stream processing visualization tools focus solely on composition of dataflow
graphs. Streamsight's novelty hinges on a wide range of capabilities, including
the ability to manage the dynamics of large and evolving topologies comprising
multiple streaming applications with thousands of nodes and interconnections.
From rendering live performance counters using different perspectives to
allowing recordings and replays of the execution process, Streamsight provides
the mechanisms that permit a better understanding of the evolving and adaptive
behavior of streaming applications. These capabilities are used for debugging
purposes, for performance optimization, and management of resources, including
capacity planning. More than 50 developers, both inside and outside IBM, have
been using Streamsight.

%M C.SV.08.135
%T Software visualization for end-user programmers: trial period obstacles
%S Joint paper session with VL/HCC
%A Subrahmaniyan, Neeraja
%A Burnett, Margaret
%A Bogart, Christopher
%B Proceedings of the ACM Symposium on Software Visualization
%D 2008
%P 135-144
%K end-user software engineering, software adoption, software visualization,
spreadsheets
%* (c) Copyright 2008 ACM
%W http://doi.acm.org/10.1145/1409720.1409742
%X Software visualization for end-user programmers is a relatively unexplored
opportunity area. There are advances in software visualization research
pertinent to this, but the adoption stage has been entirely ignored. In this
paper, we focus on a popular facilitator of adoption decisions: the free trial
period. We conducted a case study of an end-user programmer (an accountant) in
this situation, as she tried out a commercial spreadsheet visualization tool to
make an adoption decision. The results have implications for both theory and
design, revealing open questions, design opportunities, and strengths and
weaknesses of theoretical foundations.

%M C.SV.08.145
%T Visualizing inter-dependencies between scenarios
%S Software visualization for design
%A Harel, David
%A Segall, Itai
%B Proceedings of the ACM Symposium on Software Visualization
%D 2008
%P 145-153
%* (c) Copyright 2008 ACM
%W http://doi.acm.org/10.1145/1409720.1409744
%X One of the main challenges in understanding a scenario-based specification
of a reactive system is rooted in the inter-dependencies between the scenarios.
These are inherently implicit in the very idea of scenario-based programming.
We introduce a graph-based visualization of such inter-dependencies, and
implement it in a tool we call SIV (for Scenario Inter-dependency
Visualization), which supplies many options for exploration of these graphs.

%M C.SV.08.155
%T Visually localizing design problems with disharmony maps
%S Software visualization for design
%A Wettel, Richard
%A Lanza, Michele
%B Proceedings of the ACM Symposium on Software Visualization
%D 2008
%P 155-164
%K software design anomalies, software visualization
%* (c) Copyright 2008 ACM
%W http://doi.acm.org/10.1145/1409720.1409745
%X Assessing the quality of software design is difficult, as "design" is
expressed through guidelines and heuristics, not rigorous rules. One successful
approach to assess design quality is based on detection strategies, which are
metrics-based composed logical conditions, by which design fragments with
specific properties are detected in the source code. Such detection strategies,
when executed on large software systems usually return large sets of artifacts,
which potentially exhibit one or more "design disharmonies", which are then
inspected manually, a cumbersome activity.
   In this article we present disharmony maps, a visualization-based approach
to locate such flawed software artifacts in large systems. We display the whole
system using a 3D visualization technique based on a city metaphor. We enrich
such visualizations with the results returned by a number of detection
strategies, and thus render both the static structure and the design problems
that affect a subject system. We evaluate our approach on a number of
open-source Java systems and report on our findings.

%M C.SV.08.165
%T Stacked-widget visualization of scheduling-based algorithms
%S Software visualization for design
%A Bernardin, Tony
%A Budge, Brian C.
%A Hamann, Bernd
%B Proceedings of the ACM Symposium on Software Visualization
%D 2008
%P 165-174
%K data visualization, information visualization, out-of-core management, task
scheduling
%* (c) Copyright 2008 ACM
%W http://doi.acm.org/10.1145/1409720.1409746
%X We present a visualization system to assist designers of scheduling-based
multi-threaded out-of-core algorithms. Our system facilitates the understanding
and improving of the algorithm through a stack of visual widgets that
effectively correlate the out-of-core system state with scheduling decisions.
The stack presents an increasing refinement in the scope of both time and
abstraction level; at the top of the stack, the evolution of a derived
efficiency measure is shown for the scope of the entire out-of-core system
execution and at the bottom the details of a single scheduling decision are
displayed. The stack provides much more than a temporal zoom-effect as each
widget presents a different view of the scheduling decision data, presenting
distinct aspects of the out-of-core system state as well as correlating them
with the neighboring widgets in the stack. This approach allows designers to to
better understand and more effectively react to problems in scheduling or
algorithm design.
   As a case study we consider a global illumination renderer and show how
visualization of the scheduling behavior has led to key improvements of the
renderer's performance.

%M C.SV.08.175
%T Applying visualisation techniques in software product lines
%S Software visualization applications
%A Nestor, Daren
%A Thiel, Steffen
%A Botterweck, Goetz
%A Cawley, Ciarán
%A Healy, Patrick
%B Proceedings of the ACM Symposium on Software Visualization
%D 2008
%P 175-184
%K feature configuration, interaction, software product lines, visualisation
%* (c) Copyright 2008 ACM
%W http://doi.acm.org/10.1145/1409720.1409748
%X Software product lines of industrial size can easily incorporate thousands
of variation points. This scale of variability can become extremely complex to
manage resulting in a product development process that bears significant costs.
One technique that can be applied beneficially in this context is
visualisation. Visualisation is widely used in software engineering and has
proven useful to amplify human cognition in data intensive applications.
Adopting this technique in software product line engineering can help
stakeholders in supporting essential work tasks and in enhancing their
understanding of large and complex product lines.
   The research presented in this paper describes an integrated meta-model and
research tool that employs visualisation techniques to address significant
software product line tasks such as variability management and product
derivation. Examples of the tasks are described and the ways in which these
tasks can be further supported by utilising visualisation techniques are
explained.

%M C.SV.08.185
%T Signature visualization of software binaries
%S Software visualization applications
%A Panas, Thomas
%B Proceedings of the ACM Symposium on Software Visualization
%D 2008
%P 185-188
%K binary analysis, malware visualization
%* (c) Copyright 2008 ACM
%W http://doi.acm.org/10.1145/1409720.1409749
%X In this paper we present work on the visualization of software binaries. In
particular, we utilize ROSE, an open source compiler infrastructure, to
pre-process software binaries, and we apply a landscape metaphor to visualize
the signature of each binary (malware). We define the signature of a binary as
a metric-based layout of the functions contained in the binary. In our initial
experiment, we visualize the signatures of a series of computer worms that all
originate from the same line. These visualizations are useful for a number of
reasons. First, the images reveal how the archetype has evolved over a series
of versions of one worm. Second, one can see the distinct changes between
versions. This allows the viewer to form conclusions about the development
cycle of a particular worm.

%M C.SV.08.189
%T Supporting the understanding of the evolution of software items
%S Software visualization applications
%A Theron, Roberto
%A Gonzalez, Antonio
%A Garcia, Francisco J.
%B Proceedings of the ACM Symposium on Software Visualization
%D 2008
%P 189-192
%K software evolution, software visualization
%* (c) Copyright 2008 ACM
%W http://doi.acm.org/10.1145/1409720.1409750
%X The aim of this paper is to support the awareness of software developers and
project managers as regards the evolution of software items by means of the
visualization of collaboration between developers and the understanding of the
evolution of commercial and open source software items. The proposed design is
supported by several interaction techniques and presents detailed information
regarding the creation of baselines, branches, revisions and the relationships
among them. A case study has been carried out and the usefulness of the tool
applied to discover relations and support awareness is revealed through the use
of interaction.

%M C.SV.08.193
%T Rapid visual design with semantics encoding through 3d CRC cards
%S Software visualization applications
%A Savidis, Anthony
%A Papadakos, Panagiotis
%A Zargianakis, George
%B Proceedings of the ACM Symposium on Software Visualization
%D 2008
%P 193-196
%K rapid prototyping, visual design encoding, visual software design
%* (c) Copyright 2008 ACM
%W http://doi.acm.org/10.1145/1409720.1409751
%X Physical CRC cards (Classes -- Responsibilities -- Collaborators) is a
well-known method for rapid software-design prototyping. It is commonly applied
with numeric heuristics to encode design semantics and denote architectural
relationships through card coloring, size variations and spatial grouping.
Existing CRC design tools are weak in terms of interactivity and visualization,
focusing mainly on form-based specification and documentation. We present
Flying Circus, a tool for rapid and exploratory software-design prototyping via
CRC cards, offering facilities such as: interactive 3d visualizations with
zooming, panning and rotational design inspection, 3d card manipulators, and
immersive navigation via stereoscopic views. Our tool is accompanied with
specific encoding strategies to represent design semantics and exploit spatial
memory and visual pattern matching, while emphasizing highly interactive
software-design visualizations.

%M C.SV.08.197
%T A landscape metaphor for visualization of software projects
%S Posters
%A Martínez, Amaia Aguirregoitia
%A Cosín, J. Javier Dolado
%A García, Concepción Presedo
%B Proceedings of the ACM Symposium on Software Visualization
%D 2008
%P 197-198
%* (c) Copyright 2008 ACM
%W http://doi.acm.org/10.1145/1409720.1409753
%X Software project management involves assessing the software system risks and
costs, establishing a master schedule, integrating the various engineering
specialities and design groups, maintaining configuration control and
continuously auditing the effort to ensure that cost and schedule are met and
the technical requirements objectives are satisfied. This paper presents a new
graphical representation model for controlling and managing a project
development process using metaphors and visual representation techniques.

%M C.SV.08.199
%T A metro map metaphor for visualization of software projects
%S Posters
%A Martínez, Amaia Aguirregoitia
%A Cosín, J. Javier Dolado
%A García, Concepción Presedo
%B Proceedings of the ACM Symposium on Software Visualization
%D 2008
%P 199-200
%* (c) Copyright 2008 ACM
%W http://doi.acm.org/10.1145/1409720.1409754
%X Software project management involves assessing the software system risks and
costs, establishing a master schedule, integrating the various engineering
specialities and design groups, maintaining configuration control and
continuously auditing the effort to ensure that cost and schedule are met and
the technical requirements objectives are satisfied.

%M C.SV.08.201
%T Combining software visualization paradigms to support software comprehension
activities
%S Posters
%A Carneiro, Glauco de F.
%A Magnavita, Rodrigo
%A Mendonça, Manoel
%B Proceedings of the ACM Symposium on Software Visualization
%D 2008
%P 201-202
%K software comprehension and visualization
%* (c) Copyright 2008 ACM
%W http://doi.acm.org/10.1145/1409720.1409755
%X Modern IDEs offer built-in support for developing plug-ins. More recently,
we have seen a growing number of plug-ins that offer non-conventional software
visualization interfaces. They usually aim to help programmers to understand
unfamiliar source code by representing it in visual structures such as trees,
scatter-plots or graphs. This poster presents a plug-in built to integrate and
combine several software visualization paradigms for supporting customized
software comprehension activities.

%M C.SV.08.203
%T Enhancing UML sketch tools with digital pens and paper
%S Posters
%A Dachselt, Raimund
%A Frisch, Mathias
%A Decker, Eike
%B Proceedings of the ACM Symposium on Software Visualization
%D 2008
%P 203-204
%K Anoto, UML, sketching, software design
%* (c) Copyright 2008 ACM
%W http://doi.acm.org/10.1145/1409720.1409756
%X Drawing diagrams is one of the most important activities during software
development processes. A multitude of sketch-based diagram tools were developed
to enhance sketching with digital features. However, these applications are not
as flexible as paper and often obstruct spontaneous sketching. To overcome
these drawbacks we suggest the usage of digital pens and paper in conjunction
with sketch-based UML diagram tools. This paper deals with work in progress
concerning the seamless integration of paper-based and digital UML-sketching.
Amongst others, this includes special UML sketch books and paper palettes used
in combination with tabletops.

%M C.SV.08.205
%T Texture-based visualization of metrics on software architectures
%S Posters
%A Byelas, Heorhiy
%A Telea, Alexandru
%B Proceedings of the ACM Symposium on Software Visualization
%D 2008
%P 205-206
%* (c) Copyright 2008 ACM
%W http://doi.acm.org/10.1145/1409720.1409757
%X We present a method that combines textures, blending, and scattered-data
interpolation to visualize several metrics defined on overlapping
areas-of-interest on UML class diagrams. We aim to simplify the task of
visually correlating the distribution and outlier values of a multivariate
metric dataset with a system's structure. We illustrate our method on a class
diagram of a real-world system.

%M C.SV.08.207
%T Towards seamless semantic zooming techniques for UML diagrams
%S Posters
%A Frisch, Mathias
%A Dachselt, Raimund
%A Brückmann, Tobias
%B Proceedings of the ACM Symposium on Software Visualization
%D 2008
%P 207-208
%K UML, diagrams, interaction techniques, models, semantic zooming,
visualization, zoomable user interface
%* (c) Copyright 2008 ACM
%W http://doi.acm.org/10.1145/1409720.1409758
%X Models become increasingly important for software development processes.
Though there is a multitude of software modeling tools available, the handling
of complex UML diagrams is still difficult. In particular, the visualization of
a global overview and of logical interrelationships between certain elements
arising from refinements of diagrams can be improved. We address these problems
and propose the usage of semantic zooming with different levels of detail and
describe intuitive interaction techniques to ease the navigation between
different diagrams in software models.

%M C.SV.08.209
%T VAST: visualization of abstract syntax trees within language processors
courses
%S Posters
%A Almeida-Martínez, Francisco J.
%A Urquiza-Fuentes, Jaime
%A Velázquez-Iturbide, J. Ángel
%B Proceedings of the ACM Symposium on Software Visualization
%D 2008
%P 209-210
%K abstract syntax trees, visualization
%* (c) Copyright 2008 ACM
%W http://doi.acm.org/10.1145/1409720.1409759
%X In this poster we present VAST, a visualization tool to support teaching
language processors. On the one hand, VAST provides an API that allows
generating visualizations of abstract syntax trees (AST). This process is
independent of the parser generator. On the other hand, VAST provides an
advanced interface to animate the AST construction process and to cope with
huge ones.

%M C.SV.08.211
%T Visualizing the computation tree of the Tutte Polynomial
%S Posters
%A Thompson, Bennett
%A Pearce, David J.
%A Anslow, Craig
%A Haggard, Gary
%B Proceedings of the ACM Symposium on Software Visualization
%D 2008
%P 211-212
%K Tutte Polynomial, software visualization
%* (c) Copyright 2008 ACM
%W http://doi.acm.org/10.1145/1409720.1409760
%X The computation trees of the Tutte Polynomial algorithm are very large.
Understanding the effects of applying heuristics to the algorithm for example
to classify knots is very challenging. We have constructed visualizations of
the Tutte Polynomial computation tree. The visualizations are useful to study
the effect of various heuristics on the algorithms' operation.

%M C.SV.08.213
%T Web software visualization using extensible 3D (X3D) graphics
%S Posters
%A Anslow, Craig
%A Noble, James
%A Marshall, Stuart
%A Biddle, Robert
%B Proceedings of the ACM Symposium on Software Visualization
%D 2008
%P 213-214
%K extensible 3D graphics, software visualization
%* (c) Copyright 2008 ACM
%W http://doi.acm.org/10.1145/1409720.1409761
%X 3D web software visualization has always been expensive, special purpose,
and hard to program. Most of the technologies used require large amounts of
scripting, are not reliable on all platforms, are binary formats, or no longer
maintained. We can make web software visualization of object-oriented programs
cheap, portable, and easy by using Extensible (X3D) 3D Graphics, which is a
free open standard. In this paper we outline our experience with X3D and
discuss the suitability of X3D as an output format for software visualization.