Reverse Engineering Low-Level Design Patterns From Object-Oriented Code.

The purpose of this research is to develop and automatically extract an abstract representation model of object-oriented (abbreviated as OO) software systems that captures the structure of the system and code dependencies, in order to aid maintenance. The research resulted in the development of two abstract representation models--the low-level design pattern (LLDP) abstract model and the low-level software architecture (LLSA) abstract model. The LLDP model is at a higher level of abstraction than the LLSA model. The LLSA model acts as an intermediate representation between the LLDP model and an OO software system. The design of the LLSA and LLDP representation models and the automatic extraction of these models from an OO software system are significant contributions of this research. An LLDP representation is a textual description of common OO strategies. Three sets of LLDPs--polymorphism, decoupling and messages are defined. LLDPs describe the structure, the benefits and consequences of a strategy. The design of the LLSA model considers the complexities inherent in OO systems, and the requirements of a maintainer from such a model. The LLSA model defines software components, static and dynamic interfaces of components and static and dynamic interactions between components. Software components are defined in terms of OO programming language constructs and interactions between the components are defined in terms of OO relationships that exist between the components. Understanding the relationships is necessary to understand what dependencies occur and why they occur in the code. The LLSA abstract model in conjunction with the LLDPs provides a view of software systems that captures the dependency relationships between code, the nature of the dependencies and the reasons why the dependencies must exist and be preserved. The LLSA model of C++ software systems in particular are defined. The usefulness of LLSA and LLDPs from the maintenance perspective are explored. A prototype CASE tool, pulse was implemented to demonstrate the feasibility of automatic extraction of both models. Reverse engineering and code analysis techniques were developed to extract the LLSA relationships and interfaces and to recognize LLDPs

A Methodology to Support the Maintenance of Object -Oriented Systems Using Impact Analysis.

Object-Oriented (OO) systems are difficult to understand due to the complex nature of the relationships that object-orientation supports. Inheritance, polymorphism, encapsulation, information hiding, aggregation, and association combine to make maintenance of OO systems difficult. Due to the presence of these characteristics in OO systems, maintenance activities on OO systems often have unexpected or unseen effects on the system. These effects can ripple through system components, complicating maintenance and testing of the system. The ability to trace the effects of maintenance provides the maintainer with knowledge that assists in debugging and testing modified and affected components. In this research, we show that the architecture of an OO system provides an effective framework for determining the impact of system changes. We developed the Comparative Software Maintenance (CSM) methodology to support the maintenance of OO systems. Through this methodology, we model relationships and structures, analyze the models to determine components that change as a result of maintenance, and perform impact analysis to determine components that are candidates for re-testing as a result of maintenance activity. The methodology includes a new data model, called Extended Low-Level Software Architecture (ELLSA), that facilitates impact analysis. CSM locates potential side effects, ripple effects, and other effects of maintenance on class structures, methods, and objects. The comprehensive architecture model enables CSM to perform either predictive, pre-modification impact analysis or post-modification impact analysis. The improved impact analysis process found in the methodology determines impact of changes to the component level. We apply the results of impact analysis to determine component level testing requirements. CSM enhances program understanding through the use of ELLSA. It also provides assistance for capturing complex dependencies found in object-oriented code. The methodology is implemented in JFlex. The automation provided by JFlex makes the application of CSM feasible

A Tool for the Maintenance of C++ Programs

This paper describes a tool that helps programmers understand object-oriented software systems written in C++, a language that is expected to gain widespread use in industry. This task is accomplished by providing information about the set of classes and files comprising the system and the relationships among them. The tool described enables its users to easily browse through the system based on the relations among its classes, files and even identifiers. In addition, the flexible use of global text styles enhances the readability of the source code. The second part of the paper describes some details about the implementation of the tool. In particular, problems are mentioned that arise when performing static analysis of C++ programs. This analysis is necessary for obtaining information needed about the program system. The primary goal of developing the tool has been to support software maintenance, but its use is in no way limited to that process. Introduction Many facts emphasize th..