Object-oriented analysis

For maintainers involved in understanding and reengineering large software, locating source code fragments that match certain patterns is a critical task. Existing solutions to the problem are few, and they either involve manual, painstaking scans of the source code using tools based on regular expressions, or the use of large, integrated software engineering environments that include simple pattern-based query processors in their toolkits. We present a framework in which pattern languages are used to specify interesting code features. The pattern languages are derived by extending the source programming language with pattern-matching symbols. We describe SCRUPLE, a finite state machine-based source code search tool, that efficiently implements this framework. We also present experimental performance results obtained from a SCRUPLE prototype, and the user interface of a source code browser built on top of SCRUPLE. >

A framework for source code search using program patterns

Systems, methods and computer program products enable framework building by interactively generating a framework corresponding to a design and editing the interactively generated framework to obtain a completed framework. The framework is displayed in various stages of construction or modification using a number of different views including a tree view, a graph view, a method view and an edit view. In addition, parts of the framework are identified as requiring completion, as completed, and as permitting completion. Still further, user methods and framework methods are differentiated. Help guided actions are provided and may be invoked to assist in the development process. Once the framework has been completed, it can be stored in a data model, and code can be generated from the completed framework. Finally, interfaces developed using conventional editors may be parsed and imported into the data model for later code generation. As a result of the present invention, code may be generated based on the completed framework and executed in a distributed computing environment.

Systems, methods and computer program products for building frameworks in an object oriented environment

Recovering architectural documentation from code is crucial to maintaining and re-engineering 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.

Recovering high-level views of object-oriented applications from static and dynamic information

Framework programming is regarded as one the main advantages of object-oriented software engineering, and is expected to increase software reuse. In exploiting frameworks, however, programmers often face difficulties caused by the complexity of the hidden architecture and the multiplicity of the design decisions that are embedded in a framework. Interactive visualization of design patterns occurring in a framework shows how the framework is operating, in a flexible yet structured way that contributes to the programmer's understanding of the underlying software architecture. In this way, programmers can explore and use frameworks efficiently even when they are distributed without vast amounts of documentation and source code.

Interactive visualization of design patterns can help in framework understanding

Increasing numbers of programmers find that they must work on large software systems that they did not write and do not entirely understand. In this situation it is necessary for the programmer to build a working model of the system's design. The process of constructing a working design model from studying the source code may be called software archaeology. This paper demonstrates how software archaeology can be done within the framework of an appropriate design methodology using good static analysis tools. The Object-Oriented Design (OOD) methods described by Grady Booch and James Rumbaugh provide the framework for my investigation. The static analysis tools are based on CIA#. The C# Information Abstractor, CIA#, builds a relational database of information extracted from C# programs. The database serves as a foundation for the development of C# programming tools. Current tools in the CIA# system include tools for graphical display of various views of the program structure, tools for queries about program symbols and relationships, and tools that extract cohesive components from a larger system. These tools can be used as they are, combined or extended to adapt to specific needs. @ Computing Systems, Vol. 5 . No. I . Winter 1992 This paper briefly describes the CIA# system and demonstrates how it can be used to extract design information from a significant system: InterViews 3.0, a C# graphical interface toolkit developed by Mark Linton at Stanford University.

/pdf/object-oriented-design-archaeology-with-cia-1zyny9yfmb.pdf

Judith E. Grass

Papers

Object-Oriented Design Archaeology with CIA++.