Steven Op de beeck

Domain-driven discovery of stable abstractions for pointcut interfaces

The benefits of defining explicit pointcut interfaces in aspect-oriented applications have been advocated by many. A pointcut interface exposes a set of crosscutting abstract behaviours (as named pointcut signatures) that multiple aspects in the application can use. In accordance with the dependency inversion and stable dependencies principles, a pointcut interface should expose only stable abstractions in order to maximally promote its reuse across a family of applications. In this paper, we propose a domain-driven architecture method for designing such stable pointcut interfaces. The method employs systematic reengineering of use case models to discover stable abstractions that are anchored in the domain model of the application. During architecture design, these stable domain abstractions are mapped to pointcut interfaces. As part of this mapping activity, the architecture is constrained to ensure that the pointcut interfaces can be implemented correctly. We have applied this method in two applications, where we validate that pointcut interfaces can be reused for implementing the composition logic of different aspects without requiring modification to their pointcut signatures. Moreover, the method consistently yields pointcut interface hierarchies.

Towards managing variability in the safety design of an automotive hall effect sensor

This paper discusses the merits and challenges of adopting software product line engineering (SPLE) as the main development process for an automotive Hall Effect sensor. This versatile component is integrated into a number of automotive applications with varying safety requirements (e.g., windshield wipers and brake pedals). This paper provides a detailed explanation as to why the process of safety assessment and verification of the Hall Effect sensor is currently cumbersome and repetitive: it must be repeated entirely for every automotive application in which the sensor is to be used. In addition, no support is given to the engineer to select and configure the appropriate safety solutions and to explain the safety implications of his decisions. To address these problems, we present a tailored SPLE-based approach that combines model-driven development with advanced model composition techniques for applying and reasoning about specific safety solutions. In addition, we provide insights about how this approach can reduce the overall complexity, improve reusability, and facilitate safety assessment of the Hall Effect sensor.

Building a Digital Publishing Platform Using AOSD

This paper presents the results of applying aspect-oriented methods and techniques during the construction of a demonstrator of an industry-grade digital publishing platform. In a rapidly evolving publishing landscape, publishing companies will have a competitive advantage in the long run if their supporting software infrastructure can sustain evolution. In this paper, we show how a component-based software architecture is refactored using AOSD techniques, and how this leads to an improved variability and evolvability of the publishing infrastructure by enabling invasive features to be introduced easily and dynamically. Finally, we provide an in-depth analysis of our main experiences and lessons learned during development of this demonstrator, in terms of three of the industrial acceptance criteria of a programming paradigm: its expressivity, its efficiency, and compatibility. The strength of this demonstrator lies in the fact that it presents a realistic, and high-effort case study, which is the result of collaboration with real-world industrial actors in the news publishing field.

Multi-view refinement of AO-connectors in distributed software systems

This paper presents MView, a technique that enables the separation of various developer stakeholder views on an architectural connector in distributed software systems. While state-of-the-art AO-ADLs focus on describing compositions using aspect-based connectors, there is no support for describing a connector across multiple architectural views. This is, however, essential for distributed systems, where run-time and distribution characteristics are not represented in a single view. The result is connectors that suffer from monolithic descriptions, where the views of different stakeholders are tangled. MView untangles these stakeholder views by defining them in separate modules and specifying refinement relations between these modules. We have integrated MView in a prototypical ADL, which allows code generation for multiple AO-middleware platforms. We evaluate MView in terms of stakeholder effort in a content distribution system for e-Media. We have created an Eclipse-plugin that supports the ADL, and performs code generation to the JBoss and Spring middleware platforms.

A domain-specific middleware layer using AOSD: next-generation digital news publishing

In this demonstrator we illustrate the design and development of a domain-specific middleware layer for supporting a publishing infrastructure. The design of the middleware layer is based on an aspect-oriented architecture which has been iteratively defined by applying state-of-the-art aspect-oriented methods. The demonstrator shows the implementation and deployment of the middleware layers on top of JBoss, using the JBoss AOP framework.

Modularity and variability of distributed software architectures through multi-view refinement of AO-Connectors

This paper presents MView, a technique that enables the separation of various architect views on an architectural connector in distributed software systems. A distributed system faces a lot of variability in the functions that it needs to support, and the deployment environments in which it needs to execute. Modularity of functionality and composition is essential in achieving this variability. While state-of-the-art AO-ADLs focus on describing compositions using aspect-based connectors, there is no support for describing a connector across multiple architecture views. This is, however, essential for distributed systems, where run-time and distribution characteristics are represented in multiple views. This results in connectors that suffer from monolithic descriptions, in which the views of different architects are tangled. MView untangles these architect views by defining them in separate modules and specifying refinement relations between these modules. We have integrated MView in an ADL, called MView ADL, which is supported by an Eclipse-plugin that performs code generation to the JBoss and Spring middleware platforms. We evaluate MView in a content distribution system for e-Media. First is an assessment of the architect effort required for creating variations of that system, followed by an evaluation of the extent to which changes ripple through the architecture.