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.

A technique for representing programs abstractly and independently of the eventual target architecture is presented that yields a file representation twice as compact as machine code for a CISC processor. It forms the basis of an implementation, in which the process of code generation is deferred until the time of loading. At that point, native code is created on_the_fly by a code_generating loader. The process of loading with dynamic code_generation is so fast that it requires little more time than the input of equivalent native code from a disk storage medium. This is predominantly due to the compactness of the abstract program representation, which allows to counterbalance the ad...

Abstract not found

Frameworks are an object-oriented reuse technique that are widely used in industry but not discussed much by the software engineering research community. They are a way of reusing design that is part of the reason that some object-oriented developers are so productive. This paper compares and contrasts frameworks with other reuse techniques, and describes how to use them, how to evaluate them, and how to develop them. It describe the tradeoffs involved in using frameworks, including the costs and pitfalls, and when frameworks are appropriate.

Introduction Object-oriented programming techniques promote a new approach to software engineering in which reliable, open applications can be largely constructed, rather than programmed, by reusing "frameworks" [3] of plug-compatible software components. Although the dream of a components-based software industry is very old [9], only now does it appear that we are close to realizing the dream. The reason for this is twofold: . Modern applications are increasingly open in terms of topology, platform and evolution, and so the need for a component-oriented approach to development is even more acute than in the past; . Objects provide an organizational paradigm for decomposing large applications into cooperating objects as well as a reuse paradigm for composing applications from pre-packaged software components. Despite the contributions of object-oriented technology, there are several open research problems that must be resolved t

Component-based software development has proven effective for systems implementation in well-understood application domains, but is still insufficient for the creation of reusable and changeable software architectures. Design patterns address these shortcomings by capturing the expertise that is necessary for reusable design solutions. However, there is so far no methodical approach to providing these conceptual design building blocks in a tangible and composable form. To address this limitation, we introduce the notion of design components, reified design patterns fit for software composition. In this paper, we define design components and explain their constituents and services. Furthermore, we detail the activities of design composition and illustrate them as a process within a four-dimensional design space. Moreover, we describe a prototype of a design composition environment. A case study helps illustrating our approach.

Abstract. We present the design and implementation of the type system for Ptolemy II, which is a tool for component-based heterogeneous modeling and design. This type system combines static typing with run-time type checking. It supports polymorphic typing of components, and allows automatic lossless type conversion at run-time. To achieve this, we use a lattice to model the lossless type conversion relation among types, and use inequalities defined over the type lattice to specify type constraints in components and across components. The system of inequalities can be solved efficiently, with existence and uniqueness of a solution guaranteed by fixed-point theorems. This type system increases the safety and flexibility of the design environment, promotes component reuse, and helps simplify component development and optimization. The infrastructure we have built is generic in that it is not bound to one particular type lattice. The type system can be extended in two ways: by adding more types to the lattice, or by using different lattices to model different system properties. Higher-order function types and extended types can be accommodated in this way. 1

Abstract not found

Object-oriented programming is considered in the context of software communities -- groups of designers and developers sharing knowledge and experience. One way of fostering reuse of this experience is by establishing large collections of reusable object classes. Resulting problems include: ClasspacsOX6/ andcAO7 organization -- how can classes and their methods be represented to simplify reuse. Classselec7X' and exploration -- what query and browsing facilities are needed by developers in order to facilitate software reuse. Class evolution -- how may the class hierarchy be reorganized as a result of changes introduced by developers. These issues are illustrated by examining prototype tools and systems intended to aid object-oriented programming.

Xax is a browser plugin model that enables developers to leverage existing tools, libraries, and entire programs to deliver feature-rich applications on the web. Xax employs a novel combination of mechanisms that collectively provide security, OS-independence, performance, and support for legacy code. These mechanisms include memory-isolated native code execution behind a narrow syscall interface, an abstraction layer that provides a consistent binary interface across operating systems, system services via hooks to existing browser mechanisms, and lightweight modifications to existing tool chains and code bases. We demonstrate a variety of applications and libraries from existing code bases, in several languages, produced with various tool chains, running in multiple browsers on multiple operating systems. With roughly two person-weeks of effort, we ported 3.3 million lines of code to Xax, including a PDF viewer, a Python interpreter, a speech synthesizer, and an OpenGL pipeline. 1