HCI Bibliography Home | HCI Conferences | SV Archive | Detailed Records | RefWorks | EndNote | Hide Abstracts
SV Tables of Contents: 0305060810

Proceedings of the ACM Symposium on Software Visualization

Fullname:SoftVis'08 Proceedings of the ACM Symposium on Software Visualization
Editors:Rainer Koschke; Christopher Hundhausen; Alexandru Telea
Location:Ammersee, Germany
Dates:2008-Sep-16 to 2008-Sep-17
Standard No:ISBN: 1-60558-112-7, 978-1-60558-112-5; ACM Order Number: 102082; ACM DL: Table of Contents hcibib: SV08
  1. Keynote
  2. Software visualization for understanding
  3. Software visualization for testing and debugging
  4. Software visualization for maintenance
  5. Software visualization interaction and layout
  6. Joint paper session with VL/HCC
  7. Software visualization for design
  8. Software visualization applications
  9. Posters


Visualization for information exploration and analysis BIBAFull-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.

Software visualization for understanding

Assessing the benefits of synchronization-adorned sequence diagrams: two controlled experiments BIBAKFull-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 BIBAKFull-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 BIBAKFull-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 BIBAKFull-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

Software visualization for testing and debugging

Analyzing the reliability of communication between software entities using a 3D visualization of clustered graphs BIBAKFull-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 BIBAKFull-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 BIBAKFull-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

Software visualization for maintenance

An interactive reverse engineering environment for large-scale C++ code BIBAFull-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 BIBAKFull-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 BIBAFull-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 BIBAKFull-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

Software visualization interaction and layout

Gef3D: a framework for two-, two-and-a-half-, and three-dimensional graphical editors BIBAKFull-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 BIBAKFull-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 BIBAKFull-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

Joint paper session with VL/HCC

Streamsight: a visualization tool for large-scale streaming applications BIBAKFull-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 BIBAKFull-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

Software visualization for design

Visualizing inter-dependencies between scenarios BIBAFull-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 BIBAKFull-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 BIBAKFull-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

Software visualization applications

Applying visualisation techniques in software product lines BIBAKFull-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 BIBAKFull-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 BIBAKFull-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 BIBAKFull-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 BIBAFull-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 BIBAFull-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 BIBAKFull-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 BIBAKFull-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 BIBAFull-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 BIBAKFull-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 BIBAKFull-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 BIBAKFull-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 BIBAKFull-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