Software productivity has been steadily increasing over the past 30 years, but not enough to close the gap between the demands placed on the software industry and what the state of the practice can deliver; nothing short of an order of magnitude increase in productivity will extricate the software industry from its perennial crisis. Several decades of intensive research in software engineering and artificial intelligence left few alternatives but software reuse as the (only) realistic approach to bring about the gains of productivity and quality that the software industry needs. In this paper, we discuss the implications of reuse on the production, with an emphasis on the technical challenges. Software reuse involves building software that is reusable by design and building with reusable software. Software reuse includes reusing both the products of previous software projects and the processes deployed to produce them, leading to a wide spectrum of reuse approaches, from the building blocks (reusing products) approach, on one hand, to the generative or reusable processor (reusing processes), on the other. We discuss the implication of such approaches on the organization, control, and method of software development and discuss proposed models for their economic analysis. Software reuse benefits from methodologies and tools to: (1) build more readily reusable software and (2) locate, evaluate, and tailor reusable software, the last being critical for the building blocks approach. Both sets of issues are discussed in this paper, with a focus on application generators and OO development for the first and a thorough discussion of retrieval techniques for software components, component composition (or bottom-up design), and transformational systems for the second. We conclude by highlighting areas that, in our opinion, are worthy of further investigation. >

Reusing software: issues and research directions

Our research centers around exploring methodologies for developing reusable software, and developing methods and toofs for building with reusable software. In this paper, we focus on reusable software component retrieval methods that were developed and teated in the context of ClassServer, an experimental library tool developed at the University of Qu6bec at Montr6al to explore fssues in software reuse [15]. The methods dfscusaed in tbfa paper fall into two categori~ 1) string search-based retrieval metbod$ and 2) keyword-based retrieval methods. Both kinds of methods have been implemented and tested by researchers, both in the context of software repositories (see e.g. [6,9]) and in the context of more traditional document tibrarles (see e.g. [2,25]). Experiments have shown that keyword-based methods, which require some manual, laborintensive pre-proceashrg, performed only marginally better than the entfrely mechanical strhtgsearch methods (see e.g.[6, 2S]), raising the issue of cost-effectivene= of keyword-based methods as compared to string search baaed methods. In this paper, we describe an implementation and experiments which attempt to brfng the two khtds of methods to a level-playing field by: 1) automating as much of the pre-processing involved hr controlled vocabulary-based methods as possible to address the crds issue, and 2) using a realistic experimental setting in which queries consist of problem statemenlx rather than component specifications, in whjch query results are aggregated over several trials, and in which recaU measures take into account overlapping components. Our experiments showed that string search based methods performed better than semi-controlled vocabulary-based method$ which goes further in the direction of more recent component retrfeval experiments which challenged the superiority of controlled vocabulary based clarification and retrieval of components (see e.g. [61).

Another nail to the coffin of faceted controlled-vocabulary component classification and retrieval

In this paper we address the problem of locating the appropriate component in an object-oriented software repository along with the issue of extending the component to adapt it to particular requirements. In order to give support to both types of tasks, we use a CBR approach which allows to profit from past experiences with the use of the repository, and to integrate different knowledge sources under the same representation scheme. This approach has been evaluated through a prototype implementation, which addresses the reuse of a general purpose Smalltalk repository.

Supporting Object Reuse Through Case-Based Reasoning

Our research centers around exploring methodologies for developing reusable software, and developing methods and tools for building inter-enterprise information systems with reusable components. In this paper, we focus on an experiment in which different component indexing and retrieval methods were tested. The results are surprising. Earlier work had often shown that controlled vocabulary indexing and retrieval performed better than full-text indexing and retrieval [IEEE Trans. Software Engng (1994) 1, IEEE Trans. Software Engng 17 (1991) 800], but the differences in performance were often so small that some questioned whether those differences were worth the much greater cost of controlled vocabulary indexing and retrieval [Commun. Assoc. Comput. Mach. 28 (1985) 289, Commun. Assoc. Comput. Mach. 29 (1986) 648]. In our experiment, we found that full-text indexing and retrieval of software components provided comparable precision but much better recall than controlled vocabulary indexing and retrieval of components. There are a number of explanations for this somewhat counter-intuitive result, including the nature of software artifacts, and the notion of relevance that was used in our experiment. We bring to the fore some fundamental questions related to reuse repositories.

/pdf/an-experiment-in-software-component-retrieval-521vwyg004.pdf

An experiment in software component retrieval

A key challenge in Component-Based Software Engineering (CBSE) is finding appropriate software components for reuse. A component broker that allows component vendors to make available their modules, and also allows component integrators to search and select components matching their requirements will help solve this problem. In this paper, we describe an E-Exchange for buying and selling of software components over the World Wide Web. The ComponentXchange uses an XML based specification language for components, which is a semi-formal specification language that can describe a rich and an extensible set of component properties including functional properties, non-functional attributes and licensing aspects. ComponentXchange supports two models of component trading. A component can be used either by downloading it and integrating it into the client application or by accessing it remotely over the network. It has a licensing server that enforces the licensing terms and conditions. ComponentXchange can be easily extended to support different payment models like pay-per-use, pay-per-user, etc.

/pdf/componentxchange-an-e-exchange-for-software-components-4nchgdrq8t.pdf

Peter Elzer

Papers

Practitioner and SoftClass: a comparative study of two software reuse research projects