Interactive Software Visualization within the RECONSTRUCTOR Project (RECONSTRUCTOR: Reconstructing Software Architectures for System Evaluation Purposes)
Danny Holten∗ Technische Universiteit Eindhoven
A BSTRACT A software architecture is an abstraction of a software system, which is indispensable for many software engineering tasks. Unfortunately, in many cases architectural information is not available, outdated, or inappropriate for the task at hand. Software architecture reconstruction concerns obtaining architectural information from an existing system. Currently, this process is unstructured, requires much manual effort, leads to results that are hard to understand, and does not provide quantitative information on software quality aspects. The RECONSTRUCTOR project aims at raising the state of the art in software architecture reconstruction. My research within RECONSTRUCTOR focuses on interactive visualization of software systems and it is basically concerned with the following questions: “How can architectural information, represented in different, interrelated views, be visualized and manipulated?” and “How can the visualization support the iterative reconstruction process and help to interpret and validate the findings of a software architecture evaluation?” 1
I NTRODUCTION
A software architecture provides a transferable abstraction of a software system [1]. Many software engineering tasks are hard to conduct without such a transferable abstraction. Examples include migrations, auditing, application integration, and impact analysis. Unfortunately, architectural information, when available at all, is often outdated and incorrect, or inappropriate for the task at hand. Software architecture reconstruction is the process of obtaining a documented architecture for an existing system. RECONSTRUCTOR takes the SYMPHONY software architecture reconstruction process as its starting point [4]. SYMPHONY distinguishes the following steps, executed iteratively: problem elicitation (why is the reconstruction needed?), concept determination (what should be reconstructed?), data gathering (what can be directly reconstructed?), knowledge inference (how can we raise the level of abstraction of the raw material?), and information presentation (how can the various views be presented to help stakeholders address the problem at hand?). The last step, information presentation, is the focus of my research within RECONSTRUCTOR and it is described in more detail in the next section. 2
P ROBLEM D ESCRIPTION
During the assessment process, large amounts of information are produced, which have to be analyzed, assessed, and presented. Effective presentation of this information is crucial to form an opinion ∗ e-mail:
[email protected]
on the system studied. The aim of the visualization track is to develop effective methods, tools, and techniques to gain insight into the various views on the architecture via visual means. Assessment is an iterative process, where the generate-presentanalyze cycle is repeated many times and where new presentations will lead to new questions. The visualization system should enable users to quickly formulate these questions and should give a customized visual answer back in short time. Overall, we regard the following two issues to be the most challenging: Integrated visualization. Many methods have been developed to visualize hierarchical, relational, or multivariate data, but the problem how to show these simultaneously in an integrated way is rarely addressed; Multiple views. The visualization methods developed should be able to provide effective visualizations for the most important views. Often the same entities will occur in multiple views and it should be easy to correlate these. The data shown is often dynamic and drastic changes in the visualization should be avoided here in order to simplify judgement of the effect of changes. Finally, the user must be able to inspect views at different positions and at different levels of detail. 3
R ESEARCH M ETHOD
The research method is case driven, and is based on close cooperation between the members of the research team and the industrial partners within RECONSTRUCTOR. The typical steps are (1) selecting an (industrial) case study, (2) iteratively reconstructing the relevant architectural views, using current capabilities as well as the methods under development, (3) evaluating the usability of the reconstruction process and the reconstructed architecture, and (4) integrating the results in a reconstruction framework. 4 4.1
ACCOMPLISHED WORK Visualizing Software Metrics using Visual Realism
The visualization techniques used in current software visualization frameworks make use of a limited set of graphical elements to highlight relevant aspects of a software system. Although human visual perception enables rapid processing of additional visual cues like shading and texture, they are generally not used. In [3] we show how 2D and 3D computer graphics techniques for achieving visual realism can be used to increase the information throughput of software visualization techniques. An example illustrating the simultaneous use of treemaps, cushions, color, texture, and bump mapping is shown in figure 1. 4.2
Hierarchical Edge Bundles
A compound graph is a frequently encountered type of data set. Relations are given between items, and a hierarchy is defined on the items as well. In [2] we present a new method for visualizing such
5
Figure 1: Multivariate visualization of fan-in and code smell: (a) Methods with high fan-in and low code smell (permissible situation); (b) Methods with low fan-in and high code smell (medium-priority situation); (c) A method with medium fan-in and fairly high code smell, indicating a potential problem area [3].
compound graphs. Our approach is based on visually bundling the adjacency edges, i.e., non-hierarchical edges, together. We realize this by assuming that the hierarchy is shown via a standard visualization method. Next, we bend each adjacency edge, modeled as a B-spline curve, toward the polyline defined by the path via the inclusion edges from one node to another. This hierarchical bundling reduces visual clutter and also visualizes implicit adjacency edges between parent nodes that are the result of explicit adjacency edges between their respective child nodes. An example illustrating the use of hierarchical edge bundles is shown in figure 2.
D ISCUSSION AND C ONCLUSION
In [3] we have shown how established visualization and computer graphics techniques for achieving visual realism can be combined to increase the expressiveness of software visualizations. We experienced the resulting visualizations of software systems as aesthetically pleasing while providing a high information density without being visually overwhelming or confusing. As far as future work is concerned, user experiments will have to be performed to gain insight in how other users experience the visualizations and to determine the practical feasibility of such an approach. The techniques that were used are furthermore especially suited for implementation on programmable graphics hardware to maintain real-time performance when used to visualize large software systems. For the hierarchical edge bundling technique introduced in [2] we have demonstrated how hierarchical edge bundles can be used in conjunction with existing tree visualization techniques, how a bundle-based visualization is capable of reducing visual clutter, and how the amount of bundling can be used to provide a continuous trade-off between a low-level and a high-level view of the adjacency relations. The majority of the CS staff, students and local companies that were given a demonstration considered the technique as generally useful for quickly gaining insight in the adjacency relations present in hierarchically organized systems. Furthermore, they regarded the visualizations as being aesthetically pleasing. As far as limitations are concerned, we currently consider the bundle overlap in case of layouts with a large number of collinear nodes to be the biggest problem of hierarchical edge bundles. We regard the implementation of the suggested bundle-centric interaction technique as well as zooming techniques to allow users to inspect subparts of a data set in more detail as the most important directions for future work. Subsequently, user experiments will need to be performed to gain insight in the practical usability of our technique in conjunction with the provided interaction techniques. Finally, feedback from potential users indicated that in addition to visualizing and exploring hierarchies and adjacency relations, functionality for editing the data, i.e., by interactively reordering data elements to perform what-if investigations, is a future research direction that is worth considering as well. 6
ACKNOWLEDGEMENTS
This project is funded by the Netherlands Organization for Scientific Research (NWO) Jacquard program under research grant no. 638.001.408 (RECONSTRUCTOR Project). R EFERENCES
Figure 2: A software system and its associated call graph (caller = green, callee = red). The system is shown using a radial layout using bundling. Bundling reduces visual clutter, making it easier to perceive the actual connections. Bundling also shows relations between sparsely connected systems more clearly, which are almost completely obscured in non-bundled versions [2].
[1] L. Bass, P. Clements, and R. Kazman. Software Architecture in Practice. Addison-Wesley, 1998. [2] D. Holten and J.J. van Wijk. Hierarchical Edge Bundles: Visualization of Adjacency Relations in Hierarchical Data. In Proceedings of the IEEE Symposium on Information Visualization (INFOVIS’06) (to be published), 2006. [3] D. Holten, R. Vliegen, and J.J. van Wijk. Visual Realism for the Visualization of Software Metrics. In 3rd IEEE International Workshop on Visualizing Software for Understanding and Analysis (VISSOFT’05), 2005. [4] A. van Deursen, C. Hofmeister, R. Koschke, L. Moonen, and C. Riva. Symphony: View-Driven Software Architecture Reconstruction. In Proceedings of the IEEE/IFIP Working Conference on Software Architecture (WICSA’04), 2004.
