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.

This thesis develops a semantic model of inheritance and investigates its applications for the analysis and design of programming languages. Inheritance is a mechanism for incremental programming in the presence of self-reference. This interpretation of inheritance is formalized using traditional techniques of fixed-point theory, resulting in a compositional model of inheritance that is directly applicable to object-oriented languages. Novel applications of inheritance revealed by the model are illustrated to show that inheritance has wider significance beyond object-oriented class inheritance. Constraints induced by self-reference and inheritance are investigated using type theory and yield a formal characterization of abstract classes and a demonstration that the subtype relation is a direct consequence of the basic mechanism of inheritance. The model is proven equivalent to the operational semantics of inheritance embodied by the interpreters of object-oriented languages like Smalltalk. Concise descriptions of inheritance behavior in several object-oriented languages, including Smalltalk, Beta, Simula, and Flavors, are presented in a common framework that facilitates direct comparison of their features.

Syntax Tree (AST), where the DCLs correspond to the productions of the syntax of some programming language. This would be misleading, however, because there is no syntax and there are no productions. The DCL corresponds only to what the programmer had I am indebted to Dr. Hendrik Boom for the term. in mind, it corresponds to an intention. But to understand precisely the distinction, we have to take a few more steps to complete the definition. To make an intention actionable, we associate with the DCL a method which describes the semantics of the intention by specifying the process of transforming the subtree headed by the intention instance into a tree containing only primitive executable nodes with fixed semantics. Now to obtain a runnable program, we need only traverse the intentional tree and apply the transformations indicated by the DCLs pointed to by the nodes, in a process we term "reduction". To distinguish the transforming method from traditional object oriented methods which are to be invoked in run time, the term "extension method" or xmethod will be used. The tree containing only primitive executable nodes will be called "reduced tree" which is written in a fixed language called "R-code". The transformations can be whimsically called "reduction enzymes". The reduced tree is really an intermediate language for interfacing with a machine-specific code generator. The reason that we use trees for this purpose is purely an engineering decision: since reduction enzymes must already operate on trees which are their inputs, it is only natural that their outputs be in the same form also. To be sure, the reduction need not take place in a single step, so the above description is somewhat simplified. A node may be transformed several times until the subtree is comple...

Software reuse is being pursued in an attempt to improve programmer productivity. The concept of reuse is to permit various work products of software development to be used on more than one project in order to amortize their development costs. Productivity is not the only advantage of reuse although it is the most widely publicized. By incorporating reusable components into a new product, the components bring with them whatever qualities they possess, and these can contribute to the quality of the new product. This suggests that reuse might be exploited for achieving quality as an entirely separate goal from improving productivity. If useful properties pertaining to quality could be shown to be present in products as a direct result of software development based on reuse, this might be a costeffective way of achieving those qualities irrespective of the productivity advantages. The adjective certified is sometimes used to describe components that have been tested in some way prior to entry into a library but the term certified is not formally defined in the reuse literature. In this paper, we address the issue of certifying reusable components. We advocate the development of software by reuse with the specific intent of establishing as many of the required properties in the final product as possible by depending upon properties present in the reusable components. For this goal to succeed, a precise definition of certification of reusable components is required and such a definition is presented. The benefits of the definition and the way in which it supports the goal are explored.

This paper presents a method how to represent and build a reusable VHDL component. The representation is based on external functions use. The design procedure is described as transferring of characteristics intrinsic for a given class of domain objects and features from a given VHDL model by re-coding and extending this model with new features. The formal syntax of the functions is given. The component instantiation is performed via pre-processing.

This position paper describes the reuse space in five dimensions which are more or less orthogonal. With this description in mind we discuss when and how to learn reusable components and how to apply them. From this discussion we will conclude an operational environment for reuse. Keywords: description of kinds of reuse, components-based reuse, to learn components, application of components Workshop Goals: getting and giving feedback; networking; Working Groups: reuse process models, reuse education. quotation from Larry Latour, reuse workshop Pittsburgh 1989 Dusink- 1 Background The interest for reuse dates from the time that an Ada program library had to be built by our group. This means that we started from a component-oriented view on reuse. In this view reuse has two sides: the making of reusable components and the reuse of them. Of course, they both influence one another. With these ideas in mind a two-track research was started. One track working on the form and represen...

In this paper, a method is presented for the reuse of software designs and software architectures. A soft-ware design refers to the abstractions and mechanisms that provide the behavior a system or a component re-quires. A software architecture refers to the organiza-tional structure of a software system or a component. According to this method, a software design can be represented in terms of Eztended Data-Flow Graphs (EDFGs) and formal specifications. The graphs and the specifications can be organized into a hierarchical structure, representing different levels of abstraction. Such a structure can be easily understood, modified, reconstructed, aiming at varieties of design targets. 1

Software reuse is advocated primarily as a technique to improve programmer productivity. Reuse permits various artifacts of software development to be used on more than one project in order to amortize their development costs. Productivity is not the only advantage of reuse although it is the most widely publicized. By incorporating reusable parts into a new product, the parts bring with them whatever qualities they possess, and these can contribute to the quality of the new product. This suggests that reuse might be exploited for improving dependability as an entirely separate goal from improving productivity. If useful properties pertaining to dependability could be shown to be present in products as a direct result of software development based on reuse, this might be a costeffective way of achieving those qualities irrespective of the productivity advantages. In this paper, we address the issue of certifying reusable parts and exploiting certification to establish properties of sys...

this paper is organized as a derivation of Intentional Programming (IP) from first principles, it must be obvious to anyone with practical scientific experience that the historical development of IP followed a heuristic, pragmatic and iterative path, and the present logic has been reverse engineered from the results of this development for pedagogical clarity. Indeed, the pedagogical purpose is only enhanced if the pretense were lifted and the list were taken to be a description, as well as a motivation for IP. The "unassailable" items will form the basis for IP and indicate the emphasis; the "doubtful" items will be all delegated back to the users for routine resolution, and the "terrible things" will all find solutions

Product Line Engineering (PLE) is an increasingly important paradigm in software development whereby commonalities and variations among similar systems are systematically identi ed and exploited. PLE covers a large spectrum of activities, from domain analysis to product validation and testing. Variability is manifested throughout this spectrum in artifacts such as requirements, models, code and documentation and it is often of crosscutting nature. These characteristics promote di erent kinds of modularization and composition techniques (e.g., objects, components, aspects, features, subjects, frames, etc.) as suitable candidates to manage variability. Prior work on Generative Programming (GP) and Component Engineering (CE) has shown their successful applicability to PLE and the potential bene ts of modularization and composition techniques. The Workshop on Modularization, Composition, and Generative Techniques for Product Line Engineering (McGPLE) aims at expanding and capitalizing on the increasing interest of researchers from these communities. It builds on the success of the Aspect-oriented Product Line (AOPLE) workshop which has run