Program

The concept of software composition dates back to the introduction of the notion of software modularization. This talk will first give a brief overview of various behavioral composition mechanisms such as function invocation, delegation, inheritance, reflection and meta-object protocols, and aspect-orientation. Secondly, the talk will outline various design dimensions of composition such as static vs. dynamic, symmetric vs. asymmetric, local vs. systemic, black-box vs. white-box, general-purpose vs. domain-specific, and explicit vs. oblivious composition. Further, the talk will focus on message interception-based composition mechanisms with a special emphasis on composition-filters. Along this line, various new research results will be illustrated in providing language independence, and semantic interference detection and avoidance. Finally, the talk will end by presenting our new research results in specifying and automatically measuring and verifying the composibility characteristics of software.

The design of programming languages is, in general, geared towards accumulation rather than composition of features. However, by adding an everincreasing number of built-in abstractions, any programming language is eventually at risk to reach a critical mass at which it may become increasingly difficult for designers to maintain and for developers to use an evolving language appropriately. To tackle this language design paradox, we have developed GLOO, a small open-ended dynamic language, whose design philosophy aims at a unified approach in which program and language evolution result directly from the definition of extensible domain sub-languages. Surprisingly, these extensible domain sub-languages not only provide a framework to capture domain expertise, but also give rise to a powerful compositional model for language extension. To demonstrate the effectiveness of this approach, we develop the Language of Namespaces and Traits in this paper. We define this extensible domain sub-language as an aggregate of various forms of object-oriented language support. Using the Language of Namespaces and Traits as example, we show that GLOO’s extension model plays a crucial role in achieving a flexible compositional approach for the design of readily-available and extensible programming abstractions.

The effective management and composition of architectural variabilities has long been of importance to product line architects. Ar- chitects need to describe how conceptual variabilities are composed and realised through architectural decompositions of a product line. Archi- tecture variabilities need to be described in terms of the chosen design de- compositions, which do not often correspond naturally to feature model decompositions. Also, the fine-grained nature of certain architectural variabilities makes it di±cult to represent them in a modular fashion, and describe how they are composed across different views. In order to address these issues, this paper presents a variability modelling lan- guage (VML), which supports first-class representation of heterogeneous forms of architectural variabilities. The language complements existing architectural modelling approaches for product lines by providing mech- anisms to: (i) explicitly reference variation points in multiple architec- tural views, and (ii) support compositions involving both fine-grained and coarse-grained variabilities in an orthogonal fashion. The complete- ness and simplicity of VML is assessed through four case studies from different domains.

Superimposition is a composition technique that has been applied successfully in several areas of software development. In order to unify several languages and tools that rely on superimposition, we present an underlying language-independent model that is based on feature structure trees (FSTs). Furthermore, we offer a tool, called FSTComposer, that composes software components represented by FSTs. Currently, the tool supports the composition of components written in Java, Jak, XML, and plain text. Three nontrivial case studies demonstrate the practicality of our approach.

The Business Process Execution Language (BPEL) is now a de facto standard for specifying and executing business process for web service composition and orchestration. As more and more web services are composed using BPEL, tuning these compositions and gain better performance becomes increasingly important. This paper presents our approach for optimizing the BPEL process and introduces OptBPEL, a tool for performance optimization of BPEL process. The approach starts from the optimization of synchronization structure concerning link in BPEL. After that, some concurrency analysis techniques are applied to obtain further performance improvement. Finally, we give some experiments and prove the efficiency of these optimization algorithms used in OptBPEL.

Flexibility can significantly impact performance. Some component-based frameworks come with a near to zero overhead but provide only build-time configurability. Other solutions provide a high degree of flexibility but with an uncontrollable and a possibly unacceptable impact on performance. We believe that no flexible systems give programmers a means to control the inherent overhead introduced by flexibility. This prevents from reaching acceptable tradeoffs between performance and flexibility, according to the applications needs or hardware targets. This paper presents an ongoing work that aims to redesign the existing Think component framework. Once revisited, the framework makes possible to finely adjust the flexibility to the actually desired needs and thus better control the induced performance overhead. A categorization of the dimensions of flexibility is also introduced in order to articulate our proposition.

We present an approach that generates context-aware, optimized libraries of algorithms and data structures. The search space contains all combinations of implementation variants of algorithms and data structures including dynamically switching and converting between them. Based on profiling, the best implementation for a certain context is precomputed at deployment time and selected at runtime. In our experiments, the profile-guided composition outperforms the individual variants in almost all cases.

Autonomic computing is one of the most promising techniques for managing the complexity of modern software applications. It fosters the idea of systems able to autonomously detect anomalies and react accordingly. Supervision and actual business logic are intertwined and work together to supply the autonomic features. The paper presents our ongoing work on loose compositions for autonomic systems and introduces the first ideas of a framework based on Java, aspect oriented programming, and rules. The paper also sketches a first prototype implementation, based on the DIET agent framework.

Self-adaptive component-based architectures provide methods and mechanisms to support the dynamic adaptation of their structure under evolving execution context. Dynamic adaptation is particularly relevant in the domain of ubiquitous computing, which is subject to numerous unexpected changes of the execution context. In this paper, we focus on changes in the service provider landscape: business services may dynamically come and go, and their quality of service may vary. We introduce an extension of the MADAM component-based planning framework that optimizes the overall utility of applications when such changes occur. MADAM planning is based on dynamic configuration of component frameworks. The extended planning framework supports seamless configuration of component frameworks based on both local and remote components and services. In particular, components and services can be plugged in interchangeably to provide functionalities defined by the component framework. The extended planning framework is illustrated and validated on a use case scenario.

Extensible Component Platforms support the discovery, installation, starting, uninstallation of components at runtime. Since they are often targeted at mobile resource-constrained devices, they have both strong performance and security requirements. The current security model for Java systems – Permissions – is based on call stack analysis. This is very time-consuming, which makes it difficult to use in production environments. We therefore define the Component-Based Access Control (CBAC) Security Model, which emulates Java Permissions through static analysis at the installation phase of the components. CBAC is based on a fully declarative approach that makes it possible to tag arbitrary methods as sensitive. A formal model is defined to guarantee that a given component have sufficient access rights, and that dependencies between components are taken into account. A first implementation of the model is provided for the OSGi Platform, using the ASM library for code analysis. Performance tests show that the cost of CBAC at install time is negligible, since it is executed together with digital signature verification which is much more costly. Moreover, unlike Java Permissions, the CBAC security model does not have any runtime overhead.

Many companies use business process management systems (BPMS) for modeling and execution support of their business processes. Many processes are highly dynamic and require changes even during execution. Common commercial BPMS fail to support such processes appropriately since they work in a rather static manner, i.e. they demand that the structure of a process is fixed before execution. Our research group cooperates with an industry partner who uses a static BPMS. This paper describes an approach that posteriorly extends this static BPMS inasmuch as dynamic changes of processes during execution are supported. The benefit of this approach is that our partner in industry gains support of dynamic processes but still use the existing BPMS and save investments related to it.

The use of XML as a format for message exchange makes Web services well suited for composition of heterogeneous components. However, since clients must manage differences in message schemas between services, interoperability is still a significant problem. Interoperability currently can be supported through the use of transformations provided by a Web service intermediary. However, intermediary technologies do not provide a way for clients to reason about the composition of services and intermediaries. We propose an approach to provide clients with an interface composed of schema information from a Web service and an intermediary. Composition is performed by applying rewriting rules, defined by the intermediary, to the server interface schema. This new interface takes into account what transformations are available at an intermediary. The advantage of the approach is that clients can continue to benefit from code generation and static type-checking offered by interface definition languages such as WSDL; while still making use of the flexibility offered by intermediary transformations. We provide the algorithmic details of composition, including a proof of correctness and an upper bound on complexity. We demonstrate the approach in the context of a Web service composition of three publicly available Web services.

One fundamental issue in service-oriented computing concerns the question whether services can be composed in a manner that allows them to achieve their individual goals. In this paper we use a variant of interface automata as an abstraction of the input/output behaviour of services, which are themselves represented as terms in the pi-calculus extended with an action for expressing service collaboration. In this setting, the question whether two or more services can meaningfully compose is then reduced to checking a simple property of the product automaton of the involved interfaces.

The Kmelia abstract component model is extended to allow the description of component compositions with multipart interactions leading to simultaneous communications between more than two services. Shared services are defined to explicitly control multipart interactions. Accordingly the communication actions of Kmelia are extended. The for- mal definitions of the Kmelia model, the composition of components via their services and their analysis are revisited to integrate the extension of the model. An example illustrates the need and the usage of shared services.

Producing interactive applications is a multidisciplinary software composition activity. This, and the nature of user interface code, puts particular requirements on component composition frameworks. We describe a component model that relies on a hierarchical tree of heterogeneous elements communicating through events and data flows. This model allows to assemble, reuse and apply late binding techniques to components as diverse as data management, algorithms, interaction widgets, graphical objects, or speech recognition rules at all levels of granularity. We describe implementations of the model and example uses. Finally, we outline research directions for making the model more complete and compatible with mainstream software models.

Data-centric business applications comprise an important class of distributed systems that includes on-line stores, document management systems, and patient portals. However, their complexity makes it difficult to design and implement them. We address these issues from a model-driven perspective by developing a formal, compositional, and domain-specic set of abstractions for the specication and analysis of data-centric business applications. Our technique allows us to formally analyze the specied system at design time; in particular we can analyze whether the system is resilient to abnormal conditions, i.e. that key system invariants can always be re-established.

Wireless sensor network (WSN) applications are often characterised by close coupling between their software and hardware components, which may result in ad-hoc, platform-specific software, together with the loss of portability and evolvability. We introduce a fractal composition-based approach for constructing and dynamically reconfiguring WSN applications. The approach uses pi-calculus semantics to unify the models of interaction for both software and hardware components, on both local and remote nodes. Applications are constructed by forming compositions of interacting components, and can be decomposed and reconfigured into different topologies. The advantages of the approach are that it reduces the complexity of WSN programming; results in portable and evolvable software; and allows changes to be managed during execution without having to take the system off-line. We present an outline of the approach, and illustrate it with an example specified in the Insense language.

Dynamic Aspect Oriented Programming (AOP) technologies typically provide coarse-grained mechanisms for adapting aspects that cross-cut a system deployment; i.e. whole aspect modules can be added and removed at runtime. However, in this paper we demonstrate that adaptation of the finer-grained elements of individual aspect modules is required in highly dynamic systems and applications. We present AspectOpenCOM, a principled, reflection-based component framework that provides a meta object protocol capable of fine-grained adaptation of deployed aspects. We then evaluate this solution by eliciting a set of requirements for dynamic fine-grained adaptation from a series of case studies, and illustrate how the framework successfully meets these crite- ria. We also investigate the performance gains of fine-grained adaptation versus a coarse-grained approach.

In this paper we present an approach towards safe software composition based on aspect-orientation. Aspects enable the systematic addition of code into existing programs but often they also introduce errors. In order to provide safe aspects for software composition we address the verification of the aspect-oriented language paradigm. We construct a basic calculus for aspects with types and prove formally type safety. More precisely, this paper presents the following contributions (a) a fully formalized type system for the Theory of Objects including the proof of type safety, (b) a theory of aspects based on the Theory of Objects including a type system for aspects, and (c) the definition of a notion of type safety for aspects including its proof. The entire theory and proofs are carried out in the theorem prover Isabelle/HOL.

The composition of separate concerns is a cornerstone for the construction of complex software. By now, aspect-oriented techniques have been established as the sine qua non in several application areas. However, their abilities to cope with composition conflicts are mostly limited to the linear ordering of aspects. This paper describes a more general and practical approach for the resolution of composition conflicts as it is realised in our general-purpose transformation system LLTS. Our system divides a composition into two phases. In the expansion phase separate transformations add concern code within their isolated copies of the base code. In the subsequent contraction phase the manipulations of the first phase are compared and merged wherever possible. A hinting mechanism guides the semi-automatic merging on three levels: Conflicts are detected using compatibility relations between operators, by reconciling annotations of complex transformation tasks, and based on semantic predicates of the base code language. Conflicts are reported to the user with a comprehensive explanation and can be resolved with manual by-case deviations from the original transformation code. As a result, conflicts can be remedied on a finer granularity, e.g., by revising only parts of a transformation in a certain context.