In this paper we present a method of code imple-mentation that works in conjunction with collab-oration and responsibility based analysis model-ing techniques to achieve better code reuse and resilience to change. Our approach maintains a closer mapping from responsibilities in the analy-sis model to entities in the implementation. In so doing, it leverages the features of flexible design and design reuse found in collaboration-based de-sign models to provide similar adaptability and reuse in the implementation. Our approach re-quires no special development tools and uses only standard features available in the C++ language. In an earlier paper we described the basic mech-anisms used by our approach and discussed its advantages in comparison to the framework ap-proach. In this paper we show how our approach combines code and design reuse, describing spe-cific techniques that can be used in the develop-ment of larger applications. 1

Requirements such as distribution or tracing have an impact on multiple classes in a system. They are cross-cutting requirements, or aspects. Their support is, by necessity, scattered across those multiple classes. A look at an individual class may also show support for cross-cutting requirements tangled up with the core responsibilities of that class. Scattering and tangling make object-oriented software difficult to understand, extend and reuse. Though design is an important activity within the software lifecycle with well-documented benefits, those benefits are reduced when cross-cutting requirements are present. This paper presents a means to mitigate these problems by separating the design of cross-cutting requirements into composition patterns. Composition patterns require extensions to the UML, and are based on a combination of the subjectoriented model for composing separate, overlapping designs, and UML templates. This paper also demonstrates how composition patterns map to one programming model that provides a solution for separation of cross-cutting requirements in code---aspect-oriented programming. This mapping serves to illustrate that separation of aspects may be maintained throughout the software lifecycle.

Abstract. This paper is about a paradigm shift from the current practice of manually searching for and adapting components and their manual assembly to Generative Programming, which is the automatic selection and assembly of components on demand. First, we argue that the current OO technology does not support reuse and configurability in an effective way. Then we show how a system family approach can aid in defining reusable components. Finally, we describe how to automate the assembly of components based on configuration knowledge. We compare this paradigm shift to the introduction of interchangeable parts and automated assembly lines in the automobile industry. We also illustrate the steps necessary to develop a product line using a simple example of a car product line. We present the feature model of the product line, develop a layered architecture for it, and automate the assembly of the components using a generator. We also discuss some design issues, applicability of the approach, and future development. 1 From Handcrafting to an Automated Assembly Line This paper is about a paradigm shift from the current practice of manually searching for and adapting components and their manual assembly to Generative Programming,

Several authors have identified that the only feasible way to increase productivity in software construction is to reuse existing software. To achieve this, component-based software development is one of the more promising approaches. However, traditional research in component-oriented programming often assumes that components are reused "as-is". Practitioners have found that "as-is" reuse seldomly occurs and that reusable components generally need to be adapted to match the system requirements. Existing component object models provide only limited support for component adaptation, i.e. white-box techniques such as copy-paste and inheritance and black-box approaches such as aggregation and wrapping. These techniques suffer from problems related to reusability, efficiency, implementation overhead or the self problem. To address these problems, this paper proposes superimposition, a novel black-box adaptation technique that allows one to impose predefined, but configurable types ...

In this paper, we investigate whether module concepts for capturing multi-object collaborations can be effectively used to implement crosscutting concerns in reusable, independently developed modules for a-posteriori integration into existing systems. A new kind of collaboration module, called Object Teams, is proposed which combines the best features of existing approaches, further enhances them with concepts for expressing crosscutting relations between independent collaborations, and facilitates a-posteriori integration of such collaborations into existing systems.

There is a well documented problem in the software engineering field relating to a structural mismatch between the specification of requirements for software systems and the specification of object-oriented software systems. The structural mismatch happens because the units of interest during the requirements phase (for example, feature, service, capability, function etc.) are different to the units of interest during object-oriented design and implementation (for example, object, class, method, etc.). The structural mismatch results in support for a single requirement being scattered across the design units and a single design unit supporting multiple requirements -- this in turn results in reduced comprehensibility, traceability and reuse of design models.

It has been recognized in several works that a slice of behavior affecting a set of collaborating classes is a better unit of reuse than a single class. Different techniques and language extensions have been suggested to express such slices in programming languages. We propose delegation layers, an approach that scales the OO mechanisms for single objects, such as delegation, late binding, and subtype polymorphism, to sets of collaborating objects. Technically, delegation layers combine and generalize delegation and virtual class concepts. Due to their runtime semantics, delegation layers are more flexible than previous compile time approaches like mixin layers.

Experience has shown us that object-oriented technology alone is not enough to guarantee that the systems we develop will be flexible and adaptable. Even "welldesigned " object-oriented software may be difficult to understand and adapt to new requirements. We propose a conceptual framework that will help yield more flexible object-oriented systems by encouraging explicit separation of computational and compositional elements. We distinguish between components that adhere to an architectural style, scripts that specify compositions, and glue that may be needed to adapt components' interfaces and contracts. We also discuss a prototype of an experimental composition language called PICCOLA that attempts to combine proven ideas from scripting languages, coordination models and languages, glue techniques, and architectural specification. 1 Introduction The last decade has shown that object-oriented technology alone is not enough to cope with the rapidly changing requirements of ...

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.

Modeling object-oriented applications using collaborations and roles is now well accepted. Collaboration-based or role-based designs decompose an application into tasks performed by a subset of the applications' classes. Collaborations provide a larger unit of understanding and reuse than classes, and are an important aid in the maintenance and evolution of the software. This kind of design information is lost, however, at the implementation level, making it hard to maintain and evolve an existing software application. The extraction of collaborations from code is therefore an important issue in design recovery. In this paper we propose an iterative approach which uses dynamic information to support the recovery and understanding of collaborations. We describe a tool we have developed to support our approach and demonstrate its use on a case study.