Understanding the implementation of a certain feature of a system requires to identify the computational units of the system that contribute to this feature. In many cases, the mapping of features to the source code is poorly documented. In this paper, we present a semi-automatic technique that reconstructs the mapping for features that are triggered by the user and exhibit an observable behavior. The mapping is in general not injective; that is, a computational unit may contribute to several features. Our technique allows to distinguish between general and specific computational units with respect to a given set of features. For a set of features, it also identifies jointly and distinctly required computational units.

Information visualizations must allow users to browse information spaces and focus quickly on items of interest. Being able to see some representation of the entire information space provides an initial gestalt overview and gives context to support browsing and search tasks. However, the limited number of pixels on the screen constrain the information bandwidth and make it difficult to completely display large information spaces. The Information Mural is a two-dimensional, reduced representation of an entire information space that fits entirely within a display window or screen. The mural creates a miniature version of the information space using visual attributes such as grayscale shading, intensity, color, and pixel size, along with anti-aliased compression techniques. Information Murals can be used as stand-alone visualizations or in global navigational views. We have built several prototypes to demonstrate the use of Information Murals in visualization applications; subject matter ...

Software change requests are often formulated as requests to modify or to add a specific feature or concept. To implement these changes, the features or concepts must be located in the code. In this paper, we describe the scenarios of the feature and concept location. The scenarios utilize a computer-assisted search of software dependence graph. Scenarios are demonstrated by a case study of NCSA Mosaic source code. 1. Introduction In software maintenance and evolution, change requirements are often formulated as requests to modify or to add specific program concepts or features [2, 26]. An example of such a request is "Add a new external viewer to Mosaic web browser". Before any actual change can be made to the system, software programmers must locate the implementation of the concepts ("external viewer") in the source code. Concept location is a process that maps domain concepts to the software components. The input is the maintenance request, expressed in natural language and usin...

Recovering architectural documentation from code is crucial to maintaining and reengineering software systems. Reverse engineering and program understanding approaches are often limited by the fact that (1) they propose a fixed set of predefined views and (2) they consider either purely static or purely dynamic views of the application. In this paper we present an environment supporting the generation of tailorable views of object-oriented systems from both static and dynamic information. Our approach is based on the combination of user-defined queries which allow an engineer to create high-level abstractions and to produce views using these abstractions.

Modeling object-oriented applications using collaborations and roles is now well accepted. Collaboration-based or role-based designs decompose an application into tasks performed by a subset of the applications' classes. Collaborations provide a larger unit of understanding and reuse than classes, and are an important aid in the maintenance and evolution of the software. This kind of design information is lost, however, at the implementation level, making it hard to maintain and evolve an existing software application. The extraction of collaborations from code is therefore an important issue in design recovery. In this paper we propose an iterative approach which uses dynamic information to support the recovery and understanding of collaborations. We describe a tool we have developed to support our approach and demonstrate its use on a case study.

To fully understand the underlying architecture of an object-oriented software system, both static and dynamic analyses are needed. Dynamic reverse engineering techniques are especially important for understanding the run-time behavior of objects in a distributed object systems and in systems that rely heavily on polymorphism. Shimba, a prototype reverse engineering environment, has been built to support understanding an existing Java software system. The dynamic event trace information is generated automatically as a result of running the target system under a customized sdk [14] debugger and viewed as scenario diagrams using the SCED tool [5]. In SCED, state diagrams can be synthesized automatically from scenario diagrams. This facility is used to visualize the total behavior of a selected object or method, disconnected from the rest of the system. This paper demonstrates how Shimba aids understanding the behavior of Java programs. A case study in made to validate the usefulness of ...

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.

Abstract not found

Understanding the run-time behavior of object-oriented legacy systems is a complex task due to factors such as late binding and polymorphism. Current approaches extract and use information from the complete execution trace of a system. The sheer size and complexity of such traces make their handling, storage, and analysis difficult. Current software systems which run almost non-stop do not permit such a full analysis. In this paper we present a lightweight approach based on the extraction of a condensed amount of information, e.g., measurements, that does not require a full trace. Using this condensed information, we propose a visualization approach which allows us to identify and understand certain aspects of the objects' lifetime such as their role played in the creation of other objects and the communication architecture they support.

The diagnosis of performance and memory problems can require the analysis of large and complex data sets describing a program’s execution. An analysis tool must help the user both find the right organization of the data to uncover useful information, and work with the data through a lengthy and unpredicatable discovery process. In this paper we present Jinsight EX, a tool for analyzing Java performance, that adopts techniques that have been successfully used to explore large data sets in other application domains, and adapts them specifically to the needs of program execution analysis. We introduce execution slices, a high-level organizing abstraction that the user may define and then easily reuse in various settings. We illustrate techniques that allow the user to perform a range of common analysis tasks and to structure a longer analysis process, using this abstraction. We present the tool, its implementation and initial experience of its use. 1.