Software visualization tools face many challenges in terms of their implementation, including scalability, usability, adaptability, and durability. Such tools, like many other research tools, tend to have a short life cycle and are vulnerable to software evolution processes because of the complex problem domain and the constantly changing requirements which are dictated by research goals. In this paper we discuss the implementation of the software visualization tool CodeCrawler according to five criteria, namely the overall architecture, the internal architecture, the visualization engine, the metamodel and the interactive facilities. This discussion generates implementation recommendations and design guidelines that hold for our tool and the class of tools its stands for. We then also extract common design guidelines and recommendations that apply for other software visualization and general reverse engineering tools as well, and hope that these insights can be used fruitfully by other researchers in this field.

Authentic descriptions of a software architecture are required as a reliable foundation for any but trivial changes to a system. Far too often, architecture descriptions of existing systems are out of sync with the implementation. If they are, they must be reconstructed. There are many existing techniques for reconstructing individual architecture views, but no information about how to select views for reconstruction, or about process aspects of architecture reconstruction in general. In this paper we describe view-driven process for reconstructing software architecture that fills this gap. To describe Symphony, we present and compare different case studies, thus serving a secondary goal of sharing real-life reconstruction experience. The Symphony process incorporates the state of the practice, where reconstruction is problemdriven and uses a rich set of architecture views. Symphony provides a common framework for reporting reconstruction experiences and for comparing reconstruction approaches. Finally, it is a vehicle for exposing and demarcating research problems in software architecture reconstruction.

To maintain and understand large applications, it is important to know their architecture. The first problem is that unlike classes and packages, architecture is not explicitly represented in the code. The second problem is that successful applications evolve over time, so their architecture inevitably drifts. Reconstructing the architecture and checking whether it is still valid is therefore an important aid. While there is a plethora of approaches and techniques supporting architecture reconstruction, there is no comprehensive software architecture reconstruction state of the art and it is often difficult to compare the approaches. This article presents a state of the art in software architecture reconstruction approaches.

We propose that collaborative software visualization can improve team software maintenance. We first review how visualization can support software maintenance from the perspectives of system understanding, process understanding and software evolution. From this, we conclude that visualization tools are rarely designed to provide explicit support for collaborative authoring and sharing of views. We then provide an overview of research from a Computer Supported Cooperative Work perspective, and propose that this research should be applied to software visualization. We explore the opportunities and challenges this research focus presents and conclude that more attention paid to the social aspects of software visualization should improve both individual and team processes in software maintenance. 1.

Recently, many software visualization (SV) techniques and tools have become available to developers in order to help them understand their software. In our project, firstly, we identified a list of SV tools that we described, and evaluated qualitatively using the taxonomy of Price et al. Our experience with this taxonomy as well as the impact of the qualitative evaluation on Bell Canada will be discussed in this paper. Then, a quantitative evaluation was conducted in spring 2000 with more than 100 participants. In this paper, we especially put the emphases on the perspectives of the results, by reporting on our experiences and by discussing the major findings and their impact.

This paper describes a case study that uses clustering to group classes of an existing objectoriented system of significant size into subsystems. The clustering process is based on the structural relations between the classes: associations, generalizations and dependencies. We experiment with different combinations of relationships and different ways to use this information in the clustering process. The results clearly show that dependency relations are vital to achieve good clusterings. The clustering is performed with a third party tool called Bunch. Compared to other clustering methods the results come relatively close to the result of a manual reconstruction. Performance wise the clustering takes a significant amount of time, but not too much to make it unpractical. In our case study, we base the clustering on information from multiple versions and compare the result to that obtained when basing the clustering on a single version. We experiment with several combinations of versions. If the clustering is based on relations that were present in both the reconstructed and the first version this leads to a significantly better clustering result compared to that obtained when using only information from the reconstructed version. 1.

Graphic visuals derived from reverse engineered source code have long been recognized for their impact on improving the comprehensibility of structural and behavioral aspects of large software systems and their source code. A number of visualization techniques, primarily graph-based, do not scale. Some other proposed techniques based on 3D metaphors tend to obscure important structural relationships in the program. Multiple views displayed in overlapping windows are suggested as a possible solution, which more often than not results in problems of information overload and cognitive discontinuity. In this paper, we first present a comprehensive survey of related work in program comprehension and software visualization, and follow it up with a detailed description of our research which uses program slicing for deriving program structure-based attributes and 3D-metaball-based rendering techniques to help visualization-based analysis of source code structure. Metaballs, a 3D modeling technique, has already found extensive use for representing complex organic shapes and structural relationships in biology and chemistry. We have developed a metaball software visualization system in Java3D, named MetaViz. As proof of concept, using MetaViz, we demonstrate the creation of 3D visuals that are intuitively comprehensible and communicate information about relative component complexity and coupling among components and therefore enhance comprehension of the program structure.

Abstract not found

We address the problem of users creating visualizations to debug and understand multi-agent systems. To expedite the process of creating visualizations, we have developed VizScript, a collection of tools, which combines a generic application instrumentation, a knowledge base, and simple scene definition primitives with a reasoning system. Using VizScript we were able to recreate the visualizations for a complex multiagent system with an order-of-magnitude less effort than was required in a Java implementation.

New component-based techniques are emerging, leading to new ways to develop software. Industrial component technologies such as COM, JavaBeans, EJB, or CCM are powerful but their extensive use leads to component-based software products that are difficult to understand. This paper discusses several issues in visualizing component-based software products, namely the visualization of the component model itself, the visualization of software components and finally the visualization of software assemblies.