Aswin van den Berg

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.

Joinpoint inference from behavioral specification to implementation

Aspect-Oriented Programming languages allow pointcut descriptors to quantify over the implementation points of a system. Such pointcuts are problematic with respect to independent development because they introduce strong mutual coupling between base modules and aspects. This paper introduces a new joinpoint selection mechanism based on state machine specifications. Module interfaces include behavioral specifications defined as protocol state machines. These specifications are not defined with respect to potential aspects, but are used to model and simulate the architecture of a system and act as behavioral contracts between the modules of the system. We show how a smart joinpoint selection mechanism is able to infer points that might be located deep inside the implementation of a module, given pointcuts that are expressed entirely in terms of behavioral specification elements. We present a tool, the Motorola WEAVR, which implements this technique in a Model-Driven Engineering environment.

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.

Experiences in deploying model-driven engineering

In this paper, we describe how Motorola has deployed model-driven engineering in product development, in particular for the development of highly reliable telecommunications systems, and outline the benefits obtained. Model-driven engineering has dramatically increased both the quality and the reliability of software developed in our organization, as well as the productivity of our software engineers. Our experience demonstrates that model-driven engineering significantly improves the development process for telecommunications systems. We discuss the elements we found most important for deployment of model-driven engineering in a large product development organization: An appropriate modeling language, a powerful domain-specific code generator, and a deployment support team.

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.

Automated semantic analysis of design models

Based on several years of experience in generating code from large SDL and UML models in the telecommunications domain, it has become apparent that model analysis must be used to augment more traditional validation and testing techniques. While model correctness is extremely important, the difficulty of use and non-scalability of most formal verification techniques when applied to large-scale design models renders them insufficient for most applications. We have also repeatedly seen that even the most complete test coverage fails to find many problems. In contrast, sophisticated model analysis techniques can be applied without human interaction to large-scale models. A discussion of the model analysis techniques and the model defects that they can detect is provided, along with some real-world examples of defects that have been caught.

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.