A. De Lucia

Recovering traceability links between code and documentation

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 a method based on information retrieval to recover 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. We apply both a probabilistic and a vector space information retrieval model in two case studies to trace C++ source code onto manual pages and Java code to functional requirements. We compare the results of applying the two models, discuss the benefits and limitations, and describe directions for improvements.

Program slicing: methods and applications

Program slicing is a viable method to restrict the focus of a task to specific sub-components of a program. Examples of applications include debugging, testing, program comprehension, restructuring, downsizing, and parallelization. The paper discusses different statement deletion based slicing methods, together with algorithms and applications to software engineering.Program slicing is a viable method to restrict the focus of a task to specific sub-components of a program. Examples of applications include debugging, testing, program comprehension, restructuring, downsizing, and parallelization. The paper discusses different statement deletion based slicing methods, together with algorithms and applications to software engineering.

Understanding function behaviors through program slicing

We present conditioned slicing as a general slicing framework for program comprehension. A conditioned slice consists of a subset of program statements which preserves the behavior of the original program with respect to a set of program executions. The set of initial states of the program that characterize these executions is specified in terms of a first order logic formula on the input variables of the program. Conditioned slicing allows a better decomposition of the program giving the maintainer the possibility to analyze code fragments with respect to different perspectives. We also show how slices produced with traditional slicing methods can be reduced to conditioned slices. Conditioned slices can be identified by using symbolic execution techniques and dependence graphs.

Enhancing an artefact management system with traceability recovery features

We present a traceability recovery method and tool based on latent semantic indexing (LSI) in the context of an artefact management system. The tool highlights the candidate links not identified yet by the software engineer and the links identified but missed by the tool, probably due to inconsistencies in the usage of domain terms in the traced software artefacts. We also present a case study of using the traceability recovery tool on software artefacts belonging to different categories of documents, including requirement, design, and testing documents, as well as code components.

Migrating legacy systems towards object-oriented platforms

Presents an approach to migrate legacy systems to object-oriented platforms. The process consists of six sequential phases and encompasses reverse engineering and re-engineering activities. The aim of the reverse engineering phases is to decompose programs into components implementing user interface management and components implementing application domain objects. The identification of objects is centred around a persistent data store and exploits object-oriented design metrics. Wrapping techniques are the core of the re-engineering activities. They make new systems able to exploit existing resources, thus allowing an incremental and selective translation of the identified objects

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.

Identifying reusable functions using specification driven program slicing: a case study

We present the results of a case study in identifying and isolating reusable functions from C programs. The work exploits and specializes to programs written in C the theoretical framework of specification driven program slicing, a new program slicing process for isolating code fragments implementing functional abstractions. The specification of the function to be isolated, given in terms of a precondition and a postcondition, is used to identify a suitable slicing criterion. The preconditions for the execution of program statements and predicates are abstracted by using symbolic execution and compared with the conditions of the specification. The statements whose preconditions are equivalent to the pre and postconditions of the functional abstraction are candidates for entry and exit points of the slice implementing the abstraction. Once the slicing criterion has been identified, the slice can be isolated using algorithms based on control flow graphs and dependence graphs.

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.

Improving Source Code Lexicon via Traceability and Information Retrieval

The paper presents an approach helping developers to maintain source code identifiers and comments consistent with high-level artifacts. Specifically, the approach computes and shows the textual similarity between source code and related high-level artifacts. Our conjecture is that developers are induced to improve the source code lexicon, i.e., terms used in identifiers or comments, if the software development environment provides information about the textual similarity between the source code under development and the related high-level artifacts. The proposed approach also recommends candidate identifiers built from high-level artifacts related to the source code under development and has been implemented as an Eclipse plug-in, called COde Comprehension Nurturant Using Traceability (COCONUT). The paper also reports on two controlled experiments performed with masters and bachelors students. The goal of the experiments is to evaluate the quality of identifiers and comments (in terms of their consistency with high-level artifacts) in the source code produced when using or not using COCONUT. The achieved results confirm our conjecture that providing the developers with similarity between code and high-level artifacts helps to improve the quality of source code lexicon. This indicates the potential usefulness of COCONUT as a feature for software development environments.

ADAMS Re-Trace: a traceability recovery tool

We present the traceability recovery tool developed in the ADAMS artefact management system. The tool is based on an information retrieval technique, namely latent semantic indexing and aims at supporting the software engineer in the identification of the traceability links between artefacts of different types. We also present a case study involving seven student projects, which represented an ideal workbench for the tool. The results emphasise the benefits provided by the tool in terms of new traceability links discovered, in addition to the links manually traced by the software engineer. Moreover, the tool was also helpful in identifying cases of lack of similarity between artefacts manually traced by the software engineer, thus revealing inconsistencies in the usage of domain terms in these artefacts. This information is valuable to assess the quality of the produced artefacts.