Abstract. We are concerned with the design of programming languages that support the paradigm of component-oriented programming. Languages based on the accepted idea of combining modular and objectoriented concepts fail to provide adequate support. We argue that messages should be separated from methods to address this shortcoming. We introduce the concept of stand-alone messages, give examples for its utility, and compare it to related approaches and language constructs. Besides leading to interesting insights on the interaction of modular and object-oriented concepts, we believe that stand-alone messages also provide a useful basis for further research on component-oriented programming languages. 1

The essence of component-oriented programming is a new understanding of extensibility in which the development and integration of extensions is a distributed activity, not a centralized one as in previous software development paradigms. Component-oriented programming languages must therefore be designed to have certain basic properties that support rather than impede the distributed extensibility of software systems. We discuss a number of existing language mechanisms in this regard and provide examples from Lagoona, an experimental component-oriented programming language we are developing.

Current object-oriented development practice is centered around application frameworks. In this paper, we argue that this approach is misleading, as it distracts from the ultimate goal of composing software out of "software components" originating from different sources. In particular, we suggest a model of software composition that is based on passing of "first-class messages" rather than on inheritance. In most object-oriented programming languages, messages and the methods that get executed in response to receiving them are only "second class citizens". In these languages, one can send a message to an object, but one cannot further manipulate the message itself as a data object. As a consequence, many of the operations that a naive observer might expect to be available are in fact not usually offered. Examples of such missing operations are the ability to store arriving messages in a data structure and execute them asynchronously later, perhaps in a different order, or the capabili...

The paradigm of component-oriented programming, which promises to improve upon object-oriented techniques in significant ways, is currently still difficult to apply in practice. One problem impeding further progress is that established strongly-checked, class-based, objectoriented languages do not take the requirements of component-oriented programming into account. The concepts of stand-alone messages and generic message forwarding, which have been developed in the programming language Lagoona, lead to language designs that suit the new paradigm better while still preserving an object-oriented programming style. We illustrate the utility of these concepts by analyzing several archetypal design and implementation problems and solving them in a coherent language framework. We also discuss how these concepts can be implemented efficiently and propose a suitable execution model based on high-level intermediate representations and dynamic recompilation.

Traditional, statically composed software can be globally optimized for execution speed at compile-time. For dynamically composed component software, a different execution model has to be employed to achieve comparable performance. As components are developed and compiled separately, little is known at compile-time about the environment they will be used in later. The global information required to aggressively optimize the overall system is only available after the deployment phase. In this paper, we discuss how dynamic recompilation can be employed to provide an efficient execution model for dynamically composed software.

Aspect-oriented programming (AOP) and implementation of system software are fairly complex tasks on their own. Combining these two severe challenges seems to be not very inviting to operating system and system software builders. To make AOP more appealing to the system software community, we limit the sometimes pervasive nature of AOP by applying lessons learned from component-oriented programming to make AOP more manageable and easier to verify. The result is AspectLagoona, a featherweight aspect language with very simple semantics and easily understandable and well specified aspect and component code interaction.

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 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.

Java has multiple inheritance of interfaces, but only single inheritance of code via classes. This situation results in duplicated code in Java library classes and application code. We describe a generalization to the Java language syntax and the Java Virtual Machine (JVM) to support multiple inheritance of code, called MCI-Java. Our approach places multiply-inherited code in a new language construct called an implementation, which lies between an interface and a class in the inheritance hierarchy. MCI-Java does not support multiply-inherited data, which can cause modeling and performance problems. The MCI-Java extension is implemented by making minimal changes to the Java syntax, small changes to a compiler (IBM Jikes), and modest localized changes to a JVM (SUN JDK 1.2.2). The JVM changes result in no measurable performance overhead in real applications. 1

In this paper we present a model that supports a clean separation between the concepts of interface, implementation, and representation. We present several problems that are difficult to solve in the absence of such separation and describe how the proposed model can be used to provide a solution. We also describe the principles that can be used to implement the proposed model in an existing object-oriented database management system. 1 Introduction In the past two decades, object-oriented technology has been extensively used in design and development of database management systems. This technology has been introduced to meet the challenging requirements posed by current applications. One of the major advantages of object-oriented software technology is its strong support for code reuse. While code reuse is important in application programs, it is even more important in database programming. Data stored in many databases far outlives the application programs originally written to pro...