Component-based systems are mostly composed out of existing artifacts. Missing pieces are newly developed. Interoperability between the existing artifacts is usually not given. The newly

Recently, component models have received much attention from the Software Engineering research community. The goal of each of these models is to increase reuse and to simplify the implementation and composition of new software. While all these models focus on the speci cation and packaging of components, however, they provide almost no support for their adaptation and composition. This work still has to be done programmatically. In this paper we present Type Based Adaptation, a novel adaptation technique that uses the type information available about a component. We also describe the design and implementation of our reference implementation thereby verifying the feasibility of this approach.

An event-based distributed application is a group of software components interacting with each other by producing events that in turn trigger the invocation of procedures. In this work, we are concerned with the technology and methods for integrating an event-based application, whether that application is being constructed from scratch or synthesized from existing systems. Developing an event-based application is a complex task for programmers, who must address several issues not found in traditional systems and, currently, must do so without much assistance. These issues include event declaration, structure, binding, and naming. Our objective is to provide the same software engineering benefits to programmers of event-based applications as are currently provided to programmers of applications using traditional RPC or messagepassing mechanisms. In this work, we broaden the technology for integration to encompass event-based programming. A method is described for separating event intera...

Component models have received much attention recently both from the software engineering research community and from industry. This is apparent through the sheer number of component models that have been developed in the last few years. The goal of each of these models is to increase reuse and to simplify the implementation and composition of new software. All these models focus on the specication and packaging of components but provide almost no support for the adaptation and easy composition of components. If components have not been written with each other in mind, their composition still has to be carried out programmatically. Since one of the advantages of software components is independent development, they will rarely be entirely compatible with each other.

Existing black-box adaptation techniques are insufficiently powerful for a large class of real-world tasks. Meanwhile, white-box techniques are language-specific and overly invasive. We argue for the inclusion of specialpurpose adaptation features in a configuration language, and outline the benefits of targetting binary representations of software. We introduce Cake, a configuration language with adaptation features, and show how its design is being shaped by two case studies. 1.

The REBOUND adaptation framework organizes a collection of adaptation tactics in a way that they can be selected based on the components available for adaptation. Adaptation tactics are specified formally in terms of the relationship between the component to be adapted and the resulting adapted component. The tactic specifications are used as matching conditions for specification-based component retrieval, creating a ``retrieval for adaptation' ' scenario. The results of specification matching are used to guide component adaptation. Several examples illustrate how the framework guides component and tactic selection and how basic tactics are composed to form more powerful tactics.

Because protocol software is difficult and expensive to implement and test, it is often ported between systems, instead of being rewritten from scratch. Unfortunately, porting protocol software can be nearly as difficult as from-scratch development, due to inherent differences in subsystem design and services provided. Thus, protocol subsystems can have a profound effect on the portability of a protocol implementation. In this paper, we propose an approach permitting the incorporation of new protocols into a subsystem other than their "native" one, without the drawbacks or expense of porting and original development. Our approach is based on protocol module encapsulation, which allows unmodified protocol code developed for one protocol subsystem to be used within another. We relate our experiences designing, implementing, and measuring the performance of our protocol encapsulation modules, using an AppleTalk protocol stack as a baseline. College of Computing Georgia Institute of Techno...

This paper summarises the work of a University of Mancshester / ICL collaborative project, which is charged with "introducing evolutionary enhancements to ICL's development environment to benefit productivity and time to market". This applies in particular to the tools used to develop and support VME, ICL's mainframe operating system, though it is our intention to make the work as general as possible. We describe the use of the Eiffel object-oriented programming language as an interface to an existing database system, a design repository. We give a brief overview of the history of the system to explain the reasons for adopting the new technology, and discuss the expected benefits. We present the reasons why we chose Eiffel as the vehicle rather than any other language or a proprietary solution. We discuss the benefits of holding implementation level information as nodes in a network database instead of as discrete files, and show how the system will be evolved to support multiple imple...

Software designers compose systems from components written in some programming language. They regularly describe systems using abstract patterns and sophisticated relations among components. However, the configuration tools at their disposal restrict them to composition mechanisms directly supported by the programming language. To remedy this lack of expressiveness, we must elevate the relations among components to first-class entities of the system, entitled to their own specifications and abstractions. Keywords: software architecture, system configuration idioms, software design Presented at Workshop on Studies of Software Design, May 1993. Also to be published in Proceedings of Workshop on Studies of Software Design, Lecture Notes in Computer Science, Springer-Verlag 1994. 1 This research was supported by the Carnegie Mellon University School of Computer Science and Software Engineering Institute (which is sponsored by the U.S. Department of Defense) and by a grant from ...

The reusability of available multimedia and middleware services brings new challenges for enabling flexible and efficient development and deployment of distributed end-to-end multimedia applications with specific Quality-of-Service(QoS) in ubiquitous environments. The main challenges in reusing available components include understanding and utilizing of domain-specific components and middlewares with various semantics, and enabling their QoS-aware interoperability in ubiquitous environments that resource fluctuations, device and service changes are a common phenomenon. This paper presents a QoS-aware meta-data compiler framework that provides a solution for the challenges. The framework extends standard component construction and composition with QoS-related meta-data. It defines a set of QoS-aware models and meta-data translation models that are essential for modelling QoS consistency. The framework also enables QoS-aware semantics and interfaces for interoperability among connected components forming a QoS-aware multimedia application. Besides the defined models, the framework introduces an architecture that integrates the models with a set of high-level specifications, a meta-data compiler protocol, and a run-time support to form a programming environment,