To be an effective platform for performance-sensitive real-time and embedded applications, off-the-shelf CORBA middleware must preserve the communication-layer quality of service (QoS) properties of applications end-to-end. However, the standard CORBA GIOP/IIOP interoperability protocols are not well suited for applications that cannot tolerate the message footprint size, latency, and jitter associated with general-purpose messaging and transport protocols. It is essential, therefore, to develop standard pluggable protocols frameworks that allow custom messaging and transport protocols to be configured flexibly and used transparently by applications. This paper provides three contributions to research on pluggable protocols frameworks for performance-sensitive distributed object computing (DOC) middleware. First, we outline the key design challenges faced by pluggable protocols developers. Second, we describe how we resolved these challenges by developing a pluggable protocols framewo...

Ubiquitous computing promotes physical spaces with hundreds of specialized embedded devices that increase our productivity, alleviate some specific everyday tasks and provide new ways of interacting with the computational environment. Personal computers lose the focus of attention due to the fact that the computational environment is spread across the physical space. Therefore, the users ’ view of the computational environment is finally extended beyond the physical limits of the computer. Physical spaces become computer systems, or in other terms, Active Spaces. However, these Active Spaces require novel system software capable of seamlessly coordinating their hidden complexity. Our goal is to extend the model provided by current computer systems to allow interaction with physical spaces and their contained entities (physical and virtual) by means of a single abstraction called Active Space. 1.

Aspect-orientation can help to separate concerns in software. One of the goals of this separation is to promote flexibility and configurability; this is especially true when constructing program families (and product-lines). This paper introduces a set of principles that instruct in the creation of flexible, configurable, aspect-oriented systems. We illustrate the principles through their application to a software product-line. The principle of dependency alignment serves as a guideline for structuring concern implementation in modules, eliminating unwarranted dependencies between concerns. The principles of orthogonal and weakly orthogonal aspects instruct in the design of aspects that are included in some system configurations, but not in others. We show how these principles scale to larger systems and larger concern implementations.

Although existing CORBA specifications, such as Real-time CORBA and CORBA Messaging, address many end-to-end quality-of-service (QoS) aspects, they do not define strategies for configuring these QoS aspects into applications. Therefore, application developers must make these configuration decisions manually and explicitly, which is tedious, error-prone, and often sub-optimal. Although the recently adopted CORBA Component Model (CCM) does define a standard configuration framework for packaging and deploying software components, conventional CCM implementations focus on functionality rather than quality-of-service, which makes them unsuitable for applications with stringent QoS requirements. This paper presents three contributions to the study of reflective middleware for QoS-enabled component-based applications. It outlines strategies for (1) selecting optimal communication mechanisms reflectively, (2) re-factoring QoS aspects from components into their containers to adaptively respond to changing QoS requirements and conditions, and (3) dynamically loading/unloading and activating/deactivating component implementations. Based on our ongoing research on CORBA and the CORBA Component Model, we believe the application of reflective techniques to component middleware will provide an dynamically adaptive and (re)configurable environment for COTS software that meets the stringent QoS demands of next-generation applications. 1

Although existing CORBA specifications, such as Real-time CORBA and CORBA Messaging, address many end-to-end quality-of-service (QoS) properties, they do not define strategies for configuring these properties into applications flexibly, transparently, and adaptively. Therefore, application developers must make these configuration decisions manually and explicitly, which is tedious, error-prone, and often suboptimal. Although the recently adopted CORBA Component Model (CCM) does define a standard configuration framework for packaging and deploying software components, conventional CCM implementations focus on functionality rather than adaptive quality-of-service, which makes them unsuitable for next-generation applications with demanding QoS requirements. This paper presents three contributions to the study of middleware for QoS-enabled component-based applications. It outlines reflective middleware techniques designed to adaptively (1) select optimal communication mechanisms, (2) manage QoS properties of CORBA components in their containers, and (3) (re)configure selected component executors dynamically. Based on our ongoing research on CORBA and the CCM, we believe the application of reflective techniques to component middleware will provide a dynamically adaptive and (re)configurable framework for COTS software that is well-suited for the QoS demands of next-generation applications. 1

With the recent adoption of the CORBA component model (CCM), application programmers now have a standard way to implement, manage, configure, and deploy components that implement and integrate CORBA services. The CCM standard not only enables greater software reuse for servers, it also provides greater flexibility for dynamic configuration of CORBA applications. Thus, CCM appears to be well-suited for general-purpose client/server applications. Due to the complexity of the standard and relative immaturity of implementations, however, CCM is not yet appropriate for mission-critical applications with high-performance and real-time quality-of-server (QoS) requirements. Therefore, we have begun a project to identify, prototype, benchmark, optimize, and deploy the key patterns and framework components necessary to mature the CCM standard so it can be applied successfully to mission-critical applications with stringent QoS requirements. There are two contributions of our research project. ...

In open distributed real-time and embedded (DRE) systems, different ORB endsystems may use different scheduling disciplines. To ensure appropriate end-to-end application behavior in an open architecture, DRE systems must enforce an ordering on activities originating in an endsystem and activities that migrate there, based on the relative importance of these activities. This paper describes the meta-programming techniques applied in Juno, which extends Real-time CORBA to enhance the openness of DRE systems with respect to their scheduling disciplines by enabling dynamic ordering of priority equivalence classes. We use the forthcoming OMG Real-Time CORBA 2.0: Dynamic

Architecture description languages (ADLs) can be used for describing architectures of component-based software systems. Typical ADLs provide explicit support for specifying components, connectors and configurations as well as for building hierarchical system configurations. All of them allow to specify structural dependencies among components, thus describing static configurations. This may be sufficient for an initial system composition, but does not provide enough information for post-deployment and runtime reconfiguration. Only a few ADLs provide some support for dynamics, usually without a clear differentiation between a possible behaviour of component descriptions and a runtime behaviour of component instances. Even XML-based ADLs such as xADL 2.0, which clearly distinguishes between the design-time and run-time, only defines structural instance schemata. In our approach, we observe the ”use ” dependencies among instances of components (called ”live components”) of an already deployed and running system. The life components are constrained by specified structural dependencies (defined in ”component descriptions”). Live components are hosted in containers. The ”Service-Connector-Container ” view of our model provides a way to describe the runtime behaviour of a system. Thus, it supports dynamic reconfiguration of component-based software systems. We use ”service effect automata ” for runtime behaviour specification and intend to extend them using the timing and liveness concepts of ”live sequence charts”. Topics from CFP dynamic composition of component-based systems, dynamic architectures, architecture description languages suitable to guide COP, system design for hot-swappable components, addressing variability requirements in component-based solutions 1

Ubiquitous computing promotes physical spaces with hundreds of specialized embedded devices that increase our productivity, alleviate some specific everyday tasks and provide new ways of interacting with the computational environment. Personal computers lose the focus of attention due to the fact that the computational environment is spread across the physical space. Therefore, the users' view of the computational environment is finally extended beyond the physical limits of the computer. Physical spaces become computer systems, or in other terms, Active Spaces. However, these Active Spaces require novel system software capable of seamlessly coordinating their hidden complexity. Our goal is to extend the model provided by current computer systems to allow interaction with physical spaces and their contained entities (physical and virtual) by means of a single abstraction called Active Space. 1. Introduction Ubiquitous computing promotes the proliferation of embedded devices specializ...

Commercial off-the-shelf (COTS) middleware increasingly offers not only functional support for standard interfaces, but also the ability to optimize their resource consumption patterns. For example, a COTS real-time object request broker (ORB) may permit users to configure its server-side thread pooling policies. On one hand, this flexibility makes it possible to use standard functional interfaces in applications where they were not applicable previously. On the other hand, the nonstandard nature of the optimization mechanisms -- i.e., the "knobs and dials" -- acts against the very product-independence that standardized COTS interfaces are intended to provide. This paper provides two contributions to the study of mechanisms for reducing the life-cycle costs of distributed real-time and embedded (DRE) systems. First, we present a mechanism--called a Quality Connector--that enables applications to specify the qualities of service that they require from their infrastructure, and then manages the operations that optimize the middleware to implement those requirements. Second, we show how Quality Connectors are being applied in practice to allocate communication resources automatically for real-time CORBA event propagation. Although middleware that configures itself in response to quality of service (QoS) requests has been investigated and applied in general-purpose computing contexts, we believe that the present work is among the first to put such capabilities into mission-critical DRE systems with stringent QoS requirements. 1