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

Hands-On: Experiencing Software Architecture in Virtual Reality

Recently, virtual reality (VR) and gesture-based interface devices emerged at the consumer market. Both concepts offer new visualization and interaction capabilities, which can improve the user experience when using software. In Software Engineering, exploring and comprehending software systems is often addressed via visualization techniques. In this paper, we present our VR approach to explore software systems by using a head-mounted display and two different gesture-based interaction devices. Hence, we achieve a more immersive user experience and natural interaction, which benefits the comprehension process. Our VR approach is integrated into ExplorViz, our tool for live trace visualization of large software landscapes. In order to emphasize the advantages, we apply our combined approach on a small software system, running within our webbased tool ExplorViz. In this context, we present both, the visualization and the interaction capabilities

Visualization of graphs and trees for software analysis

A software architecture is an abstraction of a software system, which is indispensable for many software engineering tasks. Unfortunately, in many cases information pertaining to the software architecture is not available, outdated, or inappropriate for the task at hand. The RECONSTRUCTOR project focuses on software architecture reconstruction, i.e., obtaining architectural information from an existing system. Our research, which is part of RECONSTRUCTOR, focuses on interactive visualization and tries to answer the following question: How can users be enabled to understand the large amounts of information relevant for program understanding using visual representations? To answer this question, we have iteratively developed a number of techniques for visualizing software systems. A large number of these cases consists of hierarchically organized data, combined with adjacency relations. Examples are function calls within a hierarchically organized software system and correspondence relations between two different versions of a hierarchically organized software system. Hierarchical Edge Bundles (HEBs) are used to visualize adjacency relations in hierarchically organized data, such as the aforementioned function calls within a software system. HEBs significantly reduce visual clutter by visually bundling relations together. Massive Sequence Views (MSVs) are used in conjunction with HEBs to enable analysis of sequences of relations, such as function-call traces. HEBs are furthermore used to visually compare hierarchically organized data, e.g., two different versions of a software system. HEBs visually emphasize splits, joins, and relocations of subhierarchies and provide for interactive selection of sets of relations. Since HEBs require a hierarchy to perform the bundling, we present Force-Directed Edge Bundles (FDEBs) as an alternative to visually bundle relations together in the absence of a hierarchical component. FDEBs use a self-organizing approach to bundling in which edges are modeled as flexible springs that can attract each other. As a result, visual clutter is reduced and high-level edge patterns are better visible. Finally, in all these methods, a clear depiction of the direction of edges is important. We have therefore performed a separate study in which we evaluated ten representations (including the standard arrow) for depicting directed edges in a controlled user study

Live Visualization of Database Behavior for Large Software Landscapes: The RACCOON Approach

Databases are essential components within large software landscapes, since they are employed in almost every information system. Based on the growing complexity of software systems and a steadily increasing amount of data which is collected, processed, and stored in databases, it is difficult to obtain a live overview of these software landscapes. This often leads to an insufficient knowledge of the actual internal structure and behavior of employed databases. Furthermore, databases are often involved in performance issues within information systems. A solution to these problems is employing live visualizations of databases and related communication from applications within the software landscape. These visualizations allow operators to understand their databases in detail and to analyze database queries performed by applications. Based on established visualization concepts like the entity relationship diagrams and the 3D city metaphor, operators can be supported in the task of database comprehension. Established monitoring techniques, like dynamic and static analysis, can be used to capture necessary information from applications and databases. In this paper, we present our live visualization approach of databases and associated communication for large software landscapes. Our visualization offers two different views – a landscape-level and a database-level perspective. The landscape-level perspective provides an overview of monitored applications and related databases. The database-level perspective reveals database schemas within a database, shows contained tables and relationships, and allows for the inspection of executed queries based on the monitoring information collected at runtime