Conference Paper

Exploring the Evolution of Software Quality with Animated Visualization

Authors:
To read the full-text of this research, you can request a copy directly from the authors.

Abstract

Assessing software quality and understanding how events in its evolution have lead to anomalies are two important steps toward reducing costs in software maintenance. Unfortunately, evaluation of large quantities of code over several versions is a task too time-consuming, if not overwhelming, to be applicable in general. To address this problem, we designed a visualization framework as a semi-automatic approach to quickly investigate programs composed of thousands of classes, over dozens of versions. Programs and their associated quality characteristics for each version are graphically represented and displayed independently. Real-time navigation and animation between these representations recreate visual coherences often associated with coherences intrinsic to subsequent software versions. Exploiting such coherences can reduce cognitive gaps between the different views of software, and allows human experts to use their visual capacity and intuition to efficiently investigate and understand various quality aspects of software evolution. To illustrate the interest of our framework, we report our results on two case studies.

No full-text available

Request Full-text Paper PDF

To read the full-text of this research,
you can request a copy directly from the authors.

... 44 3.26 Timeline [WL08a] pour visualiser l'évolution de la classe : Graphics3D du logiciel Jmol . . . 47 3.29 Visualisation de l'évolution avec VERSO [LSP08] . . 49 ix . . ...
... La visualisation VERSO par Langelier, Sahraoui et Poulin, présentée en section 3.4.3, permet egalement de mettre enévidence l'évolution du logiciel [LSP08]. Les figures 3.29(a) et 3.29(b) montrent respectivement la visualisation avec VERSO d'un logiciel en version 1 et version 2. Une interpolation linéaire qui modifie simultanément les trois caractéristiques visuelles (la couleur, la taille et l'angle) est appliquée aux objets de la représentation graphique afin de créer une animation qui permet de passer de la version 1à la version 2. Cette animation ne dure qu'une seconde, mais elle attire l'attention de l'utilisateur sur les changements et permet une meilleure compréhension qu'en sautant brutalementà la visualisation de la version suivante [SIG07]. ...
... La contrainte principale de la métaphore de la ville est que cette dernière est représentée sur un (seul) plan [LSP08], ce qui est problématique pour la représentation des relations entré eléments. Même si certains travaux tentent de donner de la hauteurà la métaphore de la ville, comme par exemple les travaux présentés chapitre 3 section 3.4.3 ...
Thesis
Ce travail s'inscrit dans le cadre des recherches menées autour de l'analyse et la visualisation des logiciels, notamment les logiciels à objets, et en particulier Java. Très brièvement, on peut dire que le but de cette thèse revient à tenter de répondre à une question fondamentale: comment faire pour faciliter la compréhension du logiciel par ses développeurs et concepteurs ? Ce travail de recherche est basé en grande partie sur deux axes principaux. Le premier consiste à analyser l'exécution des programmes, non seulement au niveau de la méthode, mais bien au niveau du bloc de base, pour recueillir des données d'exécutions avec un maximum de précision comme par exemple les différents types d'instances sur les sites d'appels. Le second axe considère l'utilisation des informations apportées par notre analyse dynamique de l'exécution pour permettre la visualisation de ces données. En effet, ces informations offrent des détails intéressants sur le fonctionnement du programme et aident à expliquer le comportement du logiciel, aussi bien pour déceler les problèmes de performance que les problèmes de codages. Nous proposons une technique souple et efficace qui effectue une analyse dynamique de l'exécution de programmes Java. Nous introduisons ainsi une nouvelle technique et un nouvel outil permettant de recueillir des informations encore non proposées par d'autres analyseurs. Cette approche trace l'exécution précise des programmes tout en ayant une baisse des performances d'exécution acceptable, laissant le programme final utilisable. De plus, nous proposons et expérimentons une approche basé sur la visualisation des relations au sein d'une représentation du logiciel par une métaphore de ville. Nous introduisons une nouvelle technique de représentation des relations nommée "3D HierarchicalEdge Bundles" qui est basée sur une représentation 2D existante nommée "HierarchicalEdge Bundles". Cette approche conserve la puissance de visualisation du logiciel offerte par la métaphore de la ville tout en ajoutant la représentation des relations, et cela d'une façon lisible. Ces travaux sont validés entre autres par le développement d'un outil d'analyse nommé VITRAIL JBInsTrace et d'un outil de visualisation nommé VITRAIL Visualizer. Ces outils sont la base de nos recherche actuelles sur l'étude de l'exécution des programmes objets
... 44 3.26 Timeline [WL08a] pour visualiser l'évolution de la classe : Graphics3D du logiciel Jmol . . . 47 3.29 Visualisation de l'évolution avec VERSO [LSP08] . . 49 ix . . ...
... La visualisation VERSO par Langelier, Sahraoui et Poulin, présentée en section 3.4.3, permet egalement de mettre enévidence l'évolution du logiciel [LSP08]. Les figures 3.29(a) et 3.29(b) montrent respectivement la visualisation avec VERSO d'un logiciel en version 1 et version 2. Une interpolation linéaire qui modifie simultanément les trois caractéristiques visuelles (la couleur, la taille et l'angle) est appliquée aux objets de la représentation graphique afin de créer une animation qui permet de passer de la version 1à la version 2. Cette animation ne dure qu'une seconde, mais elle attire l'attention de l'utilisateur sur les changements et permet une meilleure compréhension qu'en sautant brutalementà la visualisation de la version suivante [SIG07]. ...
... La contrainte principale de la métaphore de la ville est que cette dernière est représentée sur un (seul) plan [LSP08], ce qui est problématique pour la représentation des relations entré eléments. Même si certains travaux tentent de donner de la hauteurà la métaphore de la ville, comme par exemple les travaux présentés chapitre 3 section 3.4.3 ...
Article
This work falls within the scope of research pertaining to the analysis and the visualization of software systems, especially for object oriented languages, and more precisely Java. In a nutshell, it can be said the aim of this thesis is to try to answer a fundamental question: what can we do to ease the understanding of software by its designers and developers ? This research work is mainly based on two axes. The first axis consists in analyzing software runtime, not only at method level, but also at basic bloc level, so as to be able to get meaningful and precise information about the runtime. For instance, we can acquire the different types of instances on call sites at runtime. The second axis considers the use of information coming from our dynamic analyzer of software runtime and allowing the visualization of these data. Indeed, this kind of information offers important details about software functioning and provide a way to explain the behavior of software, so as to identify performance, coding and even design and architecture issues. We propose a technique that allows flexible and efficient dynamic analysis of the execution of Java programs. We thus introduce a new technique and tool for gathering information not yet offered by other analyzers. This approach precisely traces the execution of programs with acceptable performance penalty, that is while keeping the traced programs usable. In addition, we propose and experiment an approach based on visualizing relationships within a software city representation. We introduce a new technique for representing relationships in 3D named the "3D Hierarchical Edge Bundles" that is based on an existing 2D technique, the "Hierarchical Edge Bundles". This approach keeps the power of the software city metaphor while adding the representation of the relationships within the software, in a readable way. These works are validated by, among others things, the development of a tracer and analyzer tool called VITRAIL JBInsTrace and a visualization tool called VITRAIL Visualizer. These tools are used on our current researches which consist in studying runtime of object-oriented programs.
... Software metrics are an ideal abstraction as they encapsulate, summarize, and provide essential quality information about source code [44]. As such, they are essential in providing a continual understanding and analysis of the quality of a system during all phases of the product life cycle. ...
... The visualization framework by Langelier et al. also facilitates the analysis of software over many versions [44], albeit in a slightly different manner. Instead of employing a technique that displays the entire system evolution in one picture [45], they rely on animated transitions from one version to another. ...
... The user controls forward and backward navigation in time, which in turn animates three graphical characteristics that are mapped to metric values -color, height, and twist. While the animations are of a short duration, they are well-designed and help attract the attention of the viewer towards program modifications [44]. This work of Langelier et al. contains references to extensive case studies aimed at detecting both evolution patterns and known anomalies. ...
Conference Paper
Software systems are an integral component of our everyday life as we find them in tools and embedded in equipment all around us. In order to ensure smooth, predictable, and accurate operation of these systems, it is crucial to produce and maintain systems that are highly reliable. A well-designed and well-maintained architecture goes a long way in achieving this goal. However, due to the intangible and often complex nature of software architecture, this task can be quite complicated. The field of software architecture visualization aims to ease this task by providing tools and techniques to examine the hierarchy, relationship, evolution, and quality of architecture components. In this paper, we present a discourse on the state of the art of software architecture visualization techniques. Further, we highlight the importance of developing solutions tailored to meet the needs and requirements of the stakeholders involved in the analysis process.
... Reported in Graph-based [7], [8], [9], [10], [11], [12], [13], [14], [15], [16], [17], [18] Notation-based [19] Matrix-based [7], [13], [15], [20], [21], [22], [23], [24], [25], [26] Metaphor-based [27], [28] Others [9], [29], [30], [31], [32] Following is a brief discussion of the above mentioned visualization techniques: ...
... Artifact-based [9], [11], [14], [15], [18], [20], [23], [24], [25], [26], [27], [29], [34], [30], [35] Metric-based [21], [22], [28] Feature-based [10], [16], [31], [32], [36] Architecture-based [7], [8], [12], [13], [17], [19], [25] Following is a brief discussion of McNair et al. [19] categories: ...
Conference Paper
Full-text available
Background: Software is an important asset for organizations and development teams. It must evolve over time in order to meet different changes in its environment, satisfy the developers' needs, and adapt to new requirements.
... YARN [21] can represent evolving couplings using animated node-link diagrams, but only supports high level abstractions (packages). Langelier et al. (2008) [22] uses an animated 3D model to show the evolving hierarchical structure of software, as well as changes in terms of metrics. IHVis [23] allows visualizing the evolution of design structures using node-link diagrams, but may have scalability issues and cannot show the evolution of multiple types of couplings. ...
... YARN [21] can represent evolving couplings using animated node-link diagrams, but only supports high level abstractions (packages). Langelier et al. (2008) [22] uses an animated 3D model to show the evolving hierarchical structure of software, as well as changes in terms of metrics. IHVis [23] allows visualizing the evolution of design structures using node-link diagrams, but may have scalability issues and cannot show the evolution of multiple types of couplings. ...
Conference Paper
Full-text available
Software designs are ever changing to adapt to new environments and requirements. Tracking and understanding changes in modules and relationships in a software project is difficult, but even more so when the software goes through several types of changes. The typical complexity and size of software also makes it harder to grasp software evolution patterns. In this paper, we present an interactive matrix-based visualization technique that, combined with animation, depicts how software designs evolve. For example, it shows which new modules and couplings are added and removed over time. Our generic visualization supports dynamic and weighted digraphs and is applied in the context of software evolution. Analyzing source code changes is important to determine the software's structural organization and identify quality issues over time. To demonstrate our approach, we explore open-source repositories and discuss some of our findings regarding these evolving software designs.
... The VERSO visualization by Langelier et al., presented in Section 4.3, allows the analysis of software over many versions [53]. Fig. 29a shows the appearance with VERSO of a preliminary version of a software. ...
... Visualization of evolution with VERSO from[53].Fig. 30. ...
Article
Software is usually complex and always intangible. In practice, the development and maintenance processes are time-consuming activities mainly because software complexity is difficult to manage. Graphical visualization of software has the potential to result in a better and faster understanding of its design and functionality, thus saving time and providing valuable information to improve its quality. However, visualizing software is not an easy task because of the huge amount of information comprised in the software. Furthermore, the information content increases significantly once the time dimension to visualize the evolution of the software is taken into account. Human perception of information and cognitive factors must thus be taken into account to improve the understandability of the visualization. In this paper, we survey visualization techniques, both 2D- and 3D-based, representing the static aspects of the software and its evolution. We categorize these techniques according to the issues they focus on, in order to help compare them and identify the most relevant techniques and tools for a given problem.
... Some approaches enrich software maps with animations to display dynamic information over time (Lemieux and Salois, 2006, sec. 3.4) that can relate to the behavior or evolution of systems: EVOSPACES (Dugerdil and Alam, 2008) highlights classes in a software city when they are activated; DYNACITY (Dashuber and Philippsen, 2022), EXPLORVIZ (Krause et al., 2021), SYNCHRO-VIS , and others also draw connections between modules to visualize dataflow; Langelier et al. (2008) gradually construct a software city and update the geometries and colors of buildings to represent development activity. Some approaches allow programmers to monitor a system in real-time while others replay a previously recorded trace of software activity (Dugerdil and Alam, 2008). ...
Conference Paper
Full-text available
Program comprehension is a key activity in software development. Several visualization approaches such as software maps have been proposed to support programmers in exploring the architecture of software systems. However, for the exploration of program behavior, programmers still rely on traditional code browsing and debugging tools to build a mental model of a system's behavior. We propose a novel approach to visualizing program behavior through animated 2.5D object maps that depict particular objects and their interactions from a program trace. We describe our implementation and evaluate it for different program traces through an experience report and performance measurements. Our results indicate that our approach can benefit program comprehension tasks, but further research is needed to improve scalability and usability.
... For 2D treemaps, color patterns such as two corners, resulting in a diagonal color gradient, or contrast modifications like ratio shading can be used for 2D treemaps (Tu and Shen 2007). Regarding 2.5D treemaps, animation using an interpolation of height and color attributes could be used, too (Bladh et al. 2005;Langelier et al. 2008). With our focus on changes in data mapped to color, our approach is also related to encoding multiple colors within the same surface or space, known as color weaving (Urness et al. 2003), which was also applied to visualize two measures in color on treemaps (Benomar et al. 2013). ...
Article
Full-text available
Treemaps depict tree-structured data while maintaining flexibility in mapping data to different visual variables. This work explores how changes in data mapped to color can be represented with rectangular 2.5D treemaps using procedural texture patterns. The patterns are designed to function for both static images and interactive visualizations with animated transitions. During rendering, the procedural texture patterns are superimposed onto the existing color mapping. We present a pattern catalog with seven exemplary patterns having different characteristics in representing the mapped data. This pattern catalog is implemented in a WebGL-based treemap rendering prototype and is evaluated using performance measurements and case studies on two software projects. As a result, this work extends the toolset of visual encodings for 2.5D treemaps by procedural texture patterns to represent changes in color. It serves as a starting point for user-centered evaluation. Graphical abstract
... A simple but effective use of in-situ templates for display of changes in height is given in Figure 2, one using explicit color mapping (thereby partially occluding the actual color mapping) the other a procedural patterns for direction encoding (using an arrow pattern). Alternatively, animation by means of an interpolation of height and color attributes [1,5] could be used. ...
Conference Paper
Full-text available
This work investigates the extent to which animated procedural texture patterns can be used to support the representation of changes in 2.5D treemaps. Changes in height, color, and area of individual nodes can easily be visualized using animated transitions. Especially for changes in the color attribute, plain animated transitions are not able to directly communicate the direction of change itself. We show how procedural texture patterns can be superimposed to the color mapping and support transitions. To this end, we discuss qualitative properties of each pattern, demonstrate their ability to communicate change direction both with and without animation, and conclude which of the patterns are more likely to increase effectiveness and correctness of the change mapping in 2.5D treemaps.
... Typically, structural elements, including iles, classes, and packages, are presented as an expandable list widget on the left-hand side of the IDE and the content of a selected element is displayed in the center as a large textual panel. Visualization is known to be efective at assisting practitioners in carrying out software comprehension and maintenance tasks [2,8,12,21,22]. ...
Conference Paper
Full-text available
To characterize the building blocks of a legacy software system (e.g., structure, dependencies), programmers usually spend a long time navigating its source code. Yet, modern integrated development environments (IDEs) do not provide appropriate means to eiciently achieve complex software comprehension tasks. To deal with this unfulilled need, we present Hunter, a tool for the visualization of JavaScript applications. Hunter visualizes source code through a set of coordinated views that include a node-link diagram that depicts the dependencies among the components of a system, and a treemap that helps programmers to orientate when navigating its structure. In this paper, we report on a controlled experiment that eval- uates Hunter. We asked 16 participants to solve a set of software comprehension tasks, and assessed their efectiveness in terms of (i) user performance (i.e., completion time, accuracy, and attention), and (ii) user experience (i.e., emotions, usability). We found that when using Hunter programmers required signiicantly less time to complete various software comprehension tasks and achieved a signiicantly higher accuracy. We also found that the node-link diagram panel of Hunter gets most of the attention of program- mers, whereas the source code panel does so in Visual Studio Code. Moreover, programmers considered that Hunter exhibits a good user experience.
... Numerous multi-frame approaches have been developed, where only one revision is shown at a time and change is visualized by animation. Examples are evolving versions of "software cities" [28] by Langelier et al. [29], Steinbrückner and Lewerentz [2], Boccuzzo and Gall [30] and Wettel and Lanza [3], the latter two also supporting some kind of static timeline view for a limited number of revisions. Another multiframe visualization, drawing individual releases at a finegrained level (including inheritance, call graphs, and control flow) and using color coding to indicate authorship, has been demonstrated by Collberg et al. [31]. ...
Conference Paper
Understanding the evolution of a project is crucial in reverse-engineering, auditing and otherwise understanding existing software. Visualizing how software evolves can be challenging, as it typically abstracts a multi-dimensional graph structure where individual components undergo frequent but localized changes. Existing approaches typically consider either only a small number of revisions or they focus on one particular aspect, such as the evolution of code metrics or architecture. Approaches using a static view with a time axis (such as line charts) are limited in their expressiveness regarding structure, and approaches visualizing structure quickly become cluttered with an increasing number of revisions and components. We propose a novel trade-off between displaying global structure over a large time period with reduced accuracy and visualizing fine-grained changes of individual components with absolute accuracy. We demonstrate how our approach displays changes by blending redundant visual features (such as scales or repeating data points) where they are not expressive. We show how using this approach to explore software evolution can reveal ephemeral information when familiarizing oneself with a new project. We provide a working implementation as an extension to our open-source library for fine-grained evolution analysis, LISA.
... In software visualization, treemaps and treemap-like approaches are used. There are software maps (Bohnet and Döllner, 2011), Code Cities (Wettel and Lanza, 2008) and VERSO (Langelier et al., 2008) represent software systems using nested rectangles. However, depicting the evolution is addressed using differing approaches, too. ...
Conference Paper
Full-text available
We propose the rectangular treemap layout algorithm EvoCells that maps changes in tree-structured data onto an initial treemap layout. Changes in topology and node weights are mapped to insertion, removal, growth, and shrinkage of the layout rectangles. Thereby, rectangles displace their neighbors and stretche their enclosing rectangles with a run-time complexity of O(n log n). An evaluation using layout stability metrics on the open source ElasticSearch software system suggests EvoCells as a valid alternative for stable treemap layouting.
... Verso. Langelier et al. [13], [14] proposed Verso, a 3D visualization of evolving systems. In their approach, classes are represented as 3D boxes, arranged over a flat 2D plan. ...
Conference Paper
Full-text available
Static and dynamic evolution of software systems may be described in terms of connection additions and removals in a graph. Due to the inherent complexity of software, navigating through such a dynamic network is a non-trivial task and extracting relevant information typically involves sophisticated queries. We explore the notion of space-time cube, a well-known 3D representation of an evolving dynamic graph, to support a set of software engineering activities. CuboidMatrix is a visualization tool that offers simple and expressive navigation operations. We have evaluated our tool against two software comprehension activities, namely (i) assessing interaction of classes during a software execution and (ii) exploring the cause of breaking Lint-like quality rules over a large number of software revisions. Video companion: https:// youtu.be/ nOl788-zGE8 Artifact: http:// dx.doi.org/ 10.5281/ zenodo.56469
... An evolution overview places these layouts sequentially besides each other. In [116] the authors propose layout animation to achieve coherence between successive layouts. Knight . ...
Thesis
Software visualization is a field of software engineering which aims at providing visual representations of software systems or particular aspects thereof. Numerous approaches for the visualization of software systems have been developed during the last decades. Software cities denote one particular kind of software visualizations that adopts the city metaphor for depicting software systems as virtual cities. Due to their high expressiveness and effectiveness software cities are mainly used for program comprehension tasks, during reverse engineering, and in quality analysis scenarios. Software systems evolve. They are steadily enhanced to provide new product functions, corrected to fix defects, or adapted to changed system environments. Software cities, as proposed today, do not take this evolutionary character of software systems into account. The evolution of software systems, i.e. changes to their internal structure and other characteristics, can easily disrupt the overall software city structure and thus yield very inconsistent visualizations for evolving software systems. The interpretation of these evolving software cities may be error-prone and time-consuming. In this thesis we propose a new software city approach that is based on the observation that real cities often reveal their evolution insofar as they contain e.g. historic centers or satellite cities. Analogous patterns, however, cannot be found in software cities which is an astonishing divergence. We claim that by preserving historical structures and carefully expanding software cities during software evolution, i.e. by spatializing software evolution, we obtain highly expressive, effective, and consistent software cities which support a broader range of application scenarios than the current state of the field. The main contribution of this thesis is a new layout approach for software cities, which explicitly takes evolution into account. Its effects are twofold: First, evolution becomes directly visible in the software city structure in the form of specific geographic patterns that each depicts particular evolutionary phenomena. The resulting increased expressiveness allows for supporting new application scenarios which are evaluated for several example systems. Second, software evolution does no longer disrupt the overall software city structure. Instead, the software cities evolve smoothly during system evolution, which allows for using them during ongoing system development and maintenance. The high consistency of this approach is confirmed in an empirical evaluation.
... Most techniques visualize the change process by animating the transition phase between two software revisions. The VERSO visualization tool [LSP08] uses linear interpolation of color, height, and twist between two revisions. Another approach uses an Evolution Storyboard consisting of an ordered sequence of animated panels showing the structural changes during a time period [DB06]. ...
Conference Paper
Full-text available
Software maps are a commonly used tool for code quality monitoring in software-development projects and decision making processes. While providing an important visualization technique for the hierarchical system structure of a single software revision, they lack capabilities with respect to the visualization of changes over multiple revisions. This paper presents a novel technique for visualizing the evolution of the software system structure based on software metric trends. These trend maps extend software maps by using real-time rendering techniques for natural phenomena yielding additional visual variables that can be effectively used for the communication of changes. Therefore, trend data is automatically computed by hierarchically aggregating software metrics. We demonstrate and discuss the presented technique using two real world data sets of complex software systems.
... This has been used to great effect in a variety of projects, from Rosling's Gapminder [20] to Langelier et. al.'s visualizations of software quality [13]. However, because they change so rapidly, animations are not necessarily well suited for detailed analysis. ...
Article
Mounting evidence suggests that current trends in global energy usage are leading to global warming, which will likely change our climate irreparably. Yet, as noted in IPCC reports, most people do not take this danger seriously enough to change their behaviors. Computer games, which are increasingly being used for educational purposes, have the potential to change people's understanding and attitudes toward critical issues such as energy use and global climate change. Yet it remains unclear how well serious games achieve these ends, and what, exactly, it is that makes them effective. We propose that by looking at data collected by these games, and correlating it with instruments that measure changes in attitudes, we can determine what game scenarios and activities are actually changing people's minds. This will help us to design more effective games for educating the public in a way that yields tangible results. In this paper we describe a novel strategy for classifying and visualizing the dynamic, multivariate data generated by serious games. Our contribution is a framework for categorizing these data, corresponding to layered visualizations that help to reveal the patterns in what players are doing over time. Specifically, this paper introduces the concept of Action Shapes, which are glyphs that are automatically generated using a variation on parallel coordinates. As elements in the layered visualization, Action Shapes represent the "benificence" of students' choices seen in the contexts of student progress and the overall game state. As proof of concept, we are applying this visualization to Energy Choices, a multiplayer game that teaches people about the interrelated issues of global warming and energy use. Although the examples provided in this paper are specific to this particular game, this strategy may be readily applied to a wide variety of other educational games designed to help people to be smarter about energy use and the planet.
... Theron et al. [307] visualize the evolution of baselines and revisions of artifacts from software repositories. Langelier et al. [162] use different views and animation to show structural and control version metrics of evolving software. Other evolutionary work has included the evolution of UML diagrams such as class diagrams [131,132,315] and model transformations [325]. ...
Article
Most software visualization systems and tools are designed from a single-user perspective and are bound to the desktop, IDEs, and the web. These design de-cisions do not allow users to collaboratively analyse software or easily interact and navigate software visualizations. We are building collaborative, interactive, multi-touch software visualization applications for multi-touch tables. Our user studies will outline the strengths and weaknesses of designing multi-touch soft-ware visualization applications and inform how users collaboratively conduct visual software analytics with multi-touch table user interfaces.
... As soon as new versions become available, new visualization sequences must be computed, which in turn can differ significantly from the original sequence and the mental models constructed by its users so far. A similar approach though based on treemaps is described by Sahraoui et al. [28]. ...
Article
Full-text available
Software cities are visualizations of software systems in the form of virtual cities. They are used as platforms to integrate a large variety of product- and process-related analysis data. Their usability, however, for real-world software development often suffers from their inability to appropriately deal with software changes. Even small structural changes can disrupt the overall structure of the city, which in turn corrupts the mental maps of its users. In this article we describe a systematic approach to utilize the city metaphor for the visualization of evolving software systems as growing software cities. The main contribution is a new layout approach which explicitly takes the development history of software systems into account. The approach has two important effects: first, it creates a stable gestalt of software cities even when the underlying software systems evolve; thus, by preserving its users’ mental maps these cities are especially suitable for use during ongoing system development. Second, it makes history directly visible in the city layouts, which allows for supporting novel analysis scenarios. We illustrate such scenarios by presenting several thematic cities’ maps, each capturing specific development history aspects.
... Although version-based visualization approaches are well-known in several fields of computer science (see e.g., [9,10,11,12,13,14,15,16,17,18]), the development of visualization approaches for version management in the business process context has received little attention in the last years [19,20]. Usually the different versions are presented as a list (e.g., Apromore platform [21] or IBM Business Process Manager [22]), as an indented list to highlight the hierarchical structure (e.g., e*Insight Business Process Manager [23]) or as a version graph to visualize the hierarchical and non-hierarchical relationships between versions (e.g., [24,25,26]). ...
Conference Paper
Full-text available
Managing large collections of different process model versions is for many organizations inevitable and results from, e.g., adaption of models to solve different challenges or modifications due to changed or new conditions. One challenge in this context is to make the differences between the versions visible and comparable. Visualizations have the advantage that they can present the relationships between the different process versions in a user-friendly way and therefore support users in their decisions. In this paper we introduce a visualization concept with the goal to provide a simple overview in order to compare complementary or contrasting characteristics between different versions. The design idea is presented on the basis of two use cases. Limitations of the concept are also discussed. The visualization concept should support users to gain a first impression about the characteristics between the versions and can be used as an entry point for a more detailed analysis of the different versions.
... By using the results of detection strategies, we depict the real problems in a system, without the risk of getting false positives or false negatives. Recently, the same authors extended their approach to evolution analysis using animations [10] . Unfortunately , the idea is not backed up by a configurable tool and the authors present an analysis of class-level changes only. ...
Conference Paper
Full-text available
The comprehensive understanding of today's software systems is a daunting activity, because of the sheer size and complexity that such systems exhibit. Moreover, software systems evolve, which dramatically increases the amount of data one needs to analyze in order to gain insights into such systems. Indeed, software complexity is recognized as one of the major challenges to the development and maintenance of industrial-size software projects. Our vision is a 3D visualization approach which helps software engineers build knowledge about their systems. We settled on an intuitive metaphor, which depicts software systems as cities. To validate the ideas emerging from our research, we implemented a tool called CodeCity. We devised a set of visualization techniques to support tasks related to program comprehension, design quality assessment, and evolution analysis, and applied them on large open-source systems written in Java, C++, or Smalltalk. Our next research goals are enriching our metaphor with meaningful representations for relations and encoding higher-level information.
... For instance, the software city metaphor is divided into districts, districts into sub-districts that contain streets, buildings, etc. Usually, the software city geometry is laid out over a 2D plane [26]. Some works divide the 2D plane on many pieces and add a degree of elevation on each of them to express software metrics [27] or project metrics [28]. ...
Conference Paper
Software systems are often very complex because of their huge size and the tremendous number of interactions between their components. However, understanding relations between software elements is crucial to optimize the development and the maintenance process. A good way to ease this understanding of software relations is to use advanced visualization techniques to graphically see interactions between elements. Nevertheless representing those software relations is not an easy task and often leads to hard to understand clutter. We believe that combining both edge clustering techniques and real-world metaphors can help address this issue, producing easier-to-read visualizations that ease the cognitive process and thus significantly help understanding the underlying software. In this paper, we explain how we adapted the existing 2D Hierarchical Edge bundles technique to represent relations in a 3D space on top of city metaphors.
... Langelier et al. proposed an application of their approach to analyze the evolution of software quality using animated visualization [LSP08]. To characterize software quality, the authors employ a set of structural software metrics and version control information. ...
Article
Full-text available
Software understanding takes up a large share of the total cost of a software system. The high costs attributed to software understanding activities are caused by the size and complexity of software systems, by the continuous evolution that these systems are subject to, and by the lack of physical presence which makes software intangible. Reverse engineering helps practitioners deal with the intrinsic complexity of software, by providing a broad range of patterns and techniques. One of these techniques is software visualization, which makes software more tangible, by providing visible representations of software systems. Interpreting a visualization is by no means trivial and requires knowledge about the visual language of the visualization. One means to ease the learning of a new visualization's language are metaphors, which allow the interpretation of new data representations by analogy. Possibly one of the most popular metaphors for software visualization is the city metaphor, which has been explored in the past by a number of researchers. However, in spite of the efforts, the value of this metaphor for reverse engineering has never been taken beyond anecdotical evidence. In this dissertation, we demonstrate the value of the city metaphor for reverse engineering along two directions. On the one hand, we show that the metaphor is versatile enough to allow the representation of different facets of software. On the other hand, we show that the city metaphor enables the creation of software visualizations which efficiently and effectively support reverse engineering activities. Our interpretation of the city metaphor at its core depicts the system as a city, the packages as districts, and the classes as buildings. The resulting "code city" visualization provides a structural overview of the software system, enriched with contextual data. To be able to perform analyses of real systems using our approach, we implemented a tool called CodeCity. We demonstrate the versatility of the metaphor, by using it in three different analysis contexts, \ie program comprehension, software evolution analysis, and software design quality assessment. For each of the contexts, we describe the visualization techniques we employ to encode the contextual data in the visualization and we illustrate the application by means of case studies. The insights gained in the three analysis contexts are complementary to each other, leading to an increasingly more complete "big picture" of the systems. We then demonstrate how the visualizations built on top of our city metaphor effectively and efficiently support reverse engineering activities, by means of an extensive controlled experiment. The design of our experiment is based on a list of desiderata that we extracted from our survey of the current body of research. We conducted the experiment over a period of six months, in four sites located in three countries, with a heterogeneous sample of subjects composed of fair shares of both academics and industry practitioners. The main result of our experiment was that, overall, our approach outperforms the state- of-practice in supporting users solve reverse engineering tasks, in terms of both correctness and completion time.
Article
Distributed systems pose unique challenges for software developers. Understanding the system’s communication topology and reasoning about concurrent activities of system hosts can be difficult. The standard approach, analyzing system logs, can be a tedious and complex process that involves reconstructing a system log from multiple hosts’ logs, reconciling timestamps among hosts with non-synchronized clocks, and understanding what took place during the execution encoded by the log. This article presents a novel approach for tackling three tasks frequently performed during analysis of distributed system executions: (1) understanding the relative ordering of events, (2) searching for specific patterns of interaction between hosts, and (3) identifying structural similarities and differences between pairs of executions. Our approach consists of XVector , which instruments distributed systems to capture partial ordering information that encodes the happens-before relation between events, and ShiViz , which processes the resulting logs and presents distributed system executions as interactive time-space diagrams. Two user studies with a total of 109 students and a case study with 2 developers showed that our method was effective, helping participants answer statistically significantly more system-comprehension questions correctly, with a very large effect size.
Chapter
Software Visualization is the field of Software Engineering that aims to help people to understand software through the use of visual resources. It can be effectively used to analyze and understand the large amount of data produced during software evolution. Several Software Evolution Visualization (SEV) approaches have been proposed. The goals of the proposed approaches are varied, and they try to help programmers and managers to deal with software evolution in their daily software activities. Despite their goals, their applicability in real development scenarios is questionable. In this chapter, the authors discuss the current state of the art and challenges in software evolution visualization, presenting issues and problems related to the area, and they propose some solutions and recommendations to circumvent them. Finally, the authors discuss some research directions for the SEV domain.
Article
Software engineers need to comprehend large amounts of data to maintain software. Software Visualization is an area that helps users to analyze software through the use of visual resources. It can be effectively used to understand the large amount of data produced during software evolution. A key challenge in the area is to create strategies to consistently visualize the many software attributes, modules and versions produced during its lifecycle. Most of the current visualization strategies seek to present data as a whole, including all available versions of the software in one visual scene. The area lacks strategies visualizing software in detail through the analysis of the evolution of specific software modules. Both strategies are useful, and should be selected according to the task at hand. This work focuses on combining software evolution visualization strategies, experimentally validating the benefits of the approach. Its goal was to build empirical evidence on the use of the combined multiple strategies for software evolution comprehension. It presents an experimental study that exploits the benefits of combining multiple visual strategies of software evolution analysis. The results show that combined visualization strategies perform better in terms of correctness and analysis time.
Article
Software Visualization is the field of Software Engineering that aims to help people to understand software through the use of visual resources. It can be effectively used to analyze and understand the large amount of data produced during software evolution. Several Software Evolution Visualization (SEV) approaches have been proposed. The goals of the proposed approaches are varied, and they try to help programmers and managers to deal with software evolution in their daily software activities. Despite their goals, their applicability in real development scenarios is questionable. In this chapter, the authors discuss the current state of the art and challenges in software evolution visualization, presenting issues and problems related to the area, and they propose some solutions and recommendations to circumvent them. Finally, the authors discuss some research directions for the SEV domain.
Conference Paper
Software visualization as a research field focuses on the visualization of the structure, behavior, and evolution of software. It studies techniques and methods for graphically representing these different aspects of software. Interest in software visualization has grown in recent years, producing rapid advances in the diversity of research and in the scope of proposed techniques, and aiding the application experts who use these techniques to advance their own research. Despite the importance of evaluating software visualization research, there is little work studying validation methods. As a consequence, it is usually difficult producing compelling evidence about the effectiveness of software visualization contributions. The goal of this paper is to study the validation techniques performed in the software visualization literature. We conducted a systematic mapping study of validation methods in software visualization. We consider 752 articles from multiple sources, published between 2000 and 2012, and study the validation techniques of the software visualization articles. The main outcome of this study is the lack in rigor when validating software visualization tool and techniques. Although software visualization has grown in interest in the last decade, it still lacks the necessary maturity to be properly and thoroughly evaluating its claims. Most article evaluations studied in this paper are qualitative case studies, including discussions about the benefits of the proposed visualizations. The results help understand the needs in software visualization validation techniques. They identify the type of evaluations that should be performed to address this deficiency. The specific analysis of SOFTVIS series articles shows that the specialized conference suffers from the same shortage.
Conference Paper
Interactive software visualization offers a promising support for program comprehension, including program dynamicity. We present, the extension of an existing visualization tool with heat maps to explore the time and other dimensions of software. To this end, we first propose a framework to unify the two main software dynamicities, execution and evolution. Then, this unified framework is exploited to define a visualization environment based on heat maps. We illustrate our approach on two comprehension tasks: understanding the behavior of programmers during the evolution of an application and understanding class contributions in use cases. The case studies show that the heat-map metaphor contributes to answer, more easily, many of the questions important to program comprehension.
Article
Identifying and tracking evolving software structures at a design level is a challenging task. Although there are ways to visualize this information statically, there is a need for methods that help analyzing the evolution of software design elements. In this paper, we present a new visual approach to identify variability zones in software designs and explore how they evolve over time. To verify the usefulness of our approach, we did a user study in which participants had to browse software histories and find visual patterns. Most participants were able to find interesting observations and found our approach intuitive and useful. We present a number of design aspects that were observed by participants and the authors using our IHVis tool on four open-source projects.
Article
Full-text available
Resumen. La creciente complejidad de las aplicaciones software complica notablemente su estudio y la posible detección de errores en su diseño o implementación. Las técnicas de visualización son un instrumento muy válido para detectar o alertar sobre posibles anomalías en el diseño de este tipo de aplicaciones, algo especialmente crítico sobre todo cuando no se puede definir de forma precisa cuándo existe una "anomalía". Sin embargo, uno de los problemas de las técnicas de visualización reside en su implementación, normalmente costosa, compleja y poco flexible. En este artículo mostramos cómo es posible utilizar la ingeniería basada en modelos y las transformaciones entre modelos para implementar de forma modular, eficiente y flexible algunas herramientas de visualización de sistemas basados en componentes.
Conference Paper
Software evolution is one of the most important topics in modern software engineering research. This activity requires the analysis of large amounts of data describing the current software system structure as well as its previous history. Software visualization can be helpful in this scenario, as it can summarize this complex data into easy to interpret visual scenarios. This paper presents a interactive differential approach for visualizing software evolution. The approach builds multi-view structural descriptions of a software system directly from its source code, and uses colors to differentiate it from any other previous version. This differential approach is highly interactive allowing the user to quickly brush over many pairs of versions of the system. As a proof of concept, we used the approach to analyze eight versions of an open source system and found out it was useful to quickly identify hot spot and code smell candidates in them.
Article
Les sociétés modernes dépendent de plus en plus sur les systèmes informatiques et ainsi, il y a de plus en plus de pression sur les équipes de développement pour produire des logiciels de bonne qualité. Plusieurs compagnies utilisent des modèles de qualité, des suites de programmes qui analysent et évaluent la qualité d'autres programmes, mais la construction de modèles de qualité est difficile parce qu'il existe plusieurs questions qui n'ont pas été répondues dans la littérature. Nous avons étudié les pratiques de modélisation de la qualité auprès d'une grande entreprise et avons identifié les trois dimensions où une recherche additionnelle est désirable : Le support de la subjectivité de la qualité, les techniques pour faire le suivi de la qualité lors de l'évolution des logiciels, et la composition de la qualité entre différents niveaux d'abstraction. Concernant la subjectivité, nous avons proposé l'utilisation de modèles bayésiens parce qu'ils sont capables de traiter des données ambiguës. Nous avons appliqué nos modèles au problème de la détection des défauts de conception. Dans une étude de deux logiciels libres, nous avons trouvé que notre approche est supérieure aux techniques décrites dans l'état de l'art, qui sont basées sur des règles. Pour supporter l'évolution des logiciels, nous avons considéré que les scores produits par un modèle de qualité sont des signaux qui peuvent être analysés en utilisant des techniques d'exploration de données pour identifier des patrons d'évolution de la qualité. Nous avons étudié comment les défauts de conception apparaissent et disparaissent des logiciels. Un logiciel est typiquement conçu comme une hiérarchie de composants, mais les modèles de qualité ne tiennent pas compte de cette organisation. Dans la dernière partie de la dissertation, nous présentons un modèle de qualité à deux niveaux. Ces modèles ont trois parties: un modèle au niveau du composant, un modèle qui évalue l'importance de chacun des composants, et un autre qui évalue la qualité d'un composé en combinant la qualité de ses composants. L'approche a été testée sur la prédiction de classes à fort changement à partir de la qualité des méthodes. Nous avons trouvé que nos modèles à deux niveaux permettent une meilleure identification des classes à fort changement. Pour terminer, nous avons appliqué nos modèles à deux niveaux pour l'évaluation de la navigabilité des sites web à partir de la qualité des pages. Nos modèles étaient capables de distinguer entre des sites de très bonne qualité et des sites choisis aléatoirement. Au cours de la dissertation, nous présentons non seulement des problèmes théoriques et leurs solutions, mais nous avons également mené des expériences pour démontrer les avantages et les limitations de nos solutions. Nos résultats indiquent qu'on peut espérer améliorer l'état de l'art dans les trois dimensions présentées. En particulier, notre travail sur la composition de la qualité et la modélisation de l'importance est le premier à cibler ce problème. Nous croyons que nos modèles à deux niveaux sont un point de départ intéressant pour des travaux de recherche plus approfondis. As society becomes ever more dependent on computer systems, there is more and more pressure on development teams to produce high-quality software. Many companies therefore rely on quality models, program suites that analyse and evaluate the quality of other programs, but building good quality models is hard as there are many questions concerning quality modelling that have yet to be adequately addressed in the literature. We analysed quality modelling practices in a large organisation and identified three dimensions where research is needed: proper support of the subjective notion of quality, techniques to track the quality of evolving software, and the composition of quality judgments from different abstraction levels. To tackle subjectivity, we propose using Bayesian models as these can deal with uncertain data. We applied our models to the problem of anti-pattern detection. In a study of two open-source systems, we found that our approach was superior to state of the art rule-based techniques. To support software evolution, we consider scores produced by quality models as signals and the use of signal data-mining techniques to identify patterns in the evolution of quality. We studied how anti-patterns are introduced and removed from systems. Software is typically written using a hierarchy of components, yet quality models do not explicitly consider this hierarchy. As the last part of our dissertation, we present two level quality models. These are composed of three parts: a component-level model, a second model to evaluate the importance of each component, and a container-level model to combine the contribution of components with container attributes. This approach was tested on the prediction of class-level changes based on the quality and importance of its components: methods. It was shown to be more useful than single-level, traditional approaches. To finish, we reapplied this two-level methodology to the problem of assessing web site navigability. Our models could successfully distinguish award-winning sites from average sites picked at random. Throughout the dissertation, we present not only theoretical problems and solutions, but we performed experiments to illustrate the pros and cons of our solutions. Our results show that there are considerable improvements to be had in all three proposed dimensions. In particular, our work on quality composition and importance modelling is the first that focuses on this particular problem. We believe that our general two-level models are only a starting point for more in-depth research.
Article
Full-text available
Visualization is valuable in monitoring and debugging programs. The goal of the Wand research project at the University of Saskatchewan is to provide both a framework and tools for rapid development of visualization aids for logic programming languages. The ICOLA (Incremental Constraint-based Object Layout Algorithm) system is the newest graphics facility within Wand. ICOLA positions graphical objects according to object declarations and constraints specifying relative positional relationships among the objects. Three important features of ICOLA are that it is capable of creating reasonable pictures from highly under-constrained specifications, it uses an incremental constraint solution algorithm and hence generates those pictures efficiently, and it supports incremental (i.e. progressive) insertions and deletions of objects and constraints. The ability of the incremental algorithm to support such deletions is particularly noteworthy. This paper describes: PDI, the language supported by ICOLA; the incremental constraint solution algorithm itself; a successful implementation in Prolog and C; and results of a performance evaluation of the implementation.
Conference Paper
Full-text available
Evolutionary information about software systems has proven to be a good resource to complement existing reverse engineering approaches, because it helps in giving a historical perspective of the system to be reverse engineered. Moreover, it provides additional types of information that are not present when only one version of a system is considered. Logical coupling, the implicit dependency between artifacts which changed together, is one example of such information. However, the recurrent problem is that such information comes in large amounts and must be processed to be useful for the reverse engineering of a system. In this paper we propose an approach to use logical coupling information at different levels of abstraction to detect areas in the system which may lead to maintenance problems. They represent a good starting point to decrease the coupling in the system. Our approach uses an interactive visualization technique called the Evolution Radar, which can effectively break down the amount and complexity of the logical coupling information. We present our technique in detail and apply it on a large open-source software system
Conference Paper
Full-text available
In this paper, we advocate the use of visual tooling for the development and maintenance of component-based software systems. Our contribution is twofold. First, we demonstrate how an interactive visualization tool effectively supports understanding large component based software. Secondly, we show how to design such a tool in order to make it applicable for a wide range of component systems and investigation goals. We demonstrate our approach by several visualization scenarios for real-world systems.
Conference Paper
Full-text available
The understanding of the structure of a software system can be improved by analyzing the system's evolution during development. Visualizations of software history that provide only static views do not capture the dynamic nature of software evolution. We present a new visualization technique, the Evolution Storyboard, which provides dynamic views of the evolution of a software's structure. An evolution storyboard consists of a sequence of animated panels, which highlight the structural changes in the system; one panel for each considered time period. Using storyboards, engineers can spot good design, signs of structural decay, or the spread of cross cutting concerns in the code. We implemented our concepts in a tool, which automatically extracts software dependency graphs from version control repositories and computes storyboards based on panels for different time periods. For applying our approach in practice, we provide a step by step guide that others can follow along the storyboard visualizations, in order to study the evolution of large systems. We have applied our method to several large open source software systems. In this paper, we demonstrate that our method provides additional information (compared to static views) on the ArgoUML project, an open source UML modeling tool.
Conference Paper
Full-text available
Versioning systems to store, handle, and retrieve the evo- lution of software systems have become a common good practice for both industrial and open-source software sys- tems, currently exemplified by the wide usage of the CVS system. The stored information can then be manually re- trieved over a command line or looked at with a browser us- ing the ViewCVS tool. However, the information contained in the repository is difficult to navigate as ViewCVS pro- vides only a textual view of single versions of the source files. In this paper we present an approach to visualize a CVS repository in 3D (using VRML) by means of a visual- ization service called White Coats. The viewer can easily navigate and interact with the visualized information.
Conference Paper
Full-text available
We present the Visual Code Navigator, a set of three interrelated visual tools that we developed for exploring large source code software projects from three different perspectives, or views: the syntactic view shows the syntactic constructs in the source code. The symbol view shows the objects a file makes available after compilation, such as function signatures, variables, and namespaces. The evolution view looks at different versions in a project lifetime of a number of selected source files. The views share one code model, which combines hierarchical syntax based and line based information from multiple source files versions. We render this code model using a visual model that extends the pixel-filling, space partitioning properties of shaded cushion treemaps with novel techniques. We discuss how our views allow users to interactively answer complex questions on various code elements by simple mouse clicks. We validate the efficiency and effectiveness of our toolset by an informal user study on the source code of VTK, a large, industry-size C++ code base
Conference Paper
Full-text available
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.
Conference Paper
Full-text available
We propose an approach for complex software analysis based on visualization. Our work is motivated by the fact that in spite of years of research and practice, software development and maintenance are still time and resource consuming, and high-risk activities. The most important reason in our opin- ion is the complexity of many phenomena related to soft- ware, such as its evolution and its reliability. In fact, there is very little theory explaining them. Today, we have a unique opportunity to empirically study these phenomena, thanks to large sets of software data available through open-source programs and open repositories. Automatic analysis tech- niques, such as statistics and machine learning, are usually limited when studying phenomena with unknown or poorly- understood inuence factors. We claim that hybrid tech- niques that combine automatic analysis with human exper- tise through visualization are excellent alternatives to them. In this paper, we propose a visualization framework that supports quality analysis of large-scale software systems. We circumvent the problem of size by exploiting perception ca- pabilities of the human visual system.
Article
Full-text available
Coping with huge amounts of data is one of the major problems in the context of software evolution. Current approaches reduce this complexity by filtering out irrelevant information. In this paper we propose an approach based on a combination of software visualization and software metrics, as software visualization is apt for complexity reduction and metrics introduce the possibility to qualify evolution. We discuss a simple and effective way to visualize the evolution of software systems which helps to recover the evolution of object oriented software systems. In addition we define a vocabulary that qualifies some specific situations that occurs when considering system evolution.
Conference Paper
Full-text available
Reverse engineering and software evolution research has been focused mostly on analyzing single software sys- tems. However, rarely a project exists in isolation; instead, projects exist in parallel within a larger context given by a company, a research group or the open-source community. Technically, such a context manifests itself in the form of super-repositories, containers of several projects developed in parallel. Well-known examples of such super-repositories include SourceForge and CodeHaus. We present an easily accessible platform which supports the analysis of such super-repositories. The platform can be valuable for reverse engineering both the projects and the structure of the organization as reflected in the inter- actions and collaborations between developers. Through- out the paper we present various types of analysis applied to three open-source and one industrial Smalltalk super- repositories, containing hundreds of projects developed by dozens of people.
Conference Paper
Full-text available
Versioning systems such as CVS exhibit a large potential to investigate and understand the evolution of large software systems. Bug reporting systems such as Bugzilla help to understand which parts of the system are affected by problems. In this article, we present a novel visual approach to uncover the relationship between evolving software and the way it is affected by software bugs. By visually putting the two aspects close to each other, we can characterize the evolution of software artifacts. We validate our approach on 3 very large open source software systems
Conference Paper
Full-text available
This paper describes a user study conducted to evaluate the use of smooth animated transitions between directories in a three-dimensional, tree-map visualization. We looked specifically at the task of returning to a previously visited directory after either an animated or instantaneous return to the root location. The results of the study show that animation is a double-edged sword. Even though users take more shortcuts, they also make more severe navigational errors. It seems as though the promise of a more direct route to the target directory, which animation provides, somehow precludes users who navigate incorrectly from applying a successful recovery strategy.
Conference Paper
Full-text available
Software systems become progressively more complex and difficult to maintain. To facilitate maintenance tasks, project managers and developers often turn to the evolution history of the system to recover various kinds of useful information, such as anomalous phenomena and lost design decisions. An informative visualization of the evolution history can help cope with this complexity by highlighting conspicuous evolution events using strong visual cues. We present a scalable visualization technique called evolution spectrographs (ESG). An evolution spectrograph portrays the evolution of a spectrum of components based on a particular property measurement. We describe several special-purpose spectrographs and discuss their use in understanding and supporting software evolution through the case studies of three large software systems (OpenSSH, KOffice and FreeBSD).
Conference Paper
Full-text available
Design patterns describe good solutions to common and recurring problems in program design. The solutions are design motifs which software engineers imitate and introduce in the architecture of their program. It is important to identify the design motifs used in a program architecture to understand solved design problems and to make informed changes to the program. The identification of micro-architectures similar to design motifs is difficult because of the large search space, i.e., the many possible combinations of classes. We propose an experimental study of classes playing roles in design motifs using metrics and a machine learning algorithm to fingerprint design motifs roles. Fingerprints are sets of metric values characterising classes playing a given role. We devise fingerprints experimentally using a repository of micro-architectures similar to design motifs. We show that fingerprints help in reducing the search space of micro-architectures similar to design motifs efficiently using the Composite design motif and the JHotDraw framework.
Conference Paper
Full-text available
Existing information visualization techniques are usually limited to the display of a few thousand items. This article describes new interactive techniques capable of handling a million items (effectively visible and manageable on screen). We evaluate the use of hardware-based techniques available with newer graphics cards, as well as new animation techniques and non-standard graphical features such as stereovision and overlap count. These techniques have been applied to two popular information visualizations: treemaps and scatter plot diagrams; but are generic enough to be applied to other 2D representations as well.
Article
Full-text available
Given the central role that software development plays in the delivery and application of information technology, managers are increasingly focusing on process improvement in the software development area. This demand has spurred the provision of a number of new and/or improved approaches to software development, with perhaps the most prominent being object-orientation (OO). In addition, the focus on process improvement has increased the demand for software measures, or metrics with which to manage the process. The need for such metrics is particularly acute when an organization is adopting a new technology for which established practices have yet to be developed. This research addresses these needs through the development and implementation of a new suite of metrics for OO design. Metrics developed in previous research, while contributing to the field's understanding of software development processes, have generally been subject to serious criticisms, including the lack of a theoretical base. Following Wand and Weber (1989), the theoretical base chosen for the metrics was the ontology of Bunge (1977). Six design metrics are developed, and then analytically evaluated against Weyuker's (1988) proposed set of measurement principles. An automated data collection tool was then developed and implemented to collect an empirical sample of these metrics at two field sites in order to demonstrate their feasibility and suggest ways in which managers may use these metrics for process improvement
Article
Full-text available
We describe Gevol, a system that visualizes the evolution of software using a novel graph drawing technique for visualization of large graphs with temporal component. Gevol extracts information about a Java program stored within a CVS version control system and displays it using a temporal graph visualizer. This information can be used by programmers to understand the evolution of a legacy program: Why is the program structured the way it is? Which programmers were responsible for which parts of the program during which time periods? Which parts of the program appear unstable over long periods of time and may need to be rewritten? This type of information will complement that produced by more static tools such as source code browsers, slicers, and static analyzers.
Article
Full-text available
. Generating incrementally stable layouts is important for visualizing dynamic graphs in many applications. This paper describes DynaDAG, a new heuristic for incremental layout of directed acyclic graphs drawn as hierarchies, and its application in the DynaGraph system. 1 Introduction Effective techniques have been developed for some important families of graph layouts, such as hierarchies, planar embeddings, orthogonal grids and forced-directed (spring) models [1]. These techniques have been incorporated in practical user interfaces that display static diagrams of relationships between objects [19, 18, 17]. Static diagrams are not completely satisfactory because in many situations, the displayed graphs can change. Three common scenarios are: Manual editing. Most interactive graph drawing systems allow users to manually insert and delete nodes and edges. Layouts must be updated dynamically to reflect such changes. Browsing large graphs. When only static layout is available, browsin...
Article
While software metrics are a generally desirable feature in the software management functions of project planning and project evaluation, they are of especial importance with a new technology such as the object-oriented approach. This is due to the significant need to train software engineers in generally accepted object-oriented principles. This paper presents theoretical work that builds a suite of metrics for object-oriented design. In particular, these metrics are based upon measurement theory and are informed by the insights of experienced object-oriented software developers. The proposed metrics are formally evaluated against a widelyaccepted list of software metric evaluation criteria.
Conference Paper
A discontinuity exists between object-oriented modeling and programming languages. This discontinuity arises from ambiguous concepts in modeling languages and a lack of corresponding concepts in programming languages. It is particularly acute for binary class relationships---association, aggregation, and composition. It hinders the traceability between software implementation and design, thus hampering software analysis. We propose consensual definitions of the binary class relationships with four minimal properties---exclusivity, invocation site, lifetime, and multiplicity. We describe algorithms to detect automatically these properties in source code and apply these on several frameworks. Thus, we bridge the gap between implementation and design for the binary class relationships, easing software analysis.
Article
A discontinuity exists between object-oriented modeling and programming languages. This discontinuity arises from ambiguous concepts in modeling languages and a lack of corresponding concepts in programming languages. It is particularly acute for binary class relationships---association, aggregation, and composition. It hinders the traceability between software implementation and design, thus hampering software analysis. We propose consensual definitions of the binary class relationships with four minimal properties---exclusivity, invocation site, lifetime, and multiplicity. We describe algorithms to detect automatically these properties in source code and apply these on several frameworks. Thus, we bridge the gap between implementation and design for the binary class relationships, easing software analysis.
Article
The purpose of this study was to extend previous research on the conditions that may promote understanding and abstraction via structural alignment, that is, through a comparison between two partially understood situations. Structural alignment is a route to analogical reasoning which differs from the typical route where an analogy is made by eliciting an unknown situation from a very familiar one. Ninety-nine eighth graders were presented with two pairs of scenarios; the first depicting two phenomena of heat flow and the second, two phenomena of the changing state of matter. Participants were randomly assigned to five different conditions which varied in the degree to which they required a comparisonbetween the phenomena in the scenario pairs. For each pair of scenarios, participants were asked to describe the differences between the two phenomena, explain what happens in the phenomena, rate the similarity between the two, and justify the ratings. Results show that analogical reasoning was promoted more in the condition where participants were asked to jointly interpret the phenomena depicted in the scenarios. For both pairs of scenarios, students in this condition reached a deeper understanding; they were more able to identify alignable differences between the phenomena, and recognize the abstract and general higher-order relational structure implied by the perceptually different situations.
Chapter
Graph drawings are a basic component of user interfaces that display relationships between objects. Generating incrementally stable layouts is important for many applications. This paper describes DynaDAG, a new heuristic for incremental layout of directed acyclic graphs drawn as hierarchies, and its application in the DynaGraph system.
Conference Paper
Mining software repositories is an important activity during software evolution, as the extracted data is used to support a variety of software maintenance tasks. The key information extracted from these repositories gives a picture of the changes on the software system. To have a complete picture, tailored to the needs of the developer, the extracted data needs to be filtered, aggregated, and presented to the users. In this paper we propose a new visualization for such data, which relies on an existing software visualization front-end, SourceViewer3D (sv3D). The new visualization allows users to define multiple views of the change history data, each view helps answer a set of questions relevant to specific maintenance tasks. Data can be viewed at different granularity (e.g., file, line of text, method, class) and comprehensive views can be defined, which display to the user multiple data types at the same time. Complex questions and tasks can be solved with the aid of such views
Conference Paper
Structural analyses frequently fall short in an adequate representation of historical changes for retrospective analysis. By compounding the two underlying information spaces in a single approach, the comprehension about the interaction between evolving requirements and system development can be improved significantly. We therefore propose a lightweight approach based on release history data and source code changes, which first selects entities with evolutionary outstanding characteristics and then indicates their structural dependencies via commonly used source code entities. The resulting data sets and visualizations aim at a holistic view to point out and assess structural stability, recurring modifications, or changes in the dependencies of the file-sets under inspection. In this paper we describe our approach and its results in terms of the Mozilla case study. Our approach completes typical release history mining and source code analysis approaches, therefore past restructuring events, new, shifted, and removed dependencies can be spotted easily
Conference Paper
Many visualizations use smoothly animated transitions to help the user interact with information structures. These transitions are intended to preserve perceptual constancy during viewpoint transformations. However, animated transitions also have costs - they increase the transition time, and they can be complicated to implement - and it is not clear whether the benefits of smooth transitions outweigh the costs. In order to quantify these benefits, we carried out two experiments that explore the effects of smooth transitions. In the first study, subjects were asked to determine whether graph nodes were connected, and navigated the graph either with or without smooth scene transitions. In the second study, participants were asked to identify the overall structure of a tree after navigating the tree through a viewport that either did or did not use smooth transitions for view changes. The results of both experiments show that smooth transitions can have dramatic benefits for user performance - for example, participants in smooth transition conditions made half the errors of the discrete- movement conditions. In addition, short transitions were found to be as effective as long ones, suggesting that some of the costs of animations can be avoided. These studies give empirical evidence on the benefits of smooth transitions, and provide guidelines about when designers should use them in visualization systems.
Conference Paper
Versioning systems such as CVS or Subversion exhibit a large potential to investigate the evolution of software systems. They are used to record the development steps of software systems as they make it possible to reconstruct the whole evolution of single files. However, they provide no good means to understand how much a certain file has been changed over time and by whom. In this paper we present an approach to visualize files using fractal figures, which: (1) convey the overall development effort; (2) illustrate the distribution of the effort among various developers; and (3) allow files to be categorized in terms of the distribution of the effort following gestah principles. Our approach allows us to discover files of high development efforts in terms of team size and effort intensity of individual developers. The visualizations allow an analyst or a project manager to get first insights into team structures and code ownership principles. We have analyzed Mozilla as a case study and we show some of the recovered team development patterns in this paper as a validation of our approach
Article
This paper describes a new approach, space-optimized tree, for the visualization and navigation of tree-structured relational data. This technique can be used especially for the display of very large hierarchies in a two-dimensional space. We discuss the advantages and limitations of current techniques of tree visualization. Our strategy is to optimize the drawing of trees in a geometrical plane and maximize the utilization of display space by allowing more nodes and links to be displayed at a limited screen resolution. Space-optimized tree is a connection+enclosure visualization approach that recursively positions children of a subtree into polygon areas and still uses a node–link diagram to present the entire hierarchical structure. To be able to handle the navigation of large hierarchies, we use a new hybrid viewing technique that combines two viewing methods, the modified semantic zooming and a focus+context technique. While the semantic zooming technique can enlarge a particular viewing area by filtering out the rest of tree structure from the visualization, the focus+context technique allows the user to interactively focus, view and browse the entire visual structure with a reasonable high-density display.
Conference Paper
Design anomalies, introduced during software evolution, are frequent causes of low maintainability and low flexibility to future changes. Because of the required knowledge, an important subset of design anomalies is difficult to detect automatically, and therefore, the code of anomaly candidates must be inspected manually to validate them. However, this task is time- and resource-consuming. We propose a visualization-based approach to detect design anomalies for cases where the detection effort already includes the validation of candidates. We introduce a general detection strategy that we apply to three types of design anomaly. These strategies are illustrated on concrete examples. Finally we evaluate our approach through a case study. It shows that performance variability against manual detection is reduced and that our semi-automatic detection has good recall for some anomaly types.
Conference Paper
This paper presents an algorithm for drawing a sequence of graphs that contain an inherent grouping of their vertex set into clusters. It differs from previous work on dynamic graph drawing in the emphasis that is put on maintaining the clustered structure of the graph during incremental layout. The algorithm works online and allows arbitrary modifications to the graph. It is generic and can be implemented using a wide range of static force-directed graph layout tools. The paper introduces several metrics for measuring layout quality of dynamic clustered graphs. The performance of our algorithm is analyzed using these metrics. The algorithm has been successfully applied to visualizing mobile object software
Conference Paper
Most traditional reverse engineering tools focus on abstraction and analysis of source code, presenting a visual representation of the software architecture. This approach can be both helpful and cost effective in software maintenance tasks. However, where large software teams are concerned, with moderate levels of employee turnover, traditional reverse engineering tools can be inadequate. To address this issue, we examine the use of software process data, such as software artifact change history and developer activities. We propose the application of this data confers additional information developers need to better understand, maintain and develop software in large team settings. To explore this hypothesis, we evaluate the use of a tool, Xia, in the navigation of both software artifacts and their version history. This work introduces Xia, reveals the results of our evaluation and proposes directions for future research in this area.
Conference Paper
We describe a new method for the visualization of tree structured relational data. It can be used especially for the display of very large hierarchies in a 2-dimensional space. We discuss the advantages and limitations of current techniques of tree visualization. Our strategy is to optimize the drawing of trees in a geometrical plane and maximize the utilization of display space by allowing more nodes and links to be displayed at a limit screen resolution. We use the concept of enclosure to partition the entire display space into a collection of local regions that are assigned to all nodes in tree T for the display of their sub-trees and themselves. To enable the exploration of large hierarchies, we use a modified semantic zooming technique to view the detail of a particular part of the hierarchy at a time based on user's interest. Layout animation is also provided to preserve the mental map while the user is exploring the hierarchy by changing zoomed views.
Conference Paper
A method for visualizing hierarchically structured information is described. The tree-map visualization technique makes 100% use of the available display space, mapping the full hierarchy onto a rectangular region in a space-filling manner. This efficient use of space allows very large hierarchies to be displayed in their entirety and facilitates the presentation of semantic information. Tree-maps can depict both the structure and content of the hierarchy. However, the approach is best suited to hierarchies in which the content of the leaf nodes and the structure of the hierarchy are of primary importance, and the content information associated with internal nodes is largely derived from their children
Fingerprinting design patterns Treemaps: A space-filling approach to the visualization of hierarchical information structures
  • Y.-G Guéhéneuc
  • H Sahraoui
  • F Zaidi
Y.-G. Guéhéneuc, H. Sahraoui, and F. Zaidi. Fingerprinting design patterns. In WCRE '04: Proc. Working Conf. on Reverse Engineering, pages 172–181, 2004. [15] B. Johnson and B. Shneiderman. Treemaps: A space-filling approach to the visualization of hierarchical information structures. In IEEE Visualization Conf., 1991.