G. Canfora

Identifying the starting impact set of a maintenance request: a case study

This paper deals with impact analysis and proposes a method based on information retrieval techniques to trace the text of a maintenance request onto the set of system components initially affected by the maintenance request. The correct identification of such components is crucial for the future design and implementation of the change. The paper also discusses results from a preliminary case study where two different information retrieval approaches have been used to retrieve the software documents relevant for a maintenance request.

Migrating legacy systems to the Web: an experience report

A key to successfully moving to the Internet while salvaging past investments in centralised, mainframe-oriented software development is migrating core legacy applications towards Web-enabled client-server architectures. This paper presents the main results and lessons learned from a migration project aimed at integrating an existing COBOL system into a Web-enabled infrastructure. The original system has been decomposed into its user interface and server (application logic and database) components. The user interface has been migrated into a Web browser shell using Microsoft Active Server Pages (ASP) and VBScript. The server component has been wrapped with dynamic load libraries written in Microfocus Object COBOL, loaded into Microsoft Internet Information Server (IIS), and accessed by the ASP pages.

A reverse engineering method for identifying reusable abstract data types

Results from an experiment in reuse within the RE/sup 2/ project are presented. It is shown how a particular candidature criterion for identifying abstract data types in existing software systems can be applied both at the theoretical and practical level. The RE/sup 2/ project is concerned with the exploration of reverse engineering and reengineering techniques to facilitate reuse reengineering by the identification and classification of approximate candidature criteria.<<ETX>>

Recovering code to documentation links in OO systems

Software system documentation is almost always expressed informally, in natural language and free text. Examples include requirement specifications, design documents, user manual pages, system development journals, error logs and related maintenance reports. We propose an approach to establish and maintain traceability links between the source code and free-text documents. A premise of our work is that programmers use meaningful names for programs items, such as functions, variables, types, classes and methods. We believe that the application domain knowledge that programmers process when writing the code is often captured by the mnemonics for identifiers; therefore, the analysis of these mnemonics can help to associate high-level concepts with program concepts, and vice versa. In this paper, the approach is applied to software written in an object-oriented (OO) language, namely C++, to trace classes to manual sections.

Tracing object-oriented code into functional requirements

Software system documentation is almost always expressed informally, in natural language and free text. Examples include requirement specifications, design documents, manual pages, system development journals, error logs and related maintenance reports. We propose an approach to establish and maintain traceability links between source code and free text documents. A premise of our work is that programmers use meaningful names for program items, such as functions, variables, types, classes, and methods. We believe that the application-domain knowledge that programmers process when writing the code is often captured by the mnemonics for identifiers; therefore, the analysis of these mnemonics can help to associate high level concepts with program concepts, and vice-versa. The approach is applied to software written in an object oriented language, namely Java, to trace classes to functional requirements.

A case study of applying an eclectic approach to identify objects in code

The identification of objects in procedural programs has long been recognised as a key to successful comprehension. As a consequence, several authors have proposed methods and tools that achieve, in general, some level of success, but do not always precisely identify a coherent set of objects. We show that using an eclectic approach, where a domain expert software engineer is encouraged to tailor and combine existing approaches, may overcome the limitation of the single approaches and helps to better address the particular goals of the project at hand and the unique aspects of the subject system. The eclectic approach is illustrated by reporting experiences from a case study of identifying coarse-grained, persistent objects to be used in the migration of a COBOL system to a distributed component system.

An extensible system for source code analysis

Constructing code analyzers may be costly and error prone if inadequate technologies and tools are used. If they are written in a conventional programming language, for instance, several thousand lines of code may be required even for relatively simple analyses. One way of facilitating the development of code analyzers is to define a very high-level domain-oriented language and implement an application generator that creates the analyzers from the specification of the analyses they are intended to perform. This paper presents a system for developing code analyzers that uses a database to store both a no-loss fine-grained intermediate representation and the results of the analyses. The system uses an algebraic representation, called F(p), as the user-visible intermediate representation. Analyzers are specified in a declarative language, called F(p)-l, which enables an analysis to be specified in the form of a traversal of an algebraic expression, with access to, and storage of, the database information the algebraic expression indices. A foreign language interface allows the analyzers to be embedded in C programs. This is useful for implementing the user interface of an analyzer, for example, or to facilitate interoperation of the generated analyzers with pre-existing tools. The paper evaluates the strengths and limitations of the proposed system, and compares it to other related approaches.

Decomposing legacy systems into objects: an eclectic approach

Abstract The identification of objects in procedural programs has long been recognised as a key to renewing legacy systems. As a consequence, several authors have proposed methods and tools that achieve, in general, some level of success, but do not always precisely identify a coherent set of objects. We show that using an eclectic approach, where a domain expert software engineer is encouraged to tailor and combine existing approaches, may overcome the limitation of the single approaches and helps to better address the particular goals of the project at hand and the unique aspects of the subject system. The eclectic approach is illustrated by reporting experiences from a case study of identifying coarse-grained, persistent objects to be used in the migration of a COBOL system to a distributed component system.

Decomposing legacy programs: a first step towards migrating to client-server platforms

We propose an approach to program decomposition as a preliminary step for the migration of legacy systems. A program slicing algorithm is defined to identify the statements implementing the user interface component. An interactive re-engineering tool is also presented that supports the software engineer in the comprehension of the source code during the decomposition of a program. The focus of this paper is on the partition of a legacy system, while issues related to the re-engineering, encapsulation, and wrapping of the legacy components and to the definition of the middleware layer through which they communicate are not tackled.

Integrating document and workflow management tools using XML and web technologies: a case study

A critical point for developing successful information systems for distributed organisations is the need for integrating heterogeneous technologies and tools. This paper reports a case study of integrating two key enabling technologies, namely workflow and document management. Integration is achieved by combining several approaches, including software engineering and hypertexts. In this way, we raise the integration problem from the level of a purely technical issue to a level of conceptual modelling: integration is not focused solely on the information/software systems but involves, and is driven by, the related business processes and the documents they deal with.