| Visualization for information exploration and analysis | | BIBA | Full-Text | 7-8 | |
| John Stasko | |||
| 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. | |||
| Assessing the benefits of synchronization-adorned sequence diagrams: two controlled experiments | | BIBAK | Full-Text | 9-18 | |
| Shaohua Xie; Eileen Kraemer; R. E. K. Stirewalt; Laura K. Dillon; Scott D. Fleming | |||
| 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. Keywords: UML, concurrency and synchronization, empirical evaluation | |||
| Visualization of exception handling constructs to support program understanding | | BIBAK | Full-Text | 19-28 | |
| Hina Shah; Carsten Görg; Mary Jean Harrold | |||
| 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. Keywords: Eclipse plugin, exception handling, interactive visualization, multiple
views, program understanding | |||
| Visual analysis of importance and grouping in software dependency graphs | | BIBAK | Full-Text | 29-32 | |
| Christian Pich; Lev Nachmanson; George G. Robertson | |||
| 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. Keywords: analysis, graph layout, large graphs, multidimensional scaling, ranking,
visualization | |||
| Algorithm visualization using concrete and abstract shape graphs | | BIBAK | Full-Text | 33-36 | |
| Sascha A. Parduhn; Raimund Seidel; Reinhard Wilhelm | |||
| 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. Keywords: algorithm animation, algorithm visualisation, invariants, shape analysis,
shape graphs | |||
| Analyzing the reliability of communication between software entities using a 3D visualization of clustered graphs | | BIBAK | Full-Text | 37-46 | |
| D. Zeckzer; R. Kalcklösch; L. Schröder; H. Hagen; T. Klein | |||
| 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. Keywords: force-directed layout, gossip-based protocol, software analysis, software
visualization | |||
| HDPV: interactive, faithful, in-vivo runtime state visualization for C/C++ and Java | | BIBAK | Full-Text | 47-56 | |
| Jaishankar Sundararaman; Godmar Back | |||
| 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. Keywords: object viewer, software visualization | |||
| Representing unit test data for large scale software development | | BIBAK | Full-Text | 57-66 | |
| Joseph A. Cottam; Joshua Hursey; Andrew Lumsdaine | |||
| 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. Keywords: MPI, project management, testing, visualization | |||
| An interactive reverse engineering environment for large-scale C++ code | | BIBA | Full-Text | 67-76 | |
| Alexandru Telea; Lucian Voinea | |||
| 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. | |||
| A catalogue of lightweight visualizations to support code smell inspection | | BIBAK | Full-Text | 77-86 | |
| Chris Parnin; Carsten Görg; Ogechi Nnadi | |||
| 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. Keywords: code inspection, code smells, lightweight visualization, refactoring | |||
| Classifying desirable features of software visualization tools for corrective maintenance | | BIBA | Full-Text | 87-90 | |
| Mariam Sensalire; Patrick Ogao; Alexandru Telea | |||
| 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. | |||
| Cluster analysis of Java dependency graphs | | BIBAK | Full-Text | 91-94 | |
| Jens Dietrich; Vyacheslav Yakovlev; Catherine McCartin; Graham Jenson; Manfred Duchrow | |||
| 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. Keywords: anti-pattern detection, cluster analysis, dependency analysis, refactoring | |||
| Gef3D: a framework for two-, two-and-a-half-, and three-dimensional graphical editors | | BIBAK | Full-Text | 95-104 | |
| Jens von Pilgrim; Kristian Duske | |||
| 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. Keywords: 3D visualization, graphical editing | |||
| Automatic layout of UML use case diagrams | | BIBAK | Full-Text | 105-114 | |
| Holger Eichelberger | |||
| 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. Keywords: UML, automatic layout algorithms, drawing rules, model-driven development,
use case diagrams | |||
| Improving an interactive visualization of transition systems | | BIBAK | Full-Text | 115-124 | |
| Bas Ploeger; Carst Tankink | |||
| 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. Keywords: 3D visualization, cone trees, graph drawing, transition systems | |||
| Streamsight: a visualization tool for large-scale streaming applications | | BIBAK | Full-Text | 125-134 | |
| Wim De Pauw; Henrique Andrade; Lisa Amini | |||
| 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. Keywords: distributed processing, dynamic visualization, stream processing
visualization, visualizing topologies | |||
| Software visualization for end-user programmers: trial period obstacles | | BIBAK | Full-Text | 135-144 | |
| Neeraja Subrahmaniyan; Margaret Burnett; Christopher Bogart | |||
| 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. Keywords: end-user software engineering, software adoption, software visualization,
spreadsheets | |||
| Visualizing inter-dependencies between scenarios | | BIBA | Full-Text | 145-153 | |
| David Harel; Itai Segall | |||
| 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. | |||
| Visually localizing design problems with disharmony maps | | BIBAK | Full-Text | 155-164 | |
| Richard Wettel; Michele Lanza | |||
| 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. Keywords: software design anomalies, software visualization | |||
| Stacked-widget visualization of scheduling-based algorithms | | BIBAK | Full-Text | 165-174 | |
| Tony Bernardin; Brian C. Budge; Bernd Hamann | |||
| 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. Keywords: data visualization, information visualization, out-of-core management, task
scheduling | |||
| Applying visualisation techniques in software product lines | | BIBAK | Full-Text | 175-184 | |
| Daren Nestor; Steffen Thiel; Goetz Botterweck; Ciarán Cawley; Patrick Healy | |||
| 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. Keywords: feature configuration, interaction, software product lines, visualisation | |||
| Signature visualization of software binaries | | BIBAK | Full-Text | 185-188 | |
| Thomas Panas | |||
| 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. Keywords: binary analysis, malware visualization | |||
| Supporting the understanding of the evolution of software items | | BIBAK | Full-Text | 189-192 | |
| Roberto Theron; Antonio Gonzalez; Francisco J. Garcia | |||
| 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. Keywords: software evolution, software visualization | |||
| Rapid visual design with semantics encoding through 3d CRC cards | | BIBAK | Full-Text | 193-196 | |
| Anthony Savidis; Panagiotis Papadakos; George Zargianakis | |||
| 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. Keywords: rapid prototyping, visual design encoding, visual software design | |||
| A landscape metaphor for visualization of software projects | | BIBA | Full-Text | 197-198 | |
| Amaia Aguirregoitia Martínez; J. Javier Dolado Cosín; Concepción Presedo García | |||
| 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. | |||
| A metro map metaphor for visualization of software projects | | BIBA | Full-Text | 199-200 | |
| Amaia Aguirregoitia Martínez; J. Javier Dolado Cosín; Concepción Presedo García | |||
| 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. | |||
| Combining software visualization paradigms to support software comprehension activities | | BIBAK | Full-Text | 201-202 | |
| Glauco de F. Carneiro; Rodrigo Magnavita; Manoel Mendonça | |||
| 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. Keywords: software comprehension and visualization | |||
| Enhancing UML sketch tools with digital pens and paper | | BIBAK | Full-Text | 203-204 | |
| Raimund Dachselt; Mathias Frisch; Eike Decker | |||
| 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. Keywords: Anoto, UML, sketching, software design | |||
| Texture-based visualization of metrics on software architectures | | BIBA | Full-Text | 205-206 | |
| Heorhiy Byelas; Alexandru Telea | |||
| 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. | |||
| Towards seamless semantic zooming techniques for UML diagrams | | BIBAK | Full-Text | 207-208 | |
| Mathias Frisch; Raimund Dachselt; Tobias Brückmann | |||
| 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. Keywords: UML, diagrams, interaction techniques, models, semantic zooming,
visualization, zoomable user interface | |||
| VAST: visualization of abstract syntax trees within language processors courses | | BIBAK | Full-Text | 209-210 | |
| Francisco J. Almeida-Martínez; Jaime Urquiza-Fuentes; J. Ángel Velázquez-Iturbide | |||
| 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. Keywords: abstract syntax trees, visualization | |||
| Visualizing the computation tree of the Tutte Polynomial | | BIBAK | Full-Text | 211-212 | |
| Bennett Thompson; David J. Pearce; Craig Anslow; Gary Haggard | |||
| 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. Keywords: Tutte Polynomial, software visualization | |||
| Web software visualization using extensible 3D (X3D) graphics | | BIBAK | Full-Text | 213-214 | |
| Craig Anslow; James Noble; Stuart Marshall; Robert Biddle | |||
| 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. Keywords: extensible 3D graphics, software visualization | |||