Jim Q. Ning

Automated program understanding by concept recognition

Program understanding can be seen as the process of understanding abstract concepts in the program code. Thus, automated recognition of abstract concepts may greatly assist the human understanding process. This paper describes an approach to automated concept recognition and its implementation. In the approach, we use a concept model and a library of concept recognition rules to describe what the concepts are and how to recognize them from lower-level concepts. Programming language knowledge as well as domain knowledge are used to aid the recognition of abstract concepts.

Recovering reusable components from legacy systems by program segmentation

There are many reasons to retire a legacy system. But the system may contain critical business rules and other reusable assets that are not explicitly documented anywhere else. A software reengineering technique called program segmentation is described. It supports the recovery of these reusable assets from old code. This technique consists of a focusing step, which helps the analyst localize, understand, and combine functional pieces in large programs, and a factoring step, which extracts the focused functional pieces and packages them into independent reusable modules.<<ETX>>

Toward software plug-and-play

The growing size and complexity of systems has revealed many shortcomings of existing software engineering practices, for example, lack of scalability. This in turn raised interest in component-based and architecture-driven software development. In all likelihood, component-based software will form the foundation on which future systems will be built. The shift toward developing systems from components has been more evolutionary than revolutionary. It has its roots in accepted architectural principles such as layering, modularization, and information hiding. But it also introduces its own principles and concepts and presents new challenges. This paper discusses research ideas and technologies that will facilitate the transition toward component-based software development by leveraging object-oriented middleware technologies such as CORBA and OLE. We also present an innovative component-based development environment to illustrate the ideas we introduce.

Concept recognition-based program transformation

An approach is described that applies a transformation paradigm to automate software maintenance activities. The approach to code-to-code (horizontal) transformation is based on a high-level understanding of the programming and application domain concepts represented by the code. A very unique characteristic of this approach is its use of concept recognition, the understanding and abstraction of high-level programming and application domain entities in programs, as the basis for transformations. A program transformation tool has been developed to support the migration of a large manufacturing control system written in COBOL.<<ETX>>

Program concept recognition

Program understanding can be greatly assisted by automating the recognition of abstract concepts present in the program code. The authors describe an approach to automated concept recognition and its implementation. In the approach, a concept model and a library of concept recognition rules are used to describe what the concepts are and how to recognize them from lower-level concepts. Programming language knowledge as well as domain knowledge are both used to aid the recognition of abstract concepts.<<ETX>>

Component-based software engineering (CBSE)

Component-based software engineering or CBSE represents a new development paradigm: assembling software systems from components. This research area has raised a tremendous amount of interests both in the research community and in the software industry-a rare phenomenon in the field of software engineering. The paper discusses the technology infrastructure necessary to support CBSE. In particular, the authors present the results produced by the CBSE research project conducted at Andersen Consulting in the context of how their approach and tools automate a component-based development paradigm.

A Knowledge-based Approach To Software System Understanding

Software understanding is the process of recovering high-level, functionality-oriented information from the source code. This paper presents a knowledge-based approach to supporting understanding-intensive tasks in software maintenance and re-engineering. The approach uses programming language knowledge to parse the source code and analyze its semantics. It uses general programming and application domain knowledge to automate the recognition of functional concepts. Also, a set of presentation, focusing, and editing tools is provided for the user to view and modify the source code and to extract reusable components from it. Two workbench environments that we have recently developed based on this approach are described.

BAL/SRW: Assembler re-engineering workbench

Abstract BAL/SRW is a knowledge-based interactive software re-engineering workbench for IBM 370 Assembler programs. It assists its user in recovering design specifications directly from Assembler code. BAL/SRW uses a number of re-engineering techniques, including automated code pattern understanding, source code browsing/navigation, control flow analysis, structure simplification and abstraction, and program annotation. It also uses a set of diagramming tools to facilitate capture of program design. The output of BAL/SRW can be fed into computer-aided software engineering (CASE) tools to be used in the forward phase of system re-engineering. The paper describes the major components of the workbench in the context of how they help the analyst examine, abstract, and capture the design information of Assembler programs. It also discusses practical experience in using the workbench on a re-engineering project.

Architecture specification support for component integration

The paper describes an approach to automating the construction of software systems from components. We illustrate how integration-related concerns such as component interfacing, interconnection, distribution and configuration can be modeled with a specification language. We also show how a graphics-based design environment can be used to support visual specification and transformation of integration specifications into implementations. This approach raises the level of architecture specifications to assist the currently labor-intensive and error-prone process of system integration.<<ETX>>

ADE—an architecture design environment for component-based software engineering

The growing size and complexity of systems has revealed many shortcomings of existing software engineering practices, for example, lack of scalability. This in turn raised interest in component-based and architecture-driven software development. In all likelihood, component-based software will form the foundation on which future systems will be built. This research demonstration will show how component-based applications can be quickly assembled in an architecture design environment called ADE.