VISSOFT 2015
2015 IEEE 3rd Working Conference on Software Visualization (VISSOFT)
Powered by
Conference Publishing Consulting

2015 IEEE 3rd Working Conference on Software Visualization (VISSOFT), September 27-28, 2015, Bremen, Germany

VISSOFT 2015 – Proceedings

Contents - Abstracts - Authors
Online Calendar - iCal File

Frontmatter

Title Page

Message from the Chairs
VISSOFT is the premier conference on software visualization and related theory and practices in software comprehension. VISSOFT 2015 has taken place in Bremen, Germany. This conference is the third in line after the recent merger of the ACM Symposium on Software Visualization and the IEEE International Workshop on Visualizing Software for Understanding and Analysis (VISSOFT). VISSOFT 2015 focuses specifically on visualization techniques that draw on aspects of software maintenance, software evolution, program comprehension, reverse engineering and reengineering. As was the case for the first edition of VISSOFT, we are colocated with the 31th International Conference on Software Maintenance and Evolution (ICSME).
Artifact Evaluation
Results presented in technical papers are often validated or supported by artifacts. Typical artifacts are software, data sets, or detailed experimental descriptions. To reward the effort of creating artifacts, authors of accepted research papers may, if they wish, have their tools, data, or models evaluated by the Artifact Evaluation Committee (AEC).

Keynote

Pervasive Software Visualizations (Keynote)
Tudor Gîrba and Andrei Chiş
(tudorgirba.com, Switzerland; University of Bern, Switzerland)
A picture tells a thousand words. We all know that. Then why are our development tools showing mainly text with so much obstinacy? Even when visualizations do make it into our tools, they typically do not make it past the periphery. Something is deeply wrong. We argue that visualizations must become pervasive in software development, and to accommodate this goal, the integrated development environments must change significantly.
Article Search

Technical Papers

Stable Voronoi-Based Visualizations for Software Quality Monitoring
Rinse van Hees and Jurriaan Hage
(Utrecht University, Netherlands)
Voronoi treemaps can be used to effectively visualize software quality attributes of a given software system. To easily keep track of how the values of such attributes change over time as the software evolves from one version to the next, it is essential that the produced visualizations are stable in the sense that small changes to the values of the attributes lead to small changes in the visualization. Due to the non-deterministic nature of the standard algorithm for computing Voronoi treemaps, stability is not guaranteed. In this paper we introduce stable Voronoi treemaps for additively weighted power Voronoi diagrams. We employ scaled Hilbert curves to place Voronoi sites in the plane, thereby achieving a predictable first good approximation of the final location of the sites, and then retain the order in which sites are placed along that curve for easy comparison with revisions of the same software system.We show that our algorithm not only provides more stability, but also that because of better placement it needs fewer iterations to compute its result.
Article Search
Visual Analytics of Software Structure and Metrics
Taimur Khan, Henning Barthel, Achim Ebert, and Peter Liggesmeyer
(TU Kaiserslautern, Germany; Fraunhofer IESE, Germany)
In terms of software maintenance and comprehension, the fields of software engineering and software visualization have produced several methods and tools. However, they are typically separate tools in practice. In this paper, we present a novel methodology of combining software analysis and software visualization tools via an interactive visual workflow modeling approach. Standard software analysis tools are also limited in that they support only well-known metrics or are too complicated to use for generating custom software metrics. To address these shortcomings, our approach focuses on visual elements, their configurations, and interconnectivity rather than a data ontology and querying language. In order to test and validate our methodology, we developed a prototype tool called VIMETRIK (Visual Specification of Metrics). Our preliminary evaluation study illustrates the intuitiveness and ease-of-use of our approach with regard to understanding software measurement and analysis data.
Article Search
Vestige: A Visualization Framework for Engineering Geometry-Related Software
Teseo Schneider, Patrick Zulian, Mohammad R. Azadmanesh, Rolf Krause, and Matthias Hauswirth
(University of Lugano, Switzerland)
Geometry-related software is increasingly important in computational science and visual computing. Engineering such software is particularly challenging due to the size and complexity of the data it operates on. In this paper we present Vestige, a framework that employs visualization to address that challenge. Vestige targets four software engineering activities: (1) visualization-guided development, (2) monitoring and bug detection, (3) test oracle generation, and (4) debugging. We present five scenarios from our real-life experience as developers of geometry-related software that show how Vestige helps to improve the software development process. Integrating Vestige into the development workflow takes little effort and can have significant benefits.
Article Search Video
Hierarchical Software Landscape Visualization for System Comprehension: A Controlled Experiment
Florian Fittkau, Alexander Krause, and Wilhelm Hasselbring
(Kiel University, Germany)
In many enterprises the number of deployed applications is constantly increasing. Those applications - often several hundreds - form large software landscapes. The comprehension of such landscapes is frequently impeded due to, for instance, architectural erosion, personnel turnover, or changing requirements. Therefore, an efficient and effective way to comprehend such software landscapes is required. The current state of the art often visualizes software landscapes via flat graph-based representations of nodes, applications, and their communication. In our ExplorViz visualization, we introduce hierarchical abstractions aiming at solving typical system comprehension tasks fast and accurately for large software landscapes. To evaluate our hierarchical approach, we conduct a controlled experiment comparing our hierarchical landscape visualization to a flat, state-of-the-art visualization. In addition, we thoroughly analyze the strategies employed by the participants and provide a package containing all our experimental data to facilitate the verifiability, reproducibility, and further extensibility of our results. We observed a statistically significant increase of 14% in task correctness of the hierarchical visualization group compared to the flat visualization group in our experiment. The time spent on the system comprehension tasks did not show any significant differences. The results backup our claim that our hierarchical concept enhances the current state of the art in landscape visualization.
Article Search Info aec-badge-vissoft
A Survey on Goal-Oriented Visualization of Clone Data
Hamid Abdul Basit, Muhammad Hammad, and Rainer Koschke
(Lahore University of Management Sciences, Pakistan; PITB, Pakistan; University of Bremen, Germany)
Comprehending software clones is necessary for a number of activities in software development. The comprehension of software clones is challenged by the sheer volume of data and the complexity of the information content in that data. Visualization, or visual data analysis, takes advantage of human cognitive skills to discover unstructured insights from the visual presentations of complex and voluminous data. In this paper, we survey the existing literature on visualization of software clones. We gather the insights provided, and put that information in context of actual information needs systematically derived from the clone management goals. This framework allows us to better understand the role a visualization may play in achieving a specific user goal, identify potential gaps between existing types of visualization and information needs, and find complementary non-redundant subsets of visualizations for each user goal.
Article Search
Interactive Tag Cloud Visualization of Software Version Control Repositories
Gillian J. Greene and Bernd Fischer
(Stellenbosch University, South Africa)
Version control repositories contain a wealth of implicit information that can be used to answer many questions about a project’s development process. However, this information is not directly accessible in the version control archives and must be extracted and visualized. This paper describes ConceptCloud, a flexible, interactive browser for SVN and Git repositories. The main novelty of our approach is the combination of an intuitive tag cloud visualization with an underlying concept lattice that provides a formal structure for navigation. ConceptCloud supports concurrent navigation in multiple linked but individually customizable tag clouds, which allows for multi-faceted repository browsing and for the construction of unique visualizations. We describe the mathematical foundations and implementation of our approach, and use ConceptCloud to quickly gain insight into the team structure and development process of two projects.
Article Search aec-badge-vissoft
Visualising Software as a Particle System
Simon Scarle and Neil Walkinshaw
(University of the West of England, UK; University of Leicester, UK)
Current metrics-based approaches to visualise unfamiliar software systems face two key limitations: (1) They are limited in terms of the number of dimensions that can be projected, and (2) they use fixed layout algorithms where the resulting positions of entities can be vulnerable to misinterpretation. In this paper we show how computer games technology can be used to address these problems. We present the PhysVis software exploration system, where software metrics can be variably mapped to parameters of a physical model and displayed via a particle system. Entities can be imbued with attributes such as mass, gravity, and (for relationships) strength or springiness, alongside traditional attributes such as position, colour and size. The resulting visualisation is a dynamic scene; the relative positions of entities are not determined by a fixed layout algorithm, but by intuitive physical notions such as gravity, mass, and drag. The implementation is openly available, and we evaluate it on a selection of visualisation tasks for two openly-available software systems.
Article Search
A Visual Support for Decomposing Complex Feature Models
Simon Urli, Alexandre Bergel, Mireille Blay-Fornarino, Philippe Collet, and Sébastien Mosser
(University of Nice Sophia Antipolis, France; CNRS, France; University of Chile, Chile)
In Software Product Line (SPL) engineering, Feature Models (FMs) are widely used to capture and manage variability in a sound and organized fashion. Though semantics, notations and reasoning support are well established, maintaining large FMs is still an open problem. As large FMs naturally contain different concerns, some related to domains, others being inherently cross-cutting ones, it is challenging to find a decomposition that will tame this complexity and ease maintenance. This paper presents a visual representation of dependent FMs useful in decomposing a large FM while quantitatively visualizing constraints between and inside them. This Variability Blueprint is intuitive enough to enable the SPL maintainer to confine dependencies between FMs in a small set of identified features inside each decomposed FM. We describe our blueprint and report on its application on two case studies.
Article Search
Revealing Runtime Features and Constituent Behaviors within Software
Vijay Krishna Palepu and James A. Jones
(University of California at Irvine, USA)
Software engineers organize source code into a dominant hierarchy of components and modules that may emphasize various characteristics over runtime behavior. In this way, runtime features may involve cross-cutting aspects of code from multiple components, and some of these features may be emergent in nature, rather than designed. Although source-code modularization assists software engineers to organize and find components, identifying such cross-cutting feature sets can be more difficult. This work presents a visualization that includes a static (i.e., compile-time) representation of source code that gives prominence to clusters of cooperating source-code instructions to identify dynamic (i.e., runtime) features and constituent behaviors within executions of the software. In addition, the visualization animates software executions to reveal which feature clusters are executed and in what order. The result has revealed the principal behaviors of software executions, and those behaviors were revealed to be (in some cases) cohesive, modular source-code structures and (in other cases) cross-cutting, emergent behaviors that involve multiple modules. In this paper, we describe our system (Cerebro), envisage the uses to which it can be put, and evaluate its ability to reveal emergent runtime features and internal constituent behaviors of execution. We found that: (1) the visualization revealed emergent and commonly occuring functionalities that cross-cut the structural decomposition of the system; (2) four independent judges generally agreed in their interpretations of the code clusters, especially when informed only by our visualization; and (3) interacting with the external interface of an application while simultaneously observing the internal execution facilitated localization of code that implements the features and functionality evoked externally.
Article Search
CodeSurveyor: Mapping Large-Scale Software to Aid in Code Comprehension
Nathan Hawes, Stuart Marshall, and Craig Anslow
(Oracle Labs, Australia; Victoria University of Wellington, New Zealand; Middlesex University, UK)
Large codebases — in the order of millions of lines of code (MLOC) — are incredibly complex. Whether fixing a fault, or implementing a new feature, changes to such systems often have unanticipated effects, as it is impossible for a developer to maintain a complete understanding of the code in their head. This paper presents CodeSurveyor, a spatial visualization technique that aims to support code comprehension in large codebases by allowing developers to view large-scale software at all levels of abstraction. It uses a cartographic metaphor to produce an interactive map of a codebase where users can zoom from a view of a system’s high-level architectural components, represented as continents, down to the individual source files and the entities they define, shown as countries and states, respectively. The layout of the produced code map incorporates system dependency data and sizes regions according to a user-configurable metric (line count by default), to create distinctive shapes and positions that serve as strong visual landmarks and keep users oriented. We detail the CodeSurveyor algorithm, show it generates code maps of the Linux kernel (1.4 MLOC) in 1.5 minutes, and evaluate the intuitiveness of the metaphor to software developers and its utility in navigation tasks. Results show the effectiveness of the approach with developers of varying experience levels.
Article Search
Blended, Not Stirred: Multi-concern Visualization of Large Software Systems
Tommaso Dal Sasso, Roberto Minelli, Andrea Mocci, and Michele Lanza
(University of Lugano, Switzerland)
While constructing and evolving software systems, developers generate directly and indirectly a large amount of data of diverse nature, such as source code changes, bug tracking information, IDE interactions, stack traces, etc. Often these diverse data sources are processed and visualized in isolation, leading to a partial view of systems. We present a blended approach to visualize several data “ingredients” at once, to give as complete an answer as possible to the question “What happened to the system in the last few days?”. The goal is to enable a quick and comprehensive assessment of what happened to a software system in any given time frame.
Article Search
Visualizing Work Processes in Software Engineering with Developer Rivers
Michael Burch, Tanja Munz, Fabian Beck, and Daniel Weiskopf
(University of Stuttgart, Germany)
Work processes involving dozens or hundreds of collaborators are complex and difficult to manage. Problems within the process may have severe organizational and financial consequences. Visualization helps monitor and analyze those processes. In this paper, we study the development of large software systems as an example of a complex work process. We introduce Developer Rivers, a timeline-based visualization technique that shows how developers work on software modules. The flow of developers' activity is visualized by a river metaphor: activities are transferred between modules represented as rivers. Interactively switching between hierarchically organized modules and workload metrics allows for exploring multiple facets of the work process. We study typical development patterns by applying our visualization to Python and the Linux kernel.
Article Search

New Ideas and Emerging Results

Research Perspective on Supporting Software Engineering via Physical 3D Models
Florian Fittkau, Erik Koppenhagen, and Wilhelm Hasselbring
(Kiel University, Germany)
Building architects, but also civil or mechanical engineers often build from their designs physical 3D models for a better presentation, comprehension, and communication among stakeholders. Software engineers usually create visualizations of their software designs as digital objects to be presented on a screen only. 3D software visualization metaphors, such as the software city metaphor, provide a basis for exporting those on-screen software visualizations into physical models. This can be achieved by 3D-printers to transfer the advantages of real, physical, tangible architecture models from traditional engineering disciplines to software engineering. We present a new research perspective of using physical models to support software engineering. Furthermore, we describe four envisioned usage scenarios for physical models which provide a plethora of new research topics. To examine the benefits of our concept, we investigate the first usage scenario by evaluating the impact of using physical models on program comprehension in teams through a first controlled experiment. Since the usage of physical models had a diverging influence for our chosen task set, we report on the qualitative results in this paper. We observed that the physical models improved the team-based program comprehension process for specific tasks by initiating gesture-based interaction.
Article Search Video Info
Exploring Software Cities in Virtual Reality
Florian Fittkau, Alexander Krause, and Wilhelm Hasselbring
(Kiel University, Germany)
Software visualizations, such as the software city metaphor, are usually displayed on 2D screens and controlled by means of a mouse and thus often do not take advantage of more natural interaction techniques. Virtual reality (VR) approaches aim to improve the user experience. Emerging new technologies, like the Oculus Rift, dramatically enhance the VR experience at an affordable price. Therefore, new technologies have the potential to provide even higher immersion - and thus benefits - than previous VR approaches. We present a VR approach to explore software visualizations following the software city metaphor by using a head-mounted display and gesture-based interaction. Furthermore, we detail our gesture design and how we implemented this approach into our web-based ExplorViz tool. As first evaluation, we conducted structured interviews where participants had to solve three program comprehension tasks and rate the usability of the used gestures and general VR experience for program comprehension. The participants of our interviews rated the developed gestures for translation, rotation, and selection as highly usable. However, our zooming gesture was less favored. In general, the subjects see potential for virtual reality in program comprehension.
Article Search Video Info
From Robots to Humans: Visualizations for Robot Sensor Data
Miguel Campusano and Johan Fabry
(University of Chile, Chile)
In a robotics context, visualizing the data scanned by a robot is crucial to understand what the robot's sensors perceive about its environment. Consequently, robotic visualizations show these values in a 3-D world, such that they can be compared with the real world. However these visualizations do not allow developers to see this data in a manner that allows it to be interpreted for program construction. As a result, these visualizations are in many cases ineffective for programming robot behaviors. To address this issue, we have built several visualizations of robot sensor data for the programming of behaviors, and we report on them here. Our visualizations focus on better revealing the hard data, which allows developers to faster understand it and consequently to faster create and adapt robot behaviors.
Article Search
Visualizing Interactive and Shared Debugging Sessions
Fabio Petrillo, Guilherme Lacerda, Marcelo Pimenta, and Carla Freitas
(Federal University of Rio Grande do Sul, Brazil; UniRitter, Brazil)
Debugging is a tedious and time-consuming task since it is a methodical process of finding causes and reducing the number of defects. During debugging sessions, developers run a software project, traversing method invocations, setting breakpoints, stopping or restarting executions. In these sessions, developers explore some project areas and create knowledge about them. Unfortunately, when these sessions finish, this knowledge is lost, and developers cannot use it in other debugging sessions or sharing it with collaborators. In this paper, we present Swarm Debugging, a new approach for visualizing and sharing information obtained from debugging sessions. Swarm Debugging provides interactive and real-time visualizations, and several searching tools. Our approach was implemented as an Eclipse IDE plugin, using the Java Platform Debugging Architecture (JPDA) and web technologies to collect and visualize data. We present a running prototype and show how our approach offers more useful support for many typical development tasks than a traditional debugger tool. Through usage scenarios, we demonstrate that our approach can aid developers to decrease the required time for deciding where to toggle a breakpoint and locate bug causes.
Article Search Video
On Understanding How Developers Use the Spotter Search Tool
Juraj Kubelka, Alexandre Bergel, Andrei Chiş, Tudor Gîrba, Stefan Reichhart, Romain Robbes, and Aliaksei Syrel
(University of Chile, Chile; University of Bern, Switzerland; tudorgirba.com, Switzerland)
Analyzing how software engineers use the Integrated Development Environment (IDE) is essential to better understanding how engineers carry out their daily tasks. SPOTTER is a code search engine for the Pharo programming language. Since its inception, SPOTTER has been rapidly and broadly adopted within the Pharo community. However, little is known about how practitioners employ SPOTTER to search and navigate within the Pharo code base. This paper evaluates how software engineers use SPOTTER in practice. To achieve this, we remotely gather user actions called events. These events are then visually rendered using an adequate navigation tool chain. Sequences of events are represented using a visual alphabet. We found a number of usage patterns and identified underused SPOTTER features. Such findings are essential for improving SPOTTER.
Article Search
Unified Model for Software Engineering Data
Anna-Liisa Mattila, Antti Luoto, Henri Terho, Otto Hylli, Outi Sievi-Korte, and Kari Systä
(Tampere University of Technology, Finland)
Software process data is available in several tools such as version control systems, issue trackers and test and build systems to name a few. Using the data gathered in these software engineering tools would be ideal for collecting different kinds of software processes and product metrics as the data is already automatically gathered by the tools. However, the tools present and store the data in various formats. The data collection methods and interfaces also vary between the tools. This closes the software engineering data into silos and makes it hard to build reusable analysis and visualizations for the data. In this position paper we present a unified model for software engineering data and a framework for data collection, conversion and storing that utilizes our model. The aim of the model is to define a common format for software engineering data which is not dependent on specific software engineering tools or the software engineering process and thus can be used as a basis for building reusable visualization and analysis components. To demonstrate that we can build reusable visualization plugins on top of the framework, we created a timeline visualization plugin. The visualization plugin is used to visualize two data sets from industrial software projects that have different contexts and semantics.
Article Search
Visualization Based API Usage Patterns Refining
Mohamed Aymen Saied, Omar Benomar, and Houari Sahraoui
(Université de Montréal, Canada)
Learning to use existing or new software libraries is a difficult task for software developers, which would impede their productivity. Most of existing work provided different techniques to mine API usage patterns from client programs, in order to help developers to understand and use existing libraries. However, considering only client programs to identify API usage patterns, is a strong constraint as collecting several similar client programs for an API is not a trivial task. And even if these clients are available, all the usage scenarios of the API of interest may not be covered by those clients. In this paper, we propose a visualization based approach for the refinement of Client-based Usage Patterns. We first visualize the patterns structure. Then we enrich the patterns with API methods that are semantically related to them, and thus may contribute together to the implementation of a particular functionality for potential client programs.
Article Search
Pixel-Oriented Techniques for Visualizing Next-Generation HPC Systems
Joseph Cottam, Ben Martin, Luke Dalessandro, and Andrew Lumsdaine
(Indiana University, USA)
Visualization schemas need to be enhanced to support next-generation high-performance computing (HPC) environments. New HPC runtimes perform more actions in a unit of time, but they also perform a wider variety of actions. Existing schemas are too simple to illustrate the variety of information that HPC developers need. However, existing schemas can be extended in simple ways to become more effective for next-generation HPC environments. This paper presents extensions to the common Vampir style plot that use high-definition alpha composition and color weaving. These two techniques incorporate new detail into the traditional plot style, providing useful information for HPC developers.
Article Search
Extracting a Unified Directory Tree to Compare Similar Software Products
Yusuke Sakaguchi, Takashi Ishio, Tetsuya Kanda, and Katsuro Inoue
(Osaka University, Japan)
Source code is often reused in software development. Although developers can avoid re-implementing features in existing products, doing so may result in a large number of similar software products. To understand the commonalities and variabilities of similar products, comparing their source code is critical. However, a product may change its own directory structure, even if the products share the same source code with other products. Hence, comparing source code among products in a systematic manner is difficult. In this paper, we propose a technique to extract and visualize a unified directory tree to compare the source code of similar products. This tree includes all directories of given products and merges corresponding directories into a single node. Since a node in a tree corresponds to multiple directories in products, developers can easily compare the contents of products. In our study, we implemented the visualization as a GUI tool. In addition, we conducted a case study using four Android products to demonstrate the tool's ability to assist developers in accessing the source code of multiple products.
Article Search

Tools

Kayrebt: An Activity Diagram Extraction and Visualization Toolset Designed for the Linux Codebase
Laurent Georget, Frédéric Tronel, and Valérie Viet Triem Tong
(CentraleSupélec, France; INRIA, France; CNRS, France; University of Rennes 1, France)
We present Extractor and Viewer, two tools from the Kayrebt toolset. The former is a plugin for the Gnu Compiler Collection (GCC) which builds pseudo-UML2 activity diagrams from C source code. It is specifically designed to handle the Linux kernel, a large and complex codebase. Use cases for this tool are numerous. The diagrams extracted from the C source code can be used to get a better insight of the control or data flow inside a program, or to evaluate the complexity of a function at a glance. Kayrebt::Viewer is a GUI designed for visualizing and navigating between the diagrams to explore source code.
Article Search Video Info
SMNLV: A Small-Multiples Node-Link Visualization Supporting Software Comprehension by Displaying Multiple Relationships in Software Structure
Ala Abuthawabeh and Dirk Zeckzer
(TU Kaiserslautern, Germany; Leipzig University, Germany)
Software engineering tasks like understanding of (legacy) software, checking guidelines, finding structure, or reengineering of existing software require the analysis of the static software structure. The optimal visualization of this structure depends on the task at hand. In general, the software structure is mapped to a graph and graph drawing algorithms are used for displaying the structure. The task of drawing these graphs becomes more involved if not only one type of relations, e.g., call graphs, but many relation types should be analyzed at the same time. We propose a small-multiples node-link visualization, where each small visualization shows the graph related to one edge type. The visualizations are synchronized using selection and coordinated views. Using a separate view for each of the relations provides additional analysis capabilities. The main advantage of this approach is, that optimized drawing algorithms can be used for each type of relationship while being able to display multiple relationships at the same time.
Article Search Info
Polyhedral User Mapping and Assistant Visualizer Tool for the R-Stream Auto-Parallelizing Compiler
Eric Papenhausen, Bing Wang, M. Harper Langston, Muthu Baskaran, Tom Henretty, Taku Izubuchi, Ann Johnson, Chulwoo Jung, Meifeng Lin, Benoit Meister, Klaus Mueller, and Richard Lethin
(Stony Brook University, USA; Reservoir Labs, USA; Brookhaven National Laboratory, USA)
Existing high-level, source-to-source compilers can accept input programs in a high-level language (e.g., C) and perform complex automatic parallelization and other mappings using various optimizations. These optimizations often require trade-offs and can benefit from the user’s involvement in the process. However, because of the inherent complexity, the barrier to entry for new users of these high-level optimizing compilers can often be high. We propose visualization as an effective gateway for non-expert users to gain insight into the effects of parameter choices and so aid them in the selection of levels best suited to their specific optimization goals. A popular optimization paradigm is polyhedral mapping which achieves optimization by loop transformations. We have augmented a commercial polyhedral-model source-to-source compiler (R-Stream) with an interactive visual tool we call the Polyhedral User Mapping and Assistant Visualizer (PUMA-V). PUMA-V is tightly integrated with the R-Stream source-to-source compiler and allows users to explore the effects of difficult mappings and express their goals to optimize trade-offs. It implements advanced multivariate visualization paradigms such as parallel coordinates and correlation graphs and applies them in the novel setting of compiler optimizations. We believe that our tool allows programmers to better understand complex program transformations and deviations of mapping properties on well understood programs. This in turn will achieve experience and performance portability across programs architectures as well as expose new communities in the computational sciences to the rich features of auto-parallelizing high-level source-to-source compilers.
Article Search Video
Live Visualization of GUI Application Code Coverage with GUITracer
Arthur-Jozsef Molnar
(Babes-Bolyai University, Romania)
The present paper introduces the initial implementation of a software exploration tool targeting graphical user interface (GUI) driven applications. GUITracer facilitates the comprehension of GUI-driven applications by starting from their most conspicuous artefact - the user interface itself. The current implementation of the tool can be used with any Java-based target application that employs one of the AWT, Swing or SWT toolkits. The tool transparently instruments the target application and provides real time information about the GUI events fired. For each event, call relations within the application are displayed at method, class or package level, together with detailed coverage information. The tool facilitates feature location, program comprehension as well as GUI test creation by revealing the link between the application's GUI and its underlying code. As such, GUITracer is intended for software practitioners developing or maintaining GUI-driven applications. We believe our tool to be especially useful for entry-level practitioners as well as students seeking to understand complex GUI-driven software systems. The present paper details the rationale as well as the technical implementation of the tool. As a proof-of-concept implementation, we also discuss further development that can lead to our tool's integration into a software development workflow.
Article Search Video
OrionPlanning: Improving Modularization and Checking Consistency on Software Architecture
Gustavo Santos, Nicolas Anquetil, Anne Etien, Stéphane Ducasse, and Marco Tulio Valente
(INRIA, France; Federal University of Minas Gerais, Brazil)
Many techniques have been proposed in the lit- erature to support architecture definition, conformance, and analysis. However, there is a lack of adoption of such techniques by the industry. Previous work have analyzed this poor support. Specifically, former approaches lack proper analysis techniques (e.g., detection of architectural inconsistencies), and they do not provide extension and addition of new features. In this paper, we present ORIONPLANNING, a prototype tool to assist refactorings at large scale. The tool provides support for model- based refactoring operations. These operations are performed in an interactive visualization. The contributions of the tool consist in: (i) providing iterative modifications in the architecture, and (ii) providing an environment for architecture inspection and definition of dependency rules. We evaluate ORIONPLANNING against practitioners’ requirements on architecture definition listed in a previous survey. We also evaluate the tool in a concrete example of software remodularization.
Article Search Video
Explora: A Visualisation Tool for Metric Analysis of Software Corpora
Leonel Merino, Mircea Lungu, and Oscar Nierstrasz
(University of Bern, Switzerland)
When analysing software metrics, users find that visualisation tools lack support for (1) the detection of patterns within metrics; and (2) enabling analysis of software corpora. In this paper we present Explora, a visualisation tool designed for the simultaneous analysis of multiple metrics of systems in software corpora. Explora incorporates a novel lightweight visualisation technique called PolyGrid that promotes the detection of graphical patterns. We present an example where we analyse the relation of subtype polymorphism with inheritance and invocation in corpora of Smalltalk and Java systems and find that (1) subtype polymorphism is more likely to be found in large hierarchies; (2) as class hierarchies grow horizontally, they also do so vertically; and (3) in polymorphic hierarchies the length of the name of the classes is orthogonal to the cardinality of the call sites.
Article Search Video Info
Advancing Data Race Investigation and Classification through Visualization
Nikolaos Koutsopoulos, Mandy Northover, Timm Felden, and Martin Wittiger
(University of Stuttgart, Germany)
Data races in multi-threaded programs are a common source of serious software failures. Their undefined behavior may lead to intermittent failures with unforeseeable, and in embedded systems, even life-threatening consequences. To mitigate these risks, various detection tools have been created to help identify potential data races. However, these tools produce thousands of data race warnings, often in text-based format, which makes the manual assessment process slow and error-prone. Through visualization, we aim to speed up the data race assessment process by reducing the amount of information to be investigated, and to provide a versatile interface that quality assurance engineers can use to investigate data race warnings. The ultimate goal of our integrated software suite, called RaceView, is to improve the usability of the data race information to such an extent that the elimination of data races can be incorporated into the regular software development process.
Article Search
Spider SENSE: Software-Engineering, Networked, System Evaluation
Nishaanth H. Reddy, Junghun Kim, Vijay Krishna Palepu, and James A. Jones
(University of California at Irvine, USA)
Today, many of the research innovations in software visualization and comprehension are evaluated on small-scale programs in a way that avoids actual human evaluation, despite the fact that these techniques are designed to help programmers develop and understand large and complex software. The investments required to perform such human studies often outweigh the need to publish. As such, the goal of this work (and toolkit) is to enable the evaluation of software visualizations of real-life software systems by its actual developers, as well as to understand the factors that influence adoption. The approach is to directly assist practicing software developers with visualizations through open and online collaboration tools. The mechanism by which we accomplish this goal is an online service that is linked through the projects' revision-control and build systems. We are calling this system Spider SENSE, and it includes web-based visualizations for software exploration that is supported by tools for mirroring development activities, automatic building and testing, and automatic instrumentation to gather dynamic-analysis data. In the future, we envision the system and toolkit to become a framework on which further visualizations and analyses are developed. Spider SENSE is open-source and publicly available for download and collaborative development.
Article Search
xViZiT: Visualizing Cognitive Units in Spreadsheets
Karin Hodnigg and Martin Pinzger
(University of Klagenfurt, Austria)
Spreadsheets can be large and complex and their maintenance and comprehension difficult to end-users. Large numbers of cells, complex formulae and missing documentation can impede the understanding of a spreadsheet. Comprehension assesses different levels of a spreadsheet according to a specific maintenance task, ranging from single formulae over sets of cells to complex structural patterns. These levels of abstraction are subsumed under the term cognitive unit. XVIZIT helps end-users in maintaining and comprehending spreadsheets. It guides them through a spreadsheet model: Roles of cells and sheets, similar patterns and various concepts of modularity can be explored. It uses modularization algorithms to provide conceptional decompositions of a spreadsheet model, such as equivalence classes or data modules. XVIZIT’s slice visualizations ease the evaluation of corrective modifications by showing the dependant cells. Furthermore, XVIZIT provides a number of complexity measures allowing end-users to estimate the effort to comprehend and maintain a spreadsheet.
Article Search Info

proc time: 0.17