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.

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 of the same source file during a project lifetime. 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 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. CR categories: H.5.2[User interfaces]: evaluation/methodology; I.3.2 [Graphic systems]: stand-alone systems; J.7 [Computers in other systems]: command and control

Recovering the architecture of large evolving software is challenging. The first problem to be solved is to define what "software architecture" means in the company, and which architectural viewpoints are required by each stakeholder. In order to solve this problem, this paper provides a metamodel-driven implementation of the View Set Scenario. This paper shows how metamodels help in defining architectural viewpoints and how metamodels can be use to drive architecture recovery processes. The concepts presented in this paper were identified over the last decade in the context of a tight collaboration with Dassault Systmes, one of the largest software companies in Europe. The process pattern identified is however general and can be applied in other contexts. This process fits in the MDA and ADM approaches from the OMG. It also complies with the IEEE Standard 1471 for software architecture.

The comprehensive understanding of a large software system is a daunting task because of the sheer size and complexity that such systems exhibit. In this context software visualization is a widely used approach, since well-conceived visual representations allow one to spot patterns. The large majority of visualizations use 2D representations, because they are easier to construct, navigate, and interact with. 3D representations usually exploit the 3rd dimension as an additional means to encode quantitative values, which is dismissed by many as a too small benefit in the light of the added complexity in terms of navigation and interaction. We argue that a well-constructed, interactive, and easily navigable 3D visualization can greatly help in program comprehension tasks by supporting habitability. Habitability transmits to a developer the notion that a software system is a physical space with strong orientation points. This can give developers the feeling of being “at home ” in a system. We propose a 3D visualization of software systems hinging on the city metaphor. It is useful for program comprehension because it leads to clarity about the overall structure of a system. We apply our visualization technique on two large systems and discuss its benefits and drawbacks. 1

Far too often, architecture descriptions of existing software systems are out of sync with the implementation. If they are, they must be reconstructed, but this is a very challenging task. The first problem to be solved is to define what "software architecture" means in the company. The answer can greatly vary, especially among the many stakeholders. In order to solve this problem, this paper presents CacOphoNy, a generic metamodel-driven process for reconstructing software architecture. This paper provides a methodological guide and shows how metamodels can be used (1) to define architectural viewpoints, (2) to link these viewpoints to existing metaware and (2) to drive architecture reconstruction processes. The concepts presented in this paper were identified over the last decade in the context of Dassault Systmes, one of the largest software companies in Europe, with more than 1200 developers. CacOphoNy is however a very generic process pattern, and as such it can be applied in many other contexts. This process pattern is in line with the MDA and ADM approaches from the OMG. It also complies with the IEEE Standard 1471 for software architecture. A megamodel integrating these standards is presented.

Software evolution-in-the-large is a challenging issue. While most research work concentrates on the evolution of "programs", large scale software evolution should be driven by much higher levels of abstraction. Software architecture is an example of such abstraction. The notion of co-evolution between architecture and implementation has been identified and studied recently. This paper claims that other abstraction dimensions should also be taken into account, leading to what we call the 3D software space. This conceptual framework is used to reason about evolution-in-the-large phenomena occurring in industry. The meta dimension, which constitutes the core of the MDA approach, is considered as fundamental. This paper makes the distinction between appliware and metaware and put the lights on meta-model and model co-evolution. Conversely to the MDA approach which makes the implicit assumption that meta-models are neat, stable and standardized, in this paper meta-models are considered as complex evolving software artefacts that are most often recovered from existing metaware tools rather than engineered from scratch. In fact, we identified the notion of meta-model and model co-evolution in the context of the evolution of a multimillion LOC component-based software developed by one of the largest software companies in Europe.

There are so many kinds of software structures in a very large software product, that it is almost impossible to build a specific visualization tool for each specific need. In such a context, flexibility is very important. In this paper we claim, that producing a specific view on a large software product, should be as simple as using a spreadsheet to produce a new view on an arbitrary set of data. Instead of building visualization tools from scratch, existing components should be reused whenever possible. In particular it should be possible to connect interactively source components (those providing information on software) and visualization components (those displaying graphical views). To support this approach, we have built G SEE , a Generic Software Exploration Environment making it possible to visualize virtually any kind of software structures at a very low cost.

Tool adoption is a major issue in software engineering. In the last decades many ideas and tools have been developed in laboratories but only a few of them had a direct impact on software industry. This paper presents the results of a ten-years collaboration between the LSR-IMAG laboratory and Dassault Systmes, one of the major software companies in Europe. Two scenarii in tool adoption are described. The first one describes the successful adoption of a configuration management tool, the second one describes issues in deploying reverse architecting tool in the company.

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.

Industrial software systems are large and complex, both in terms of the software entities and their relationships. Consequently, understanding how a software system works requires the ability to pose queries over the design-level entities of the system. Traditionally, this task has been supported by simple tools (e.g., grep) combined with the programmer’s intuition and experience. Recently, however, specialized code query technologies have matured to the point where they can be used in industrial situations, providing more intelligent, timely, and efficient responses to developer queries. This working session aims to explore the state of the art in code query technologies, and discover new ways in which these technologies may be useful in program comprehension. The session brings together researchers and practitioners. We survey existing techniques and applications, trying to understand the strengths and weaknesses of the various approaches, and sketch out new frontiers that hold promise.