The paper focuses on investigating the combined use of semantic and structural information of programs to support the comprehension tasks involved in the maintenance and reengineering of software systems. Here, semantic refers to the domain specific issues (both problem and development domains) of a software system. The other dimension, structural, refers to issues such as the actual syntactic structure of the program along with the control and data flow that it represents. An advanced information retrieval method, latent semantic indexing, is used to define a semantic similarity measure between software components. Components within a software system are then clustered together using this similarity measure. Simple structural information (.e., file organization) of the software system is then used to assess the semantic cohesion of the clusters and files, with respect to each other. The measures are formally defined for general application. A set of experiments is presented which demonstrates how these measures can assist in the understanding of a nontrivial software system, namely a version of NCSA Mosaic.

Source code duplication occurs frequently within large software systems. Pieces of source code, functions, and data types are often duplicated in part, or in whole, for a variety of reasons. Programmers may simply be reusing a piece of code via copy and paste or they may be "reinventing the wheel".

A controlled experiment was conducted comparing information retrieval using a Galois lattice structure with two more conventional retrieval methods: navigating in a manually built hierarchical classification and Boolean querying with index terms. No significant performance difference was found between Boolean querying and the Galois lattice retrieval method for subject searching with the three measures used for the experiment: user searching time, recall and precision. However, hierarchical classification retrieval did show significantly lower recall compared to the two other methods. This experiment suggests that retrieval using a Galois lattice structure may be an attractive alternative since it combines a good performance for subject searching along with browsing potential. 11/12/98 2 1. Introduction Information retrieval is concerned with the representation, storage, organization, and accessing of information items (Salton & McGill, 1983). As opposed to the traditional f...

The ability to rapidly locate useful on-line services (e.g. software applications, software components, process models, or service organizations), as opposed to simply useful documents, is becoming increasingly critical in many domains. As the sheer number of such services increases it will become increasingly more important to provide tools that allow people (and software) to quickly find the services they need, while minimizing the burden for those who wish to list their services with these search engines. This can be viewed as a critical enabler of the `friction-free' markets of the `new economy'. Current service retrieval technology is, however, seriously deficient in this regard. The information retrieval community has focused on the retrieval of documents, not services per se, and has as a result emphasized keyword-based approaches. Those approaches achieve fairly high recall but low precision. The software agents and distributed computing communities have developed...

Today’s software developments are faced with steadily increasing expectations: software has to be developed faster, better, and cheaper. At the same time, application complexity increases. Meeting these demands requires fast, continuous learning and the reuse of past experience on the part of the project teams. Thus, learning and reuse should be supported by well-defined processes applicable to all kinds of experience which are stored in an organizational memory. In this paper, we introduce a tool architecture supporting continuous learning and reuse of all kinds of experience from the software engineering domain and present the underlying methodology. 1.

Changes of software systems are less expensive and less error-prone if they affect only one subsystem. Thus, clusters of artifacts that are frequently changed together are subsystem candidates. We introduce a two-step method for identifying such clusters. First, a model of common changes of software artifacts, called co-change graph, is extracted from the version control repository of the software system. Second, a layout of the co-change graph is computed that reveals clusters of frequently co-changed artifacts. We derive requirements for such layouts, and introduce an energy model for producing layouts that fulfill these requirements. We evaluate the method by applying it to three example systems, and comparing the resulting layouts to authoritative decompositions.

The architecture of a software system classifies its components into subsystems and describes the relationships between the subsystems. The information contained in such an abstraction is of immense significance in various software maintenance activities. There is considerable interest in extracting the architecture of a software system from its source code, and hence in techniques that classify the components of a program into subsystems. Techniques for classifying subsystems presented in the literature differ in the type of components they place in a subsystem and the information they use to identify related components. However, these techniques have been presented using different terminology and symbols, making it harder to perform comparative analyses. This paper presents a unified framework for expressing techniques of classifying subsystems of a software system. The framework consists of a consistent set of terminology, notation, and symbols that may be used to describe the input, output, and processing performed by these techniques. Using this framework several subsystem classification techniques have been reformulated. This reformulation makes it easier to compare these techniques, a first step towards evaluating their relative effectiveness.

This article outlines an approach that avoids these problems by choosing a retrieval method that utilizes minimal repository structure to effectively support the process of finding software components. The approach is demonstrated through a pair of proof-ofconcept prototypes: PEEL, a tool to semiautomatically identify reusable components, and CodeFinder, a retrieval system that compensates for the lack of explicit knowledge structures through a spreading activation retrieval process. CodeFinder also allows component representations to be modified while users are searching for information. This mechanism adapts to the changing nature of the information in the repository and incrementally improves the repository while people use it. The combination of these techniques holds potential for designing software repositories that minimize up-front costs, effectively support the search process, and evolve with an organization's changing needs.

Using formal specifications to represent software components facilitates the determination of reusability because they more precisely characterize the functionality of the software, and the well-defined syntax makes processing amenable to automation. We present specification matching as a method for classification, retrieval, and modification of reusable components. A software component is specified in terms of order-sorted predicate logic. For both components and methods, we consider not only exact match, but also relaxed match and logical match for performing specification matching over a library of reusable software components. 1 Introduction Software reuse has been claimed to be a means for overcoming the software crisis [1, 2]. However, current techniques to represent and manage software component libraries are not sufficient. Information retrieval methods based on analyses of natural-language documentation have been proposed [3, 4] for constructing software libraries. Unfortuna...

As the application of computer technology continues to proliferate and diversify, the identification and understanding of application domains is becoming increasingly important to software development methodologies. Domain analysis techniques have been developed to accumulate and formalize the knowledge necessary for successful software reuse. These techniques have been shown to be useful, but suffer from defining the domain too restrictively, burying important relationships deep in domain taxonomies, and prohibiting flexible identification of domains with common issues. Techniques are needed that dynamically detect recurring patterns of activities in development projects. This paper presents a method for developing and refining the knowledge and experience accumulated by a development organization so it can learn from previous efforts. A case-based repository of project experiences supports the re-use and refinement of domain knowledge to reduce duplicate effort, build on successful e...