Specification matching is a way to compare two software components based on descriptions of the components' behaviors. In the context of software reuse and library retrieval, it can help determine whether one component can be substituted for another or how one can be modified to fit the requirements of the other. In the context of object-oriented programming, it can help determine when one type is a behavioral subtype of another. We use formal specifications to describe the behavior of software components, and hence, to determine whether two components match. We give precise definitions of not just exact match, but more relevantly, various flavors of relaxed match. These definitions capture the notions of generalization, specialization, and substitutability of software components. Since our formal specifications are pre- and post-conditions written as predicates in firstorder logic, we rely on theorem proving to determine match and mismatch. We give examples from our impleme...

Software productivity has been steadily increasing over the last 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 [22,39]; nothing short of an order of magnitude increase in productivity will extricate the software industry from its perennial crisis [39,67]. Several decades of intensive research in software engineering and artificial intelligence left few alternatives but sofware 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 [68]. We discuss the implications of such appproaches 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 latter being critical for the building blocks approach. Both sets of issues are discussed in this paper, with a focus on application generators and object-oriented 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.

In this paper, the authors address some of the challenges of the current technologies in the area of component-based programming and automated software downloading. These challenges include: component updating at runtime of affected applications, adopting the "true-push" model in order to allow for silent software modification (e.g. for removing minor implementation errors), and finding a way to integrate these technologies and electronic commerce in software components. To respond to these challenges, the SOFA (SOFtware Appliances) architecture, the SOFA component model and its extension, DCUP (Dynamic Component UPdating), are introduced. SOFA and DCUP provide a small set of well scaling orthogonal abstractions which address three areas: the background for electronic commerce, the component model, and support for dynamic component updating in running applications. The updating granularity can scale anything from minor implementation changes to a major reconfiguration. In contrast with the usual belief that it is difficult to map abstractions supporting component based programming to concrete computer systems, the abstractions proposed by DCUP are very easy to map to the Java and CORBA programming environments.

this document are those of the authors and should not be interpreted as necessarily representing the official policies or endorsements, either expressed or implied, of Wright Laboratory or the U. S. Government. The U. S. Government is authorized to reproduce and distribute reprints for Government purposes notwithstanding any copyright notation thereon. This manuscript is submitted for publication with the understanding that the U. S. Government is authorized to reproduce and distribute reprints for Governmental purposes. Authors' address: School of Computer Science, Carnegie Mellon University, 5000 Forbes Avenue, Pittsburgh, PA 15213; email: amy;wing@cs.cmu.edu. To appear, ACM Transactions on Software Engineering and Methodology (TOSEM), April 1995. Permission to copy without fee all or part of this material is granted provided that the copies are not made or distributed for direct commercial advantage, the ACM copyright notice and the title of the publication and its date appear, and notice is given that copying is by permission of the Association for Computing Machinery. To copy otherwise, or to republish, requires a fee and/or specific permission. c fl 1995 ACM xxxx-xxxx/xx/xxxx-xxxx $xx.xx 2 \Delta A. Moormann Zaremski and J. M. Wing ware libraries successfully, especially as libraries increase in size, is the availability of good tools to organize, navigate through, and retrieve from libraries. Currently many libraries use the file system for their only organization (directories and files) and file system and editor commands for navigation and retrieval. For example, the local ML library is organized with categories of components as directories (e.g., local/lib/Container/, local/lib/Threads/); one uses ls and

Technical, cognitive, and social factors inhibit the widespread success of systematic software reuse. Our research is primarily concerned with the cognitive and social challenges faced by software developers: how to motivate them to reuse and how to reduce the difficulty of locating components from a large reuse repository. Our research has explored a new interaction style between software developers and reuse repository systems enabled by information delivery mechanisms. Instead of passively waiting for software developers to explore the reuse repository with explicit queries, information delivery autonomously locates and presents components by using the developers' partially written programs as implicit queries. We have designed

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.

Deduction-based software component retrieval uses preand postconditions as indexes and search keys and an automated theorem prover (ATP) to check whether a component matches. This idea is very simple but the vast number of arising proof tasks makes a practical implementation very hard. We thus pass the components through a chain of filters of increasing deductive power. In this chain, rejection filters based on signature matching and model checking techniques are used to rule out non-matches as early as possible and to prevent the subsequent ATP from "drowning." Hence, intermediate results of reasonable precision are available at (almost) any time of the retrieval process. The final ATP step then works as a confirmation filter to lift the precision of the answer set. We implemented a chain which runs fully automatically and uses MACE for model checking and the automated prover SETHEO as confirmation filter. We evaluated the system over a medium-sized collection of components. The resul...

Reusing similar requirements fragments is among the promising ways to reduce elaboration time and increase requirements quality. This paper investigates the application of analogical reasoning techniques to complete partial requirements specifications. A case base is assumed to be available; it contains requirements frameworks involving goals, constraints, objects, actions, and agents from systems already specified. We show how a rich requirements meta-model coupled with an expressive formal assertion language may increase the effectiveness of analogical reuse. An acquisition problem is first specified by the requirements engineer as a query formulated in the vocabulary of the specification fragments built so far. Source cases and partial mappings are found by query generalization followed by search through the case base. Once analogies have been confirmed, mappings are completed by use of relevance rules that distinguish in the formal assertions what is relevant to the analogy from what is irrelevant. Best analogies are then selected and extended in such a way that logical properties of the answers to the query may be verified, thus increasing confidence in the analogy. The approach is illustrated by analogical acquisition of specifications of a meeting scheduler in the KAOS goal-oriented specification language.

This paper explores the use of specification matching to discover and select component adaptation strategies. This is done within a formal framework that integrates specification-based component retrieval with a formal architecture representation to support component retrieval and adaptation. The key to integration is determining the relationship between what components are potentially reusable and how they can be properly adapted. An example is given to illustrate how the results of specification matching can be used to guide the selection and application of adaptation tactics and automate component adaptation.

Transactions are contracts that guarantee a consistent, transparent, individual system state transition and their use is widespread in many different kinds of computing systems. Some well known standards (e.g. CORBA) include the specification of services that provide transactional properties. In this paper, we present a formal method for the systematic synthesis of transactional middleware based on the combination of the aforementioned services. The synthesis of transactional middleware is based on (i) the formal specification of transactional properties and (ii) stub code generation.