G. Casazza

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.

Object-oriented design patterns recovery

Abstract Object-Oriented (OO) design patterns are an emergent technology: they are reusable micro-architectures, high-level building blocks. A system which has been designed using well-known, documented and accepted design patterns is also likely to exhibit good properties such as modularity, separation of concerns and maintainability. While for forward engineering the benefits of using design patterns are clear, using reverse engineering technologies to discover instances of patterns in a software artifact (e.g., design or code) may help in several key areas, among which are program understanding, design-to-code traceability and quality assessment. This paper describes a conservative approach and experimental results, based on a multi-stage reduction strategy using OO software metrics and structural properties to extract structural design patterns from OO design or C++ code. To assess the effectiveness of the pattern recovery approach, a process and a portable tool suite written in Java, remotely accessible by means of any WEB browser, has been developed. The developed system and experimental results on 8 industrial software (design and code) and 200,000 lines of public domain C++ code are presented.

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.

Modeling clones evolution through time series

The actual effort to evolve and maintain a software system is likely to vary depending on the amount of clones (i.e., duplicated or slightly different code fragments) present in the system. This paper presents a method for monitoring and predicting clones evolution across subsequent versions of a software system. Clones are firstly identified using a metric-based approach, then they are modeled in terms of time series identifying a predictive model. The proposed method has been validated with an experimental activity performed on 27 subsequent versions of mSQL, a medium-size software system written in C. The time span period of the analyzed mSQL releases covers four years, from May 1995 (mSQL 1.0.6) to May 1999 (mSQL 2. 0. 10). For any given software release, the identified models was able to predict the clone percentage of the subsequent release with an average error below 4 %. A higher prediction error was observed only in correspondence of major system redesign.

An approach for reverse engineering of web-based applications

The new possibilities offered by WEB applications are pervasively and radically changing several areas. WEB applications, compared to WEB sites, offer substantially greater opportunities: a WEB application provides the WEB user with a means to modify the site status. WEB applications must cope with an extremely short development/evolution life cycle. Usually, they are implemented without producing any useful documentation for subsequent maintenance and evolution, thus compromising the desired high level of flexibility, maintainability, and adaptability that is de-facto necessary to compete and survive to market shakeout. This paper presents an approach inspired by the reverse engineering arena and a tool prototype supporting WEB application reverse engineering activities, to help maintain, comprehend and evolve WEB applications. The approach defines a set of abstract views, modeled using UML diagrams, organized into a hierarchy of different abstraction levels, depicting several aspects of a WEB application to facilitate its comprehension. A real world WEB application was used as case study, and information previously not available was recovered, with encouraging results.

Maintaining traceability links during object-oriented software evolution

This paper presents a method to build and maintain traceability links and properties of a set of object‐oriented software releases. The method recovers an ‘as is’ design from C++ software releases, compares recovered designs at the class interface level, and helps the user to deal with inconsistencies by pointing out regions of code where differences are concentrated. The comparison step exploits edit distance and a maximum match algorithm. The method has been experimented with on two freely available C++ systems. Results as well as examples of applications to the visualization of the traceability information and to the estimation of the size of changes during maintenance are reported in the paper. Copyright

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 method to re-organize legacy systems via concept analysis

Proposes a method to restructure the organization of architectural source code files. The method exploits concept analysis and is based on the extraction of compiling, linking and inclusion dependencies. The method was applied to public-domain and freely-available software systems developed with the C programming language. The results presented and discussed in this paper are encouraging: the method was always able to identify, for each executable (i.e. main module), all the other modules required to successfully compile a working system. Moreover, the candidate libraries retrieved by the method almost always match those created by developers. Finally, the directory organization was judged to be very effective, even if it was different from the original one.

Modeling Web maintenance centers through queue models

The Internet and the World Wide Webs pervasiveness are changing the landscape of several different areas, ranging from information gathering/managing and commerce to software development, maintenance and evolution. Traditional telephone-centric services, such as ordering of goods, maintenance/repair intervention requests and bug/defect reporting, are moving towards Web-centric solutions. This paper proposes the adoption of queuing theory to support the design, staffing, management and assessment of Web-centric service centers. Data from a mailing list archiving a mixture of corrective maintenance and information requests were used to mimic a service center. Queuing theory was adopted to model the relation between the number of servers and the performance level. Empirical evidence revealed that, by adding an express lane and a dispatcher service time, the variability is greatly reduced and more complex business rules may be implemented. Moreover, express-lane customers experience a reduction of service time, even in the presence of a significant percentage of requests erroneously routed by the dispatcher.

A queue theory-based approach to staff software maintenance centers

The Internet and WEB pervasivenesses are changing the landscape of several different areas, ranging from information gathering/managing and commerce to software development, maintenance and evolution. Software companies having a geographically distributed structure, or geographically distributed customers, are adopting information communication technologies to cooperate. Communication technologies and infrastructures allow the companies to create a virtual software factory. This paper proposes to adopt queue theory to deal with an economically relevant category of problems: the staffing, the process management and the service level evaluation of massive maintenance projects in a virtual software factory. Data from a massive corrective maintenance intervention were used to simulate and study different service center configurations, in particular, a monolithic configuration and a configuration corresponding to a multi-phase maintenance process where several maintenance centers cooperated. Queue theory allowed effective control of the process supporting project management decisions. The mathematical tool provided a means to assess staffing, evaluate service level and balance the workload between maintenance centers while executing the project.