| Algorithm visualization using concept keyboards | | BIBAK | Full-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 | | BIBAK | Full-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 | | BIBAK | Full-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 | |||
| Visual data mining in software archives | | BIBA | Full-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 | | BIBAK | Full-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 | | BIBAK | Full-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 | | BIBAK | Full-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 | |||
| Visual specification and analysis of use cases | | BIBAK | Full-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) | | BIBAK | Full-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 | |||
| Methodology and architecture of JIVE | | BIBA | Full-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 | | BIBAK | Full-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 | | BIBAK | Full-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 | |||
| Visualizing structural properties of irregular parallel computations | | BIBAK | Full-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 | | BIBAK | Full-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 | | BIBAK | Full-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 | |||
| A space of layout styles for hierarchical graph models of software systems | | BIBAK | Full-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 | | BIBAK | Full-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 | |||
| Online-configuration of software visualizations with Vizz3D | | BIBA | Full-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 | | BIBAK | Full-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 | | BIBAK | Full-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 | |||