Visually localizing design problems with disharmony maps

Assessing the quality of software design is difficult, as “design” is expressed through guidelines and heuristics, not rigorous rules. One successful approach to assess design quality is based on de-tection strategies, which are metrics-based composed logical condi-tions, by which design fragments with specific properties are de-tected in the source code. Such detection strategies, when exe-cuted on large software systems usually return large sets of arti-facts, which potentially exhibit one or more “design disharmonies”, which are then inspected manually, a cumbersome activity. In this article we present disharmony maps, a visualization-based approach to locate such flawed software artifacts in large systems. We display the whole system using a 3D visualization technique based on a city metaphor. We enrich such visualizations with the results returned by a number of detection strategies, and thus render both the static structure and the design problems that affect a subject system. We evaluate our approach on a number of open-source Java systems and report on our findings

Software systems as cities

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

Empirical validation of CodeCity: a controlled experiment

We describe an empirical evaluation of a visualization approach based on a 3D city metaphor, implemented in a tool called CodeCity. We designed the controlled experiment based on a set of lessons extracted from the current body of research and perfected it during a preliminary pilot phase. We then conducted the experiment in four locations across three countries over a period of four months, involving participants from both academia and industry. We detail the decisions behind our design as well as the lessons we learned from this experience. Finally, we present the results of the experiment and the complete set of data required to ensure repeatability of the experiment

Visual exploration of large-scale system evolution

The goal of reverse engineering is to obtain a men-tal model of software systems. However, evolution adds another dimension to their implicit complexity, effectively making them moving targets: The evolution of software sys-tems still remains an intangible and complex process. Met-rics have been extensively used to quantify various facets of evolution, but even the usage of complex metrics often leads to overly simplistic insights, thus failing at adequately char-acterizing the complex evolutionary processes. We present an approach based on real-time interac-tive 3D visualizations, whose goal is to render the struc-tural evolution of object-oriented software systems at both a coarse-grained and a fine-grained level. By providing in-sights into a system’s history, our visualizations allow us to reason about the origins and the causalities which led to the current state of a system. We illustrate our approach on three large open-source systems and report on our findings, which were confirmed by developers of the studied systems.

Scripting 3D Visualizations with CODECITY

Software visualization is a useful means to present and explore large amounts of information. However, constructing useful visualizations targeted at specific tasks is often a trial-and-error process. As a consequence, a visualization prototyping tools needs to be flexible to allow for the creation of new visualizations and also to provide an environment that grants access to its powerful mechanisms. In this paper, we report on our experience with complementing the rich graphical user interface of CODECITY, a 3D visualization tool, with a scripting environment. The scripting language gives the programmers full access to the configurability of our system, without the need for them to be exposed to the real complexity of the application. Thanks to the scripting engine, adapting CODECITY to new types of data has become easy, as we illustrate with examples.

Archeology of Code Duplication: Recovering Duplication Chains from Small Duplication Fragments,”Proc

Code duplication is a common problem, and a wellknown sign of bad design. As a result of that, in the last decade, the issue of detecting code duplication led to various solutions and tools that can automatically find duplicated blocks of code. However, duplicated fragments rarely remain identical after they are copied; they are oftentimes modified here and there. This adaptation usually “scatters ” the duplicated code block into a large amount of small “islands ” of duplication, which detected and analyzed separately hide the real magnitude and impact of the duplicated block. In this paper we propose a novel, automated approach for recovering duplication blocks, by composing small isolated fragments of duplication into larger and more relevant duplication chains. We validate both the efficiency and the scalability of the approach by applying it on several well known open-source case-studies and discussing some relevant findings. By recovering such duplication chains, the maintenance engineer is provided with additional cases of duplication that can lead to relevant refactorings, and which are usually missed by other detection methods