On the Use of Metaballs to Visually Map Source Code Structures and Analysis Results onto 3D Space Juergen Rilling and S. P. Mudur Department of Computer Science, Concordia University, Canada rilling@cs.concordia.ca, mudur@cs.concordia.ca Abstract Many reverse-engineering tools have been developed to derive abstract representations from existing source code. Graphic visuals derived from reverse engineered source code have long been recognized for their impact on improving the comprehensibility of the structural and behavioral aspects of software systems and their source code. As programs become more complex and larger, the sheer volume of information to be comprehended by developers becomes daunting. In this paper, we combine dynamic source analysis to selectively identify source code that is relevant at any point and combine it with 3D visualization techniques to reverse engineer and analyze source code, program executions, and program structures. For this research, we focus particularly on the use of metaballs, a 3D modeling technique that has already found extensive use representing complex organic shapes and structural relationships in biology and chemistry, to provide suitable 3D visual representations for software systems. Keywords: software visualization, program slicing, 3D modeling, metaballs, visual mapping. 1. Introduction Reverse engineering as part of program comprehension can be described as the process of analyzing subject system components and their interrelationships to create a higher level of abstraction and to understand the program execution and the sequence in which it occurred. The goal of software visualization is to acquire sufficient knowledge about a software system by identifying program artifacts and understanding their relationships. As programs become more complex and larger, the sheer volume of information to be comprehended by the developers becomes daunting. It would be ideal to be able to simultaneously view and understand detailed information about a specific activity in a global context at all times for any size of program. As Ben Shneiderman explains in [25,26], the main goal of every visualization technique is “Overview first, zoom and filter, then details on demand”. This means that visualization should first provide an overview of the whole set of data then let the user restrict the set of data on which the visualization is applied, and finally give more details on the part of interest to the user. Software visualization of source code can be further categorized in static views and dynamic views. The static views are based on a static analysis of the source code and its associated information and provide a more generic high-level view of the system and its source code. The dynamic view is from analysis of monitored program execution. Based on their available run-time information, dynamic views can provide a more detailed and insightful view of the system with respect to a particular program execution. Compared to the static views, the dynamic nature of the information requires additional overhead while gathering the required data. As Mayhauser [16] illustrated, dynamic and static views should be regarded as complementary views rather than being mutually exclusive. Typically, a program performs a large set of functions/outputs. Rather than trying to comprehend all of a program’s functionality, programmers will focus on selected functions (outputs) with the goal of identifying which parts of the program significantly influence those particular functions. One approach is to apply program slicing that allows for a reduction of data to be displayed by including only those software entities (files, modules, classes, functions, statements and objects) that are relevant with respect to the computation of a specific program function of interest. Program slicing is a well-known decomposition technique that transforms a large program into a smaller one that contains only statements relevant to the computation of a selected program function (output). This is particularly of interest for the analysis and comprehension of large software systems and program executions associated with them. Visual representations of programs, primarily based on some diagrammatic notation, have been evolved right from the early days of computing [27]. However, for large, complex software systems, the comprehension of such Proceedings of the Ninth Working Conference on Reverse Engineering (WCRE02) 1095-1350/02 $17.00 ' 2002 IEEE