Thomas Cottenier

Aspect Composition in the Motorola Aspect-Oriented Modeling Weaver.

One of the fundamental issues in Aspect-Oriented approaches is aspect-to-aspect interference, which occurs when multiple aspects are deployed jointly such that different composition orders may give rise to various inconsistency problems. This paper describes how aspect precedence can be specified explicitly at the modeling level in order to derive a correct composition order and therefore reduce the aspect interference problem in Aspect-Oriented Modeling (AOM). The paper presents a modeling approach to achieve aspect reuse by introducing three distinct categories of aspect composition mechanisms. These composition concepts have been implemented in the Motorola WEAVR, which is an AOM weaver developed at Motorola as a plug-in component for Telelogic TAU G2.

Modeling aspect-oriented compositions

Crosscutting concerns are pervasive in embedded software, because of the various constraints imposed by the environment and the stringent QoS requirements on the system. This paper presents a framework for modularizing crosscutting concerns in embedded and distributed software, and automating their composition at the modeling level, for simulation and validation purposes. The proposed approach does not extend the semantics of the UML in order to represent aspects. Rather, it dedicates a metamodel to the representation of the composition semantics between aspects and core models. The paper illustrates this approach by presenting a model weaver for SDL statecharts developed at Motorola Labs. Crosscutting behavior is designed with plain SDL statecharts and encapsulated into modules called aspect beans. The weaver looks at the aspect beans and the core SDL statecharts from a perspective that is defined by lightweight extensions to the SDL and UML metamodels. A connector metamodel defines the structure of the aspect-to-core binding definition. Finally, a weaver behavioral metamodel defines composition primitives for specifying weaving strategies.

An executable choreography framework for dynamic service-oriented architectures

Interoperability and loose coupling requirements are pushing the next generation of distributed applications towards more decentralized and more dynamic interaction schemes, which the classic request/response communication paradigm can hardly accommodate. Hence, sound foundations and mechanisms for the establishment of unanticipated peer-to-peer interactions across organizational boundaries are of significant importance to upcoming middleware platforms. The executable choreography framework (ECF) is a middleware-level framework that targets dynamic and decentralized service compositions. The ECF combines transparent context propagation with aspect-oriented software composition techniques to dynamically refine the default control and data flow of service invocations. The framework provides a ground for experimentation with dynamic and distributed workflows, and a base to assess their safety and applicability when deployed across organizational boundaries

Management of feature interactions with transactional regions

This paper presents a modeling language to modularize the features of a system using orthogonal regions and to man-age the interactions between these features. Orthogonal regions are a language construct to structure a state ma-chine into a set of semi-independent behaviors. We intro-duce two concepts to manage the interactions between regions. First, we present a notion of interface between re-gions which captures the essence of their interactions. Second, we introduce a transactional composition operator to synchronize the regions and check the interaction for non-determinism and termination. The approach is eva-luated by comparing a monolithic legacy implementation of a telecommunication component to two refactored implementations. Our results show that transactional region composition can achieves independence between the im-plementations of the features of the system and that it improves the cohesion of the regions, compared to classic regions.

Report of the 14th international workshop on aspect-oriented modeling

This report summarizes the outcome of the 14th Workshop on Aspect-Oriented Modeling (AOM), as part of the 12th International Conference on Model Driven Engineering Languages and Systems – MoDELS 2009 – in Denver, Colorado, USA, on the 4th of October 2009. The workshop brought together researchers and practitioners from two communities: aspect-oriented software development (AOSD) and software model engineering. This paper gives an overview of the accepted submissions, and summarizes the results of the discussion.

Separation of concerns with transactional regions

Orthogonal regions allow a system represented as a state machine to be decomposed into a set of semi-independent modules. Regions of a state machine are usually not completely independent and interact through synchronization and communication primitives, causing coupling between the regions. As the number of regions in the system grows, these interactions become harder to maintain and the behavior of the system as a whole becomes harder to reason about. We introduce a transactional composition semantics, which overcomes these scalability limitations by implicitly and non-invasively capturing dependencies between regions. The approach is evaluated by comparing a monolithic legacy implementation of a telecommunication component to an implementation based on transactional region composition. Our results show that region-based modularization can achieve complete separation of concerns between the features of a non-trivial system and that the proposed transactional composition semantics enable region-based decomposition to be performed on a large scale.

Modular reasoning about region composition

Region composition is an operation where transitions of different automaton are woven together according to synchronization constraints. Reasoning about properties across regions is difficult, which is problematic in systems that are assembled by composing a large number of regions. We introduce two transactions constructs to enforce causality properties between transitions of a state machine. We show that transactions can be checked statically and that they support modular reasoning about region composition by preserving liveness properties within the scope of a transaction.

Architecture composition for concurrent systems

We present a framework to assemble concurrent applications from modules that capture reusable architectural pat-terns. The framework focuses on concurrent systems where computational processes communicate through asynchronous messages. The language provides support to modularize architectural patterns at different levels of granularity, using agents, regions, aspects and morphing. We present sample implementations of the architectural patterns and show how they are composed using a real-world example. Finally discuss how the deployment and composition of patterns can be further automated.