| Program animation based on the roles of variables | | BIBAK | Full-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 | | BIBAK | Full-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 | | BIBAK | Full-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 | |||
| EVolve: an open extensible software visualization framework | | BIBAK | Full-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 | | BIBAK | Full-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 | |||
| Visualizing Java in action | | BIBAK | Full-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 | | BIBAK | Full-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 | | BIBA | Full-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 visualization in CS education: comparing levels of student engagement | | BIBAK | Full-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 | | BIBAK | Full-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 | | BIBAK | Full-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 | |||
| Interactive visual debugging with UML | | BIBAK | Full-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 | | BIBAK | Full-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 | |||
| Interactive locality optimization on NUMA architectures | | BIBAK | Full-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 | | BIBAK | Full-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 | | BIBAK | Full-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 | |||
| Nice class diagrams admit good design? | | BIBAK | Full-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 | | BIBA | Full-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 | | BIBAK | Full-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 | | BIBAK | Full-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 | |||