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'05 Proceedings of the ACM Symposium on Software Visualization
Editors:Tom Naps; Wim De Pauw
Location:St. Louis, Missouri
Dates:2005-May-14 to 2005-May-15
Publisher:ACM
Standard No:ISBN: 1-59593-073-6; ACM Order Number: 102052; ACM DL: Table of Contents hcibib: SV05
Papers:20
Pages:211
  1. Visualization of algorithms
  2. Visualization of the software development process
  3. Visualization with UML
  4. Program visualization
  5. Visualization of parallel and distributed systems
  6. Layout and graph drawing algorithms for software visualization
  7. Visualization frameworks and empirical evaluation

Visualization of algorithms

Algorithm visualization using concept keyboards BIBAKFull-Text 7-16
  N. Baloian; H. Breuer; W. Luther
Software visualization and algorithm animation are topics of growing interest in computer science education. We propose a new interface to support the interaction between learners and the dynamic data structure of standard algorithms. Based on their source code users generate and configure so-called concept keyboards to explore the data structures and to execute the methods of the algorithms. This access is in contrast with a simple step interface which allows visualization of the steps of the algorithm in the right order. The results of the various evaluation phases are given. At this moment a larger study is being undertaken with undergraduates which focuses on the usability of the keyboard.
Keywords: XML-based interface, algorithm animation, algorithm visualization, concept keyboards
Algorithm animation using shape analysis: visualising abstract executions BIBAKFull-Text 17-26
  Dierk Johannes; Raimund Seidel; Reinhard Wilhelm
This paper describes progress in a non-traditional approach to algorithm animation. We visualise the abstract execution of an algorithm instead of animating the algorithm for executions on concrete input data. Algorithms under consideration are imperative pointer-based algorithms. For our purpose, we need to compute invariants which describe the state of the heap. The most powerful method to accomplish this task automatically is shape analysis. However, the output of a shape analysis can get confusingly large and complex, and it may contain redundancy as well. We need to identify those configurations which are important according to our visualisation aim, such as teaching the algorithm. We present suitable methods for structuring the shape analysis output and for finding expressive configurations. Our approach is exemplified for binary tree algorithms.
Keywords: abstract execution, algorithm animation, invariant, shape analysis, tree, visualisation
Peeking in solver strategies using explanations visualization of dynamic graphs for constraint programming BIBAKFull-Text 27-36
  Mohammad Ghoniem; Hadrien Cambazard; Jean-Daniel Fekete; Narendra Jussien
In this paper, we describe the use of visualization tools in the context of constraint programming. Specifically, we focus on the visualization of dynamic graphs using adjacency matrices, and show that visualization tools can provide valuable insights into the behavior of constraint-based solvers. This contributes to better understanding solver dynamics for teaching purposes, and can enhance the analysis and the optimization of constraint-based programs in connection with known and difficult research problems.
Keywords: constraint programming, finite domain solver, graph drawing algorithms for software visualization, visual debugging, visualization of algorithms

Visualization of the software development process

Visual data mining in software archives BIBAFull-Text 37-46
  Michael Burch; Stephan Diehl; Peter Weißgerber
Software archives contain historical information about the development process of a software system. Using data mining techniques rules can be extracted from these archives. In this paper we discuss how standard visualization techniques can be applied to interactively explore these rules. To this end we extended the standard visualization techniques for association rules and sequence rules to also show the hierarchical order of items. Clusters and outliers in the resulting visualizations provide interesting insights into the relation between the temporal development of a system and its static structure. As an example we look at the large software archive of the MOZILLA open source project. Finally we discuss what kind of regularities and anomalies we found and how these can then be leveraged to support software engineers.
CVSscan: visualization of code evolution BIBAKFull-Text 47-56
  Lucian Voinea; Alex Telea; Jarke J. van Wijk
During the life cycle of a software system, the source code is changed many times. We study how developers can be enabled to get insight in these changes, in order to understand the status, history and structure better, as well as for instance the roles played by various contributors. We present CVSscan, an integrated multiview environment for this. Central is a line-oriented display of the changing code, where each version is represented by a column, and where the horizontal direction is used for time, Separate linked displays show various metrics, as well as the source code itself. A large variety of options is provided to visualize a number of different aspects. Informal user studies demonstrate the efficiency of this approach for real world use cases.
Keywords: software evolution, software visualization
The war room command console: shared visualizations for inclusive team coordination BIBAKFull-Text 57-65
  Ciaran O'Reilly; David Bustard; Philip Morrow
Making the structure of software visible during system development helps (i) build a shared understanding of the context for each piece of work, (ii) identify progress with implementation, and (iii) highlight any conflict between individual development activities. Finding an adequate representation for such information is not straightforward, especially for large applications. This paper describes an implementation of such a visualization system designed to explore some of the issues involved. The approach is based on a 'War Room Command Console' metaphor and uses a bank of eight linked consoles to present information. The tool was applied to several industrial software systems written in a mixture of Java, C++ and C, one of which was over a million lines of code in size.
Keywords: coordination, representation, visualization
Visualizing multiple evolution metrics BIBAKFull-Text 67-75
  Martin Pinzger; Harald Gall; Michael Fischer; Michele Lanza
Observing the evolution of very large software systems needs the analysis of large complex data models and visualization of condensed views on the system. For visualization software metrics have been used to compute such condensed views. However, current techniques concentrate on visualizing data of one particular release providing only insufficient support for visualizing data of several releases.
   In this paper we present the RelVis visualization approach that concentrates on providing integrated condensed graphical views on source code and release history data of up to n releases. Measures of metrics of source code entities and relationships are composed in Kiviat diagrams as annual rings. Diagrams highlight the good and bad times of an entity and facilitate the identification of entities and relationships with critical trends. They represent potential refactoring candidates that should be addressed first before further evolving the system. The paper provides needed background information and evaluation of the approach with a large open source software project.
Keywords: Kiviat, evolution metrics, software evolution analysis, software visualization

Visualization with UML

Visual specification and analysis of use cases BIBAKFull-Text 77-85
  Deepali Kholkar; G. Murali Krishna; Ulka Shrotri; R. Venkatesh
Unified Modelling Language (UML) is popular mainly due to the various visual notations it provides for specifying large systems. In UML the details of a use case are specified in natural language using standard templates [Cockburn 2000]. This is a critical gap leading to detailed requirements of an application being specified in natural language. As a result, inadequate analysis of business requirements is a source of many defects in software application development. Here we propose to bridge this gap by extending the set of UML diagrams with three new diagrams that enable rigorous specification, analysis and simulation of requirements.
   The above is achieved by modelling business policies as global invariants and operational tasks as user interactions. We propose visual notations to specify both the global invariants as well as the user interactions. The two specifications are checked for consistency using the model checker, SAL. Inconsistencies detected by the model checker are then presented back to the analyst in the form of easy to understand diagrams. These inconsistencies help detect incompleteness in the functional specification of an application as well as help in making the functional specifications rigorous and detailed. This simplifies the task of the designers and implementers. SAL is also used to simulate the system and generate some sample runs. These sample runs are presented back to the developer in visual form enabling better understanding of the behaviour of the system. The advantages of this approach are demonstrated through our experiences with a case study as well as a project executed at Tata Consultancy Services (TCS).
Keywords: UML, model checking, requirements, visual notation
Towards modeling context-sensitive interactive applications: the context-sensitive user interface profile (CUP) BIBAKFull-Text 87-94
  Jan Van den Bergh; Karin Coninx
The construction of software systems is becoming increasingly complex because of the changing environments the software is supposed to function in. Taking into account the context of use, how the system reacts and anticipates changes in its working environment, is important for a wide range of applications, such as mobile services for example, Model-driven design is already widely accepted as a software engineering methodology to cope with these new type of requirements. This approach is known both in software engineering (e.g. model-driven architecture) as in the design of user interfaces (model-based user interface development), but although they target the same deficiencies from traditional approaches, there is still a gap between both. New modeling elements are necessary that allow the designer to make both context of use and user interactions explicit in the design phase and to create context-sensitive software that will be more robust and usable. We extend the UML 2.0 notation to address the aforementioned issues and present extensions to support the modeling of context-sensitive interactive applications. These extensions are defined in a new UML profile that can easily be used in existing modeling environments.
Keywords: UML 2.0, UML profile, abstract user interfaces, context, context-sensitive interactive applications

Program visualization

Methodology and architecture of JIVE BIBAFull-Text 95-104
  Paul Gestwicki; Bharat Jayaraman
A novel approach to the runtime visualization and analysis of object-oriented programs is presented and illustrated through a prototype system called JIVE: Java Interactive Visualization Environment. The main contributions of JIVE are: multiple concurrent representations of program state and execution history; support for forward and reverse execution; and graphical queries over program execution. This model facilitates program understanding and interactive debugging. Our visualization of runtime states clarifies the important point that objects are environments of execution. The history of object interaction is displayed via sequence diagrams, and in this way we help close the loop between design-time and run-time representations. Interactive execution is made possible by maintaining a runtime history database, which may be queried for information on variable behavior, method executions, and object interactions. We illustrate the capabilities of this system through examples. JIVE is implemented using the Java Platform Debugger Architecture and supports the Java language and libraries, including multithreaded and GUI applications.
Exploiting UML dynamic object modeling for the visualization of C++ programs BIBAKFull-Text 105-114
  Brian A. Malloy; James F. Power
In this paper we present an approach to modeling and visualizing the dynamic interactions among objects in a C++ application. We exploit UML diagrams to expressively visualize both the static and dynamic properties of the application. We make use of a class diagram and call graph of the application to select the parts of the application to be modeled, thereby reducing the number of objects and methods under consideration with a concomitant reduction in the cognitive burden on the user of our system. We use aspects to insert probes into the application to enable profiling of the interactions of objects and methods and we visualize these interactions by providing sequence and communication diagrams for the parts of the program under consideration. We complement our static selectors with dynamic selectors that enable the user to further filter objects and methods from the sequence and communication diagrams, further enhancing the cognitive economy of our system. A key feature of our approach is the provision for dynamic interaction with both the profiler and the application. Interaction with the profiler enables filtering of methods and objects. Interaction with the application enables the user to supply input to the application to provide direction and enhance comprehension or debugging.
Keywords: aspect oriented programming, program comprehension, sequence diagram, unified modeling language
Jove: java as it happens BIBAKFull-Text 115-124
  Steven P. Reiss; Manos Renieris
Dynamic software visualization is designed to provide programmers with insights as to what the program is doing. Most current dynamic visualizations either use program traces to show information about prior runs, slow the program down substantially, show only minimal information, or force the programmer to indicate when to turn visualizations on or off. We have developed a dynamic Java visualizer that provides a statement-level view of a Java program in action with low enough overhead so that it can be used almost all the time by programmers to understand what their program is doing while it is doing it.
Keywords: dynamic software visualization, instrumentation, run-time monitoring

Visualization of parallel and distributed systems

Visualizing structural properties of irregular parallel computations BIBAKFull-Text 125-134
  Wolfgang Blochinger; Michael Kaufmann; Martin Siebenhaller
An important task in parallel programming is the appropriate distribution of work on the processors. This distribution is usually dynamically changing and hard to predict, further it is very sensitive to the change of parameters. Even with advanced analysis tools this problem is hard to be solved. We propose to visualize the program structure as it changes over the execution time. We therefore present a new automatic layout algorithm based on Sugiyama's framework, which enables the user to detect structural patterns which might be fatal for the performance of the program -- patterns which might be impossible to detect in a more analytical way. Furthermore it assists the user to find appropriate timing parameters for load balancing. We integrate our visualization into an integrated development environment that supports the implementation, execution, and analysis of parallel programs.
Keywords: interactive performance tuning, visualization of parallel execution graphs
Adding parallelism to visual data flow programs BIBAKFull-Text 135-144
  Philip Cox; Simon Gauvin; Andrew Rau-Chaplin
Programming in parallel is an error-prone and complex task compounded by the lack of tool support for both programming and debugging. Recent advances in compiler-directed shared memory APIs, such as OpenMP, have made shared-memory parallelism more widely accessible for users of traditional procedural languages: however, the mechanisms provided are difficult to use and error-prone. This paper examines the use of visual notations for data flow programming to enable the creation of shared memory parallel programs. We present a model, arising from research on the ReactoGraph visual programming language, that allows code in a general class of visual data flow languages to be parallelized using visual annotations, and discuss the advantages this has over current textual methods.
Keywords: data flow, parallel, visual language
Visualization of mobile object environments BIBAKFull-Text 145-154
  Yaniv Frishman; Ayellet Tal
This paper presents a system for visualizing mobile object frameworks. In such frameworks, the objects can migrate to remote hosts, along with their state and behavior, while the application is running. An innovative graph-based visualization is used to depict the physical and the logical connections in the distributed object network. Scalability is achieved by using a focus+context technique jointly with a user-steered clustering algorithm. In addition, an event synchronization model for mobile objects is presented. The system has been applied to visualizing several mobile object applications.
Keywords: distributed software visualization, mobile objects, software visualization

Layout and graph drawing algorithms for software visualization

A space of layout styles for hierarchical graph models of software systems BIBAKFull-Text 155-164
  Andreas Noack; Claus Lewerentz
Hierarchical graphs are widely used as models of the structure of software systems. A central problem in the visualization of hierarchical graphs is the computation of layouts, i.e. of positions of the nodes in two- or three-dimensional space. We derive requirements for graph layouts from various software analysis questions, and classify the required layouts along three dimensions: layouts with meaningful distances between single nodes vs. layouts with meaningful distances between groups of nodes, layouts reflecting adjacency vs. layouts reflecting hierarchy, and layouts that faithfully reflect the size of subgraphs vs. layouts where certain subgraphs are magnified. We present a fairly simple and theoretically validated energy model for computing such layouts.
Keywords: clustering, focus + context, force-directed methods, graph drawing, information visualization, program understanding, refactoring, reverse engineering, software visualization
Voronoi treemaps for the visualization of software metrics BIBAKFull-Text 165-172
  Michael Balzer; Oliver Deussen; Claus Lewerentz
In this paper we present a hierarchy-based visualization approach for software metrics using Treemaps. Contrary to existing rectangle-based Treemap layout algorithms, we introduce layouts based on arbitrary polygons that are advantageous with respect to the aspect ratio between width and height of the objects and the identification of boundaries between and within the hierarchy levels in the Treemap. The layouts are computed by the iterative relaxation of Voronoi tessellations. Additionally, we describe techniques that allow the user to investigate software metric data of complex systems by utilizing transparencies in combination with interactive zooming.
Keywords: software metrics, treemaps, voronoi diagrams

Visualization frameworks and empirical evaluation

Online-configuration of software visualizations with Vizz3D BIBAFull-Text 173-182
  Thomas Panas; Rüdiger Lincke; Welf Löwe
A software visualization is defined by an abstract software model, views on this model and a mapping between them. For creating new visualizations, we online-configure views and their mappings instead of hand-coding them. In this paper, we introduce an architecture allowing such an online configuration and, as a proof of concept, a framework implementing this architecture. In several examples, we demonstrate generality and flexibility of our approach.
Towards understanding programs through wear-based filtering BIBAKFull-Text 183-192
  Robert DeLine; Amir Khella; Mary Czerwinski; George Robertson
Large software projects often require a programmer to make changes to unfamiliar source code. This paper presents the results of a formative observational study of seven professional programmers who use a conventional development environment to update an unfamiliar implementation of a commonly known video game. We describe several usability problems they experience, including keeping oriented in the program's source text, maintaining the number and layout of open text documents and relying heavily on textual search for navigation. To reduce the cost of transferring knowledge about the program among developers, we propose the idea of wear-based filtering, a combination of computational wear and social filtering. The development environment collects interaction information, as with computational wear, and uses that information to direct the attention of subsequent users, as with social filtering. We present sketches of new visualizations that use wear-based filtering and demonstrate the feasibility of our approach with data drawn from our study.
Keywords: collaborative filtering, computational wear, implicit query, program comprehension, software visualization
On the use of visualization to support awareness of human activities in software development: a survey and a framework BIBAKFull-Text 193-202
  Margaret-Anne D. Storey; A Davor Cubranic; Daniel M. German
This paper proposes a framework for describing, comparing and understanding visualization tools that provide awareness of human activities in software development. The framework has several purposes -- it can act as a formative evaluation mechanism for tool designers; as an assessment tool for potential tool users; and as a comparison tool so that tool researchers can compare and understand the differences between various tools and identify potential new research areas. We use this framework to structure a survey of visualization tools for activity awareness in software development. Based on this survey we suggest directions for future research.
Keywords: awareness, computer supported collaborative work, software development, visualization