. The aim of component technology is the replacement of large monolithic applications with sets of smaller software components, whose particular functionality and interoperation can be adapted to users' needs. However, the adaptation mechanisms of component software are still limited. Most proposals concentrate on adaptations that can be achieved either at compile time or at link time. Current support for dynamic component adaptation, i.e. unanticipated, incremental modifications of a component system at run-time, is not sufficient. This paper proposes object-based inheritance (also known as delegation) as a complement to purely forwarding-based object composition. It presents a typesafe integration of delegation into a class-based object model and shows how it overcomes the problems faced by forwarding-based component interaction, how it supports independent extensibility of components and unanticipated, dynamic component adaptation. 1 Introduction Component-oriented pro...

Abstract. This paper studies specific language level abstractions for component-based programming. We propose a simple model which captures some basic ingredients — like explicit context dependence, dynamic binding and subtype polymorphism, late (dynamic) composition, and avoidance of inheritance in favor of object composition — that several authors have defended to be central to black-box object-oriented component programming styles. The model is expressed by a core imperative typed calculus, in which components are first-class entities, and whose basic constructs enable the composition, scripting, instantiation and definition of atomic components. Some motivating programming examples are presented, and the operational semantics is shown to enjoy a typesafety property. We also discuss an extension to the Java language aimed at supporting the proposed model, and some implementation issues. 1

consistent fashion. Another reason arises from the initial motivation of component-oriented programming, incrementality: the new component should not duplicate functionality of the old one. Thus there must be some way for the new component to "inherit" all unmodified behaviour but substitute its own behaviour where appropriate. In traditional, statically typed, class-based object models, where component interaction at run-time is solely based on message sending, this is impossible to achieve without compromising reuse ([1]). An interesting alternative is the concept known as delegation ([5]). An object, called the child, may have references to other objects, called its parents. Messages for which the message receiver has no matching method are automatically forwarded to its parents after binding their implicit self parameter to the message receiver. Thus, all subsequent messages to self will be addressed to the message receiver, allowing it to substitute its own behaviour for par

In this work we describe the foundations of a type system for software components, which supports (1) error checking during composition, (2) automatic adaption of a component's services according to the resources of its surrounding environment, and (3) controlled extension of components by plug-ins. Since the type information is described at the interface of a component, this type system can also be regarded as an new notion for to enhance classical interfaces. This document gives a speci cation of a component type and describes algorithms performing the above actions (1) { (3). Contents 1 Introduction 1 1.1 Component-based Software Engineering . . . . . . . . . . . . . . 1 1.2 Problems of Current Technology . . . . . . . . . . . . . . . . . . 2 1.3 Requirements to an Type System . . . . . . . . . . . . . . . . . . 4 1.4 Overview: Types and their Bene ts . . . . . . . . . . . . . . . . . 4 2 Types for Software Components 6 2.1 Enhanced Finite Automata . . . . . . . . . . . . . . . . ...

Current approaches to component-oriented programming are based on traditional object-oriented languages and concepts. However, most existing object-oriented languages fail to address subtle interface compatibility issues that become paramount in a component-based setting. We explore both syntactic and semantic interface incompatibilities and discuss why they are difficult to handle. We argue that resolving these incompatibilities requires breaking with a fundamental idiom of object-oriented languages: the subordination of messages to interfaces and classes. We propose a solution based on the concept of stand-alone messages as found in the experimental programming language Lagoona and discuss its ramifications.

Component-oriented development of software supports the adaptability and maintainability of large systems, in particular if requirements change over time and parts of a system have to be modified or replaced. The software architecture in such systems can be described by components and their composition. In order to describe larger architectures, the composition concept becomes crucial. We will present a formal framework for component composition for object-based software development. The deployment of modal logics for defining components and component composition will allow us to reason about and prove properties of components and compositions. 1

. Over the past few years, the notion of building software from components has become popular again. The goal is to produce systems by adapting and linking off-the-shelf modules from a pool of interchangeable components. To turn this idea into reality, the formal descriptions of software components need to specify more than the type signatures of their exported services. At a minimum, they should contain assertions about critical properties of a component's behavior. By monitoring such behavioral contracts at run-time, language implementations can pinpoint faulty components, and programmers can replace them with different ones. In this paper, we study the notion of behavioral contracts in an object-oriented setting. While the use of behavioral contracts is well-understood in the world of procedural languages, their addition to object-oriented programming languages poses remarkably subtle problems. All existing contract enforcement tools for Java fail to catch flaws in contract...

Component-oriented programming promises to finally make the vision of pervasive software components a reality. In the area of dependable real-time systems, the benefits of increased reuse, reliability, and efficiency make component-oriented programming especially attractive. As part of the Lagoona project, we are investigating how component-oriented programming can be supported at the level of programming languages. Recently, we have also become interested in supporting the construction of real-time systems within the Lagoona framework, and we have started exploring the language design space for this domain. We outline the design of the experimental programming language Lagoona and discuss two of its novel features in more detail. We also discuss the difficulties we see for integrating the ideas of component-oriented programming with the requirements of real-time systems. It is our hope that feedback from the workshop will enable us to more clearly define a research agenda in this area.

Component software construction has been a very intensively researched branch of the nowadays software engineering discipline because it seems to be the best answer to the increasing demands on complexity, reliability, maintainability and configurability of software systems which is due to its ability to integrate all these otherwise contradictory requirements. Therefore, a lot of component frameworks have emerged recently, often as results of theoretical studies in this field. SOFA/DCUP component model that has been founded and developed by the Distributed Systems Research Group at Charles University in Prague belongs to one of the most promising ones. This thesis contributes to this project by analyzing the assets of incorporating inheritance into each of three main abstractions of the SOFA's component specification language CDL, analyzing various inheritance mechanisms how they suit needs of each of those three abstractions and proposing and elaborating the particular inheritance mechanisms that suit best. Also, some other issues concerning SOFA/DCUP, inheritance, programming languages and component software have been discussed in this work.

Open distributed systems we are going to conceive in the future will present challenging design and operating requirements demands. Integrating dynamically autonomous distributed modules, allowing module reuse, coping with specific user requirements, such as QoS, are going to be common tasks a designer will have to face. In this context, it is convenient to make available suitable models to design such systems and provide flexibility to handle dynamic requirements.