Effective Aspects: A Typed Monadic Embedding of Pointcuts and Advice

International audienceAspect-oriented programming(AOP) aims to enhance modularity and reusability in software systems by offering an abstraction mechanism to deal with crosscutting concerns. However, in most general-purpose aspect languages aspects have almost unrestricted power, eventually conflicting with these goals. In this work we present Effective Aspects: a novel approach to embed the point- cut/advice model of AOP in a statically-typed functional programming language like Haskell. Our work extends EffectiveAdvice, by Oliveira, Schrijvers and Cook; which lacks quantification, and explores how to exploit the monadic setting in the full pointcut/advice model. Type soundness is guaranteed by exploiting the underlying type system, in particular phantom types and a new anti-unification type class. Aspects are first-class, can be deployed dynamically, and the pointcut language is extensible, therefore combining the flexibility of dynamically-typed aspect languages with the guarantees of a static type system. Monads enables us to directly reason about computational effects both in aspects and base programs using traditional monadic techniques. Using this we extend Aldrich's notion of Open Modules with effects, and also with protected pointcut interfaces to external advising. These restrictions are enforced statically using the type system. Also, we adapt the techniques of EffectiveAdvice to reason about and enforce control flow properties. Moreover, we show how to control effect interference us- ing the parametricity-based approach of EffectiveAdvice. However this approach falls short when dealing with interference between multiple aspects. We propose a different approach using monad views, a recently developed technique for han- dling the monad stack. Finally, we exploit the properties of our monadic weaver to enable the modular construction of new semantics for aspect scoping and weaving. These semantics also benefit fully from the monadic reasoning mechanisms present in the language. This work brings type-based reasoning about effects for the first time in the pointcut/advice model, in a framework that is both expressive and extensible; thus allowing development of robust aspect-oriented systems as well as being a useful research tool for experimenting with new aspect semantics

Towards an aspect weaving BPEL engine

This position paper proposes the use of dynamic aspects and the visitor design pattern to obtain a highly configurable and extensible BPEL engine. Using these two techniques, the core of this infrastructural software can be customised to meet new requirements and add features such as debugging, execution monitoring, or changing to another Web Service selection policy. Additionally, it can easily be extended to cope with customer-specific BPEL extensions. We propose the use of dynamic aspects not only on the engine itself but also on the workflow in order to tackle the problems of Web Service hot deployment and hot fixes to long running processes. In this way, composing aWeb Service "on-the-fly" means weaving its choreography interface into the workflow

Translucid contracts: Expressive specification and modular verification of aspect oriented interfaces

As aspect-oriented (AO) programming techniques become more widely used, their use in critical systems such as aircraft and telephone networks, will become more widespread. However, careful reasoning about AO code seems difficult because: (1) advice may apply in too many places, and (2) standard specification techniques do not limit the control effects of advice. Commonly used black box specification techniques cannot easily specify control effects, such as advice that does not proceed to the advised code. In this work we avoid the first problem by using Ptolemy, a language with explicit event announcement. To solve the second problem we give a simple and understandable specification technique, translucid contracts, that not only allows programmers to write modular specifications for advice and advised code, but also allows them to reason about the code\u27s control effects. We show that translucid contracts support sound modular verification of typical interaction patterns used in AO code. We also show that translucid contracts allow interesting control effects to be specified and enforced

Design, Semantics and Implementation of the Ptolemy Programming Language: A Language with Quantified Typed Events

Implicit invocation (II) and aspect-oriented (AO) languages provide software designers with related but distinct mechanisms and strategies for decomposing programs into modules and composing modules into systems. II languages have explicitly announced events that run registered observer methods. AO languages have implicitly announced events that run method-like but more powerful advice. A limitation of II languages is their inability to refer to a large set of events succinctly. They also lack the expressive power of AO advice. Limitations of AO languages include potentially fragile dependence on syntactic structure that may hurt maintainability, and limits on the available set of implicit events and the reflective contextual information available. Quantified, typed events, as implemented in our language Ptolemy, solve all these problems. This paper describes Ptolemy and explores its advantages relative to both II and AO languages

Disciplined Reuse of Aspects (State of the Art & Work Plan)

This document describes the work plan and state of the art for the PhD work of André Restivo started in 2006. Acceptance of this document by a steering committee is mandatory for the final registration in the Doctoral Programme in Informatics Engineering (ProDEI) at the Engineering Faculty of University of Porto

FOAL 2002 Proceedings: Foundations of Aspect-Oriented Langauges Workshop at AOSD 2002

Aspect-oriented programming is a new area in software engineering and programming languages that promises better support for separation of concerns. The first Foundations of Aspect-Oriented Languages (FOAL) workshop was held at the 1st International Conference on Aspect-Oriented Software Development in Enschede, The Netherlands, on April 22, 2002. This workshop was designed to be a forum for research in formal foundations of aspect-oriented programming languages. The call for papers announced the areas of interest for FOAL as including, but not limited to: formal semantics, formal specification, verification, theory of testing, aspect management, theory of aspect composition, and aspect translation and rewriting. The call for papers welcomed all theoretical and foundational studies of this topic. The goals of this FOAL workshop were to: • Explore the formal foundations of aspect-oriented programming. • Exchange ideas about semantics and formal methods for aspect-oriented programming languages. • Foster interest in the programming language theory communities concerning aspects and aspect- oriented programming languages. • Foster interest in the formal methods community concerning aspects and aspect-oriented programming. In addition, we hoped that the workshop would produce an outline of collaborative research topics and a list of areas for further exploration. The papers at the workshop, which are included in the proceedings, were selected from papers submitted by researchers worldwide. Due to time limitations at the workshop, not all of the submitted papers were selected for presentation

An Extension Interface Concept for Multilayered Applications

Extensibility is an important feature of modern software applications. In the context of business applications it is one of the major selection criteria from the customer perspective. Software extensions enable developers to integrate new features to a software system for supporting new requirements. However, there are many open challenges concerning the software provider and the extension developer. A software provider must provide extension interfaces that define the software artifacts of the base application that are allowed to be extended, where and when the extension code will run, and what resources of the base application an extension is allowed to access. While concepts for such interfaces are still a challenging research topic for ``traditional'' software constructed using a single programming language, they are completely missing for complex systems consisting of several abstraction layers. In addition, state-of-the-art approaches do not support providing different extension interfaces for different stakeholders. To develop an extension for a certain software system, the extension developer has to understand what extension possibilities exist, which software artifacts provide these possibilities, the constraints and dependencies between the extensible software artifacts, and how to correctly implement an extension. For example, a simple user interface extension in a business application can require a developer to consider extensible artifacts from underlying business processes, database tables, and business objects. In commercial applications, extension developers can depend on classical means like application programming interfaces, frameworks, documentation, tutorials, and example code provided by the software provider to understand the extension possibilities and how to successfully implement, deploy, and run an extension. For complex multilayered applications, relying on such classical means can be very hard and time-consuming for the extension developers. In integrated development environments, various program comprehension tools and approaches have helped developers in carrying out development tasks. However, most of the tools focus on the code level, lack the support for multilayered applications, and do not particularly focus on extensibility. In this dissertation I aim to provide better means for defining, implementing, and consuming extension interfaces for multilayered applications. I claim that explicit extension interfaces are required for multilayered applications and they are needed for simplifying the implementation (i.e., the concrete realization) and maintainability of extension interfaces on the side of the software provider as well as the consumption of these interfaces by the extension developers. To support this thesis, I first analyze problems with extension interfaces from the perspectives of both the software provider through an example business application and an analysis of a corpus of software systems. I then analyze the problems with the consumption of extension interfaces (i.e., extension development) through a user study involving extension developers performing extension development tasks for a complex business application. Next, I present XPoints, an approach and a language for the specification of extension possibilities for multilayered applications. I develop an instantiation of XPoints evaluate it against current state-of-the-art works and its usability through a user study. I finally show how XPoints can be applied to simplify the extension development through the implementation of a recommender system for extension possibilities for multilayered applications. The advantages of the recommender system are illustrated through an example as well through a comparison between the current state-of-the-art tools for program comprehension. Topics like extension validation, monitoring, and conflict detection are left for future work