| The Clack graphical router: visualizing network software | | BIBAK | Full-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 | | BIBAK | Full-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 | | BIBAK | Full-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 | |||
| Execution patterns for visualizing web services | | BIBAK | Full-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 | |||
| Visualizing live software systems in 3D | | BIBAK | Full-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 | | BIBAK | Full-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 | |||
| Transparency, holophrasting, and automatic layout applied to control structures for visual dataflow programming languages | | BIBAK | Full-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 | | BIBAK | Full-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 | |||
| Using social agents to visualize software scenarios | | BIBAK | Full-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 | | BIBAK | Full-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 | | BIBAK | Full-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 | | BIBAK | Full-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 | |||
| Visualizing program execution using user abstractions | | BIBAK | Full-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 | | BIBAK | Full-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 | |||
| 3D visualisation of code structures in Java software systems | | BIBA | Full-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? | | BIBAK | Full-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 | |||
| A tool for visualizing schemas for semistructured data | | BIBA | Full-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 | | BIBAK | Full-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 | | BIBA | Full-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 | | BIBAK | Full-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 | | BIBA | Full-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 | | BIBA | Full-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 | | BIBAK | Full-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 | | BIBAK | Full-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 | | BIBA | Full-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 | | BIBA | Full-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 | | BIBAK | Full-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 | | BIBAK | Full-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 | | BIBAK | Full-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 | | BIBA | Full-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 | | BIBAK | Full-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 | | BIBA | Full-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 | | BIBAK | Full-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 | | BIBAK | Full-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 | | BIBAK | Full-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 | | BIBAK | Full-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 | | BIBAK | Full-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++ | | BIBA | Full-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 | | BIBA | Full-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 | | BIBA | Full-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 | | BIBAK | Full-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 | |||