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'10 Proceedings of the ACM Symposium on Software Visualization
Editors:Alexandru Telea; Carsten Görg; Steven Reiss
Location:Salt Lake City, Utah
Dates:2010-Oct-25 to 2010-Oct-26
Publisher:ACM
Standard No:ISBN: 1-4503-0028-6, 978-1-4503-0028-5; ACM DL: Table of Contents hcibib: SV10
Papers:34
Pages:228
Links:Conference home Page
  1. Keynote
  2. Capstone presentation
  3. New visualization and interaction techniques
  4. Visualization of memory
  5. Visualization for program comprehension and maintenance
  6. Trace visualization
  7. Graph layout and visualization of evolution
  8. Posters
  9. Demos

Keynote

A pragmatic perspective on software visualization BIBAFull-Text 1-2
  Arie van Deursen
For software visualization researchers taking the pragmatic philosophical stance, the ultimate measure of success is adoption in industry. For you as researcher, what can be more satisfying than enthusiastic developers being able to work better and more efficiently thanks to your beautiful visualization of their software?
   One of the aims of this talk is to reflect on factors affecting impact in practice of software visualization research. How does rigorous empirical evaluation matter? What is the role of foundational research that does not subscribe to the philosophy of pragmatism? Can we make meaningful predictions of adoption in practice if this takes 10 years or more?
   During the talk, I will illustrate the dilemmas, opportunities, and frustrations involved in trying to achieve practical impact with examples drawn from my own research in such areas as software architecture analysis, documentation generation, and Web 2.0 user interface reverse engineering.
   I will also shed light on some of my most recent research activities, which includes work in the area of spreadsheet comprehension. This is research that we conduct with a major (Dutch) financial asset management firm. Our work consists of the identification of information needs for professional spreadsheet users, a visualization to address these needs, and an evaluation of this visualization with practitioners conducting real-life spreadsheet tasks.
   Throughout the talk, I will encourage the audience to engage in the discussion, and contribute their own perspectives on the issues that I raise in my talk.

Capstone presentation

Why don't developers draw diagrams? BIBAFull-Text 3-4
  Grady Booch
Common sense (and common practice in other engineering disciplines) tells us that modeling is a Good Thing. There is undeniable value in having and using simple, standard, and expressive graphical notations to help one reason about complex artifacts. However, while software-intensive systems are among the most complex of artifacts, reality is that the vast majority of developers live fully in the textual dimension and, like Flatlanders, have no understanding of or desire for the visual dimension save for a few diagrams with dubious semantics that they may hastily and ethereally sketch on a whiteboard. This community (of SoftVis researchers) have produced some compelling ideas -- but none of them are what one can claim to be fully mainstream. This keynote will discuss why this is so and what we might do to narrow this gap to attend to the pain points of developers.

New visualization and interaction techniques

An interactive ambient visualization for code smells BIBAFull-Text 5-14
  Emerson Murphy-Hill; Andrew P. Black
Code smells are characteristics of software that indicate that code may have a design problem. Code smells have been proposed as a way for programmers to recognize the need for restructuring their software. Because code smells can go unnoticed while programmers are working, tools called smell detectors have been developed to alert programmers to the presence of smells in their code, and to help them understand the cause of those smells. In this paper, we propose a novel smell detector called Stench Blossom that provides an interactive ambient visualization designed to first give programmers a quick, high-level overview of the smells in their code, and then, if they wish, to help in understanding the sources of those code smells. We also describe a laboratory experiment with 12 programmers that tests several hypotheses about our tool. Our findings suggest that programmers can use our tool effectively to identify smells and to make refactoring judgements. This is partly because the tool serves as a memory aid, and partly because it is more reliable and easier to use than heuristics for analyzing smells.
CodePad: interactive spaces for maintaining concentration in programming environments BIBAFull-Text 15-24
  Chris Parnin; Carsten Görg; Spencer Rugaber
When software developers work with a program's source code, the structure of the source code often requires that they split their attention simultaneously across several documents and artifacts. Disruptions to programmers' concentration caused by overwhelmed capacity can then lead to programming errors and increases in the time to perform a task. We suggest the addition of peripheral interactive spaces to programming environments for supporting developers in maintaining their concentration. We introduce the novel concept of a CodePad, a peripheral, multi-touch enabled display that allows developers to engage with and manipulate multiple programming artifacts. We illustrate visualizations built for a CodePad that support multiple development scenarios and we describe how developers can coordinate the interaction and communication between a CodePad and a programming environment in personal and collaborative tasks. Additionally, we propose a design space for other visualization tools and detail our initial prototype.
User evaluation of polymetric views using a large visualization wall BIBAFull-Text 25-34
  Craig Anslow; Stuart Marshall; James Noble; Ewan Tempero; Robert Biddle
There are few visualization techniques for displaying complex software systems with large numbers of packages and classes. One visualization technique is the System Hotspots View, whose effectiveness has yet to be validated by any empirical studies. We have conducted a user evaluation to see whether participants of our modified System Hotspots View using a large visualization wall can accurately identify key measurements and comparisons in the underlying software system. The results of our user evaluation indicate that participants were able to effectively use our modified System Hotspots View to explore the example domain: version 1.6 of the Java API. Our observations also indicate that there are issues around interacting with the visualization wall.
Software evolution storylines BIBAFull-Text 35-42
  Michael Ogawa; Kwan-Liu Ma
This paper presents a technique for visualizing the interactions between developers in software project evolution. The goal is to produce a visualization that shows more detail than animated software histories, like code_swarm [15], but keeps the same focus on aesthetics and presentation. Our software evolution storylines technique draws inspiration from XKCD's "Movie Narrative Charts" and the aesthetic design of metro maps. We provide the algorithm, design choices, and examine the results of using the storylines technique. Our conclusion is that the it is able to show more details when compared to animated software project history videos. However, it does not scale to the largest projects, such as Eclipse and Mozilla.

Visualization of memory

AllocRay: memory allocation visualization for unmanaged languages BIBAFull-Text 43-52
  George G. Robertson; Trishul Chilimbi; Bongshin Lee
A program's memory system performance is one of the key determinants of its overall performance. Lack of understanding of a program's memory system behavior can lead to performance problems, the most common being memory fragmentation and memory leaks. In this paper, we present AllocRay, a visualization that animates memory allocation event trace information over a time period of execution of a program. Various modes of display with custom color mappings and zooming allow the programmer to see how heaps are used over time (by allocation type, age, size, or thread id). Custom displays also allow the programmer to quickly detect potential memory leaks and fragmentation problems. Composable filters enable the programmer to focus on specific issues. We describe the techniques used to enable processing of a huge number of trace events while enabling rapid response to visualization view changes. We also describe informal interviews with four expert programmers to examine the usability of the AllocRay design.
Heapviz: interactive heap visualization for program understanding and debugging BIBAFull-Text 53-62
  Edward E. Aftandilian; Sean Kelley; Connor Gramazio; Nathan Ricci; Sara L. Su; Samuel Z. Guyer
Understanding the data structures in a program is crucial to understanding how the program works, or why it doesn't work. Inspecting the code that implements the data structures, however, is an arduous task and often fails to yield insights into the global organization of a program's data. Inspecting the actual contents of the heap solves these problems but presents a significant challenge of its own: finding an effective way to present the enormous number of objects it contains.In this paper we present Heapviz, a tool for visualizing and exploring snapshots of the heap obtained from a running Java program. Unlike existing tools, such as traditional debuggers, Heapviz presents a global view of the program state as a graph, together with powerful interactive capabilities for navigating it. Our tool employs several key techniques that help manage the scale of the data. First, we reduce the size and complexity of the graph by using algorithms inspired by static shape analysis to aggregate the nodes that make up a data structure. Second, we introduce a dominator-based layout scheme that emphasizes hierarchical containment and ownership relations. Finally, the interactive interface allows the user to expand and contract regions of the heap to modulate data structure detail, inspect individual objects and field values, and search for objects based on type or connectivity. By applying Heapviz to both constructed and real-world examples, we show that Heapviz provides programmers with a powerful and intuitive tool for exploring program behavior.
A map of the heap: revealing design abstractions in runtime structures BIBAFull-Text 63-72
  Colin Myers; David Duke
Visual representations of runtime software structures such as heap memory graphs can aid in debugging and help to develop program understanding. However, such structures may contain thousands of objects and have no obvious spatial organisation. If the program contains flaws the appearance of objects may well differ from the user's expectations. Navigating these graphs can be challenging to the user as the space is abstract and potentially unfamiliar.
   To alleviate this problem we employ a systematic approach grounded in the principles of navigational landmarks. We identify subgraphs within the heap that correspond to significant design abstractions and apply various visualization techniques to highlight and organise these structures. The aim is to provide the user with recognisable features that are linked to more familiar representations of the software. We claim that the enhanced representation can support existing memory debugging tools by providing the user with a usable 'map' of an otherwise abstract data space.
   The results are demonstrated using data extracted from an instrumented version of the Visualization Tool Kit (VTK), a complex and widely-used architecture for data visualization.
Trevis: a context tree visualization & analysis framework and its use for classifying performance failure reports BIBAFull-Text 73-82
  Andrea Adamoli; Matthias Hauswirth
When developers profile their applications to identify performance problems, they normally use profilers producing calling context trees. A calling context tree (CCT) represents the caller-callee relationships of a program. A dynamically collected CCT provides method coverage information. The CCTs produced by profilers also include method hotness information. Trevis, our context tree visualization and analysis framework, allows users to visualize, compare, cluster, and intersect CCTs produced by profilers. We evaluate Trevis in the context of a novel profiling tool called FlyBy. FlyBy runs transparently on an end-user's computer and continuously samples the applications' call stack. When the user perceives the application as sluggish, she presses a "Was Slow!" button to tell FlyBy to file a performance failure report. The report contains the CCT based on the call stack samples FlyBy gathered over the last few seconds before the user pressed the button. We show how Trevis allows us to visualize and classify FlyBy bug reports.

Visualization for program comprehension and maintenance

Exploring the inventor's paradox: applying jigsaw to software visualization BIBAFull-Text 83-92
  Haowei Ruan; Craig Anslow; Stuart Marshall; James Noble
Software visualization research has typically focussed on domain specific tools and techniques. In this paper, we evaluate applying a general purpose visual analytics tool Jigsaw to visualize the JHotDraw open source software system. We describe how Jigsaw can be applied to visualize software, and show how it can support some program comprehension tasks.
Dependence cluster visualization BIBAFull-Text 93-102
  Syed S. Islam; Jens Krinke; David Binkley
Large clusters of mutual dependence have long been regarded as a problem impeding comprehension, testing, maintenance, and reverse engineering. An effective visualization can aid an engineer in addressing the presence of large clusters. Such a visualization is presented. It allows a program's dependence clusters to be considered from an abstract high level down thru a concrete source-level. At the highest level of abstraction, the visualization uses a heat-map (a color scheme) to efficiently overview the clusters found in an entire system. Other levels include three source code views that allow a user to "zoom" in on the clusters starting from the high-level system view, down through a file view, and then onto the actual source code where each cluster can be studied in detail.
   Also presented are two case studies, the first is the open-source calculator bc and the second is the industrial program copia, which performs signal processing. The studies consider qualitative evaluations of the visualization. From the results, it is seen that the visualization reveals high-level structure of programs and interactions between its components. The results also show that the visualization highlights potential candidates (functions/files) for re-factoring in bc and finds dependence pollution in copia.
Towards anomaly comprehension: using structural compression to navigate profiling call-trees BIBAFull-Text 103-112
  Shen Lin; François Taïani; Thomas C. Ormerod; Linden J. Ball
Developers must often diagnose anomalies in programs they only have a partial knowledge of. As a result, they must simultaneously reverse engineer parts of the system they are unfamiliar with while interpreting dynamic observation data (performance profiling traces, error-propagation channels, memory leaks), a task particularly difficult. To support developers in this kind of comprehension task, filtering and aggregation have long been suggested as key enabling strategies. Unfortunately, traditional approaches typically only provide a uniform level of aggregation, thus limiting the ability of developers to construct context-dependent representations of a program's execution. In this paper, we propose a localised approach to navigate and analyse the CPU usage of little-known programs and libraries. Our method exploits the structural information present in profiling call trees to selectively raise or lower the local abstraction level of the performance data. We explain the formalism underpinning our approach, describe a prototype, and present a preliminary user study that shows our tool has the potential to complement more traditional navigation approaches.
Embedding spatial software visualization in the IDE: an exploratory study BIBAFull-Text 113-122
  Adrian Kuhn; David Erni; Oscar Nierstrasz
Software visualization can be of great use for understanding and exploring a software system in an intuitive manner. Spatial representation of software is a promising approach of increasing interest. However, little is known about how developers interact with spatial visualizations that are embedded in the IDE. In this paper, we present a pilot study that explores the use of Software Cartography for program comprehension of an unknown system. We investigated whether developers establish a spatial memory of the system, whether clustering by topic offers a sound base layout, and how developers interact with maps. We report our results in the form of observations, hypotheses, and implications. Key findings are a) that developers made good use of the map to inspect search results and call graphs, and b) that developers found the base layout surprising and often confusing. We conclude with concrete advice for the design of embedded software maps.

Trace visualization

Visualizing windows system traces BIBAFull-Text 123-132
  Yongzheng Wu; Roland H. C. Yap; Felix Halim
Operating system traces contain the detailed behavior of the persistent actions of an application; interactions between multiple applications; and the functioning of the system as a whole. The challenge is that such traces are large and consequently hard to understand and analyze. We present lviz, a novel visualization tool, which meets these challenges. We focus on Windows system traces though our visualization is general. Our visualization is flexible and can be customized to highlight different aspects of the behavior program(s) and the overall operating system.
Understanding complex multithreaded software systems by using trace visualization BIBAFull-Text 133-142
  Jonas Trümper; Johannes Bohnet; Jürgen Döllner
Understanding multithreaded software systems is typically a tedious task: Due to parallel execution and interactions between multiple threads, such a system's runtime behavior is often much more complex than the behavior of a single-threaded system. For many maintenance activities, system understanding is a prerequisite. Hence, tasks such as bug fixing or performance optimization are highly demanding in the case of multithreaded systems. Unfortunately, state-of-the-art tools for system understanding and debuggers provide only limited support for these systems. We present a dynamic analysis and visualization technique that helps developers in understanding multithreaded software systems in general and in identifying performance bottlenecks in particular. The technique first performs method boundary tracing. Second, developers perform a post-mortem analysis of a system's behavior using visualization optimized for trace data of multithreaded software systems. The technique enables developers to understand how multiple threads collaborate at runtime. The technique is integrated into a professional and scalable tool for visualizing the behavior of complex software systems. In case studies, we have tested the technique with industrially developed, multithreaded software systems to understand system behavior and to identify multithreading-related performance bottlenecks.
Zinsight: a visual and analytic environment for exploring large event traces BIBAFull-Text 143-152
  Wim De Pauw; Steve Heisig
Information in event traces from software systems can help developers with performance analysis, debugging and troubleshooting. However, the volume of data contained in these traces can make such tasks a challenge. In this paper we propose a new tool, Zinsight, to visualize event traces from complex systems. Our contribution is a novel combination of visualizations and pattern extraction techniques, enabling user exploration, analysis and understanding of traces containing millions of events. Three complimentary views help the user answer different questions. First, the Event Flow view shows the trace in its entirety or in detail. The user sees visual patterns representing phases of processing and the relative order of events. Second, the Event Statistics view quantifies events, and presents distributions and averages enabling the user to identify outlier behavior. Third, the Sequence Context view extracts patterns of interest from the trace and represents them along with frequency and performance data in succinct execution flow diagrams. The user can navigate from patterns to their constituent instance sequences and even back to individual events in the other views. Questions can be answered and hypotheses tested using the most natural view for the task.
Jype -- a program visualization and programming exercise tool for Python BIBAFull-Text 153-162
  Juha Helminen; Lauri Malmi
Based on research into learning programming and a review of program visualization research, we designed an educational software tool that aims to target students' apparent fragile knowledge of elementary programming which manifests as difficulties in tracing and writing even simple programs. Most existing tools build on a single supporting technology and focus on one aspect of learning. For example, visualization tools support the development of a conceptual-level understanding of how programs work, and automatic assessment tools give feedback on submitted tasks. We implemented a combined tool that closely integrates programming tasks with visualizations of program execution and thus lets students practice writing code and more easily transition to visually tracing it in order to locate programming errors. In this paper we present Jype, a web-based tool that provides an environment for visualizing the line-by-line execution of Python programs and for solving programming exercises with support for immediate automatic feedback and an integrated visual debugger. Moreover, the debugger allows stepping back in the visualization of the execution as if executing in reverse. Jype is built for Python, when most research in programming education support tools revolves around Java.

Graph layout and visualization of evolution

Off-screen visualization techniques for class diagrams BIBAFull-Text 163-172
  Mathias Frisch; Raimund Dachselt
Visual representations of node-link diagrams are very important for the software development process. In many situations large diagrams -- probably consisting of hundreds of nodes and edges -- have to be edited and explored. In state-of-the-art modeling tools these activities are often accompanied by time consuming panning and zooming. In this paper we contribute the application of off-screen visualization techniques to the domain of node-link diagrams in general and to UML class diagrams in particular. The basic idea of the approach is to give a contextual view of all nodes which are clipped from the current viewport. Nodes are represented by proxy elements located within an interactive border region. The proxies show information of the associated off-screen nodes and can be used to quickly navigate to the respective node. However, there are several challenges when this technique is adapted to node-link diagrams, for example concerning the change of edge routing or scalability. We describe the design space of this approach and present different visualization and interaction techniques in detail. Furthermore, we conducted a formative evaluation of our first prototype. Based on the observations made during the evaluation, we came to final suggestions how particular techniques should be combined.
An automatic layout algorithm for BPEL processes BIBAFull-Text 173-182
  Benjamin Albrecht; Philip Effinger; Markus Held; Michael Kaufmann
The Business Process Execution Language (BPEL) is the standard execution language for business workflows. BPEL is an XML-based, verbose and complex language, consisting of block- and graph-oriented control structures, which makes it hard to generate intuitive visualizations.
   Although many tools enable the visualization of workflows before the transformation into executable systems, notations and style criteria for the visualization and layout of workflows are not standardized, so it is very hard to compare different tools. Often, the construction of a layout for a possibly complex workflow is left to the user or the result is visually unsatisfying.
   We present a novel algorithm for the layout of complex BPEL workflows, which uses the principles of the algorithm by Sugiyama and takes into account BPEL specifics, e.g. nested structures, parallel paths and several distinct types of elements. The BPEL specifics represent challenges to the layout algorithm and are not completely fulfilled by any other layout approach for BPEL.
Visual comparison of software architectures BIBAFull-Text 183-192
  Fabian Beck; Stephan Diehl
Reverse engineering methods produce different descriptions of software architectures. In this work we analyze and define the task of exploring and comparing these descriptions. We present a novel visualization technique to compare architectures based on the decomposition of the software system and on the dependencies among the code entities. A case study related to software clustering shows how we can apply this technique in practice.
Representing development history in software cities BIBAFull-Text 193-202
  Frank Steinbrückner; Claus Lewerentz
In this paper we describe a systematic approach to utilize the city metaphor for the visualization of large software systems as evolving software cities. The main contribution is a new layout approach which explicitly takes the development history of software systems into account and makes history directly visible in the layouts. These layouts incrementally evolve in a very smooth and stable way during the development of the represented software system. They are used as a visualization platform for integrating a large variety of product and process data and thus create a coherent set of specialized visualizations. To illustrate this we present some example maps capturing specific development history aspects.

Posters

3D kiviat diagrams for the interactive analysis of software metric trends BIBAFull-Text 203-204
  Andreas Kerren; Ilir Jusufi
Previous techniques for visualizing time-series of multivariate data mostly plot the time along additional axes, are often complex, and does not support intuitive interaction. In this poster paper, we present an interactive visualization approach for the analysis of software metric trends that allows users to operate with Kiviat diagrams on 2D planes in the space and to intuitively extend this visual representation into 3D if needed.
Graph works -- pilot graph theory visualization tool BIBAFull-Text 205-206
  Dan Medani; Gary Haggard; Chris Bassett; Peter Koch; Nikolas Lampert; Tim Medlock; Steven Pierce; Ryan Smith; Andrew Yehl
Graph theory is an integral part of a discrete structures course required in computer science programs. Unfortunately, in the short time such courses devote to graph theory, students often do not appreciate and/or recognize how graph theory notions and theorems become problem modeling and problem solving tools. Graph Works is a visualization tool to show what properties of graph mean in terms of a particular graph and what properties and substructures fundamental theorems guarantee to exist in a graph. The tool is designed to help users understand and develop algorithms that use graph properties needed for problem solving or find and use particular subgraphs as part of the solution process.
Visualizing software entities using a matrix layout BIBAFull-Text 207-208
  Dirk Zeckzer
Understanding legacy systems is one of the major tasks in software engineering. The relations between different entities, e.g., packages and classes in Java, are important for this understanding process. We propose a matrix based visualization of the relations between these software entities. We explore several design decisions and show what works and what does not work.
ImpactViz: visualizing class dependencies and the impact of changes in software revisions BIBAFull-Text 209-210
  Matthew Follett; Orland Hoeber
Object oriented software development is designed to be modular, with code reuse being very common. When bugs are introduced, they can manifest themselves in one or more sections of code, but originating in a completely different area. This poster outlines the features of ImpactViz, a novel approach for visualizing class dependencies and the impact of changes in software revisions stored within a repository.
VIPERS: visual prototyping environment for real-time imaging systems BIBAFull-Text 211-212
  Frederic Jean; Alexandra Branzan Albu
This paper presents a novel environment for the visual design and prototyping of computer vision systems. The proposed environment consists of a modular architecture, where each module instance performs a pre-specified task. This is well suited for the implementation of computer vision systems, which are typically highly modular. A graphical user interface allows for the visualization and comparison of intermediate results, as well as for the design of complex systems by interconnecting modules.
Towards automated analysis and visualization of distributed software systems BIBAFull-Text 213-214
  Martin Beck; Jürgen Döllner
This paper sketches one approach to facilitate comprehension of distributed software systems. These systems gain more and more importance due to a paradigm shift in software systems and applications, evolving from single-chip solutions to multi-tiered web-based applications. For a single developer, it becomes increasingly difficult to cope with the complexity of such software systems. We propose a novel automated analysis and visualization technique that aims at the interactive exploration of static structures and behavior of distributed software systems. First, it automatically gathers communication data from the instrumented system components. Second, it generates a visual representation using a heuristic layout approach. Finally, it allows developers to interactively refine and explore this structural and behavioral information.
TIE: an interactive visualization of thread interleavings BIBAFull-Text 215-216
  Gowritharan Maheswara; Jeremy S. Bradbury; Christopher Collins
Multi-core processors have become increasingly prevalent, driving a software shift toward concurrent programs which best utilize these processors. Testing and debugging concurrent programs is difficult due to the many different ways threads can interleave. One solution to testing concurrent software is to use tools, such as NASA's Java PathFinder (JPF), to explore the thread interleaving space. Although tools such as JPF provide comprehensive data about program errors, the data is generally in the form of bulk text logs, which provide little support for common analysis tasks, such as finding common and rare error states. In this paper, we present an interactive visualization tool, TIE, that integrates with JPF to enhance concurrency testing and debugging.
GEM: graphical explorer of MPI programs BIBAFull-Text 217-218
  Alan Humphrey; Christopher Derrick; Ganesh Gopalakrishnan; Beth R. Tibbitts
Formal dynamic verification complements MPI program testing by detecting hard-to-find concurrency bugs. These bugs are elusive and difficult to reproduce and track down using conventional methods due to the difficulty in determining the state of a program when the bug occurs. In previous work, we described our dynamic verifier called In-situ Partial Order (ISP [5]) that can efficiently search the execution space of an MPI program while detecting important classes of bugs. ISP does this by executing processes under the control of its own scheduler. One major limitation of ISP, when used by itself, is the lack of a powerful and widely usable graphical front-end. We now present a new tool called Graphical Explorer of MPI Programs (GEM [2]) that overcomes this limitation. GEM is designed as an Eclipse plug-in within the Parallel Tools Platform (PTP [1]), a rapidly evolving tool integration framework for parallel program development and analysis. GEM serves to bring ISP within reach of a wide array of programmers with its original release as part of PTP version 3.0 in December, 2009. Our poster illustrates the motivation for GEM, an overview of its features and our future plans.
Fault forest visualization BIBAFull-Text 219-220
  Sven Böttger; Henning Barthel; Achim Ebert
Fault tree analysis has become an important tool for safety analysis of software and embedded systems. To address growing complexity component fault trees have been introduced. This paper focuses on the analysis of fault forests, an overlapping of multiple component fault trees. We present ideas to aid common cause analysis to effectively reduce the overall risk of top events within these forests. We try to visually aid the developer to find basic events which affect a large number of top events, but also aid the risk reduction of one top event within the forest. We are not aware of any tool that supports common cause analysis.

Demos

xDIVA: automatic animation between debugging break points BIBAFull-Text 221-222
  Yung-Pin Cheng; Han-Yi Tsai; Chih-Shun Wang; Chien-Hsin Hsueh
xDIVA, a 3D debugging visualization tool, provides a platform by which visualization metaphors are interactive, composable and decoupled from data, i.e. a complicated visualization can be composed and assembled from basic ones, each of which is independently replaceable. Based on the progress of xDIVA, this tool demo paper describes an automatic animation system to generate interpolated frames between key frames, where key frames are snapshots of the 3D scene at breakpoints. This approach does not require users to add or write any animation code and is more feasible for practical use.
Understanding relaxed memory consistency through interactive visualization BIBAFull-Text 223-224
  Oystein Thorsen; Charles Wallace
We present Rasho, a tool that extracts and depicts execution scenarios from UPC source code, then allows learners to intervene in the scenarios, manipulating them to explore hypotheses about consistent and inconsistent code. This approach allows learners to play with relaxed consistency inside a responsive, informative visual space.
Beat: a tool for visualizing the execution of object orientated concurrent programs BIBAFull-Text 225-226
  Paul Johnson; Stephen Marsland
The transition from single core to multicore processors has lead to a greater need for programmers to become familiar with concurrent programming. In particular there is a need to help programmers new to concurrent programming to understand how to utilize multiprocessor systems. We feel that visualization tools could be extremely helpful to these programmers. In this paper we present a novel design for a program trace visualizer we call Beat.