A typed monadic embedding of aspects

@inproceedings{Tabareau2013ATM,
  title={A typed monadic embedding of aspects},
  author={Nicolas Tabareau and Ismael Figueroa and {\'E}ric Tanter},
  booktitle={AOSD},
  year={2013}
}
We describe a novel approach to embed pointcut/advice aspects in a typed functional programming language like Haskell. Aspects are first-class, can be deployed dynamically, and the pointcut language is extensible. Type soundness is guaranteed by exploiting the underlying type system, in particular phantom types and a new anti-unification type class. The use of monads brings type-based reasoning about effects for the first time in the pointcut/advice setting, thereby practically combining Open… 

Figures from this paper

Effective Aspects: A Typed Monadic Embedding of Pointcuts and Advice

TLDR
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.

Effective aspects : A typed monadic model to control and reason about aspect interference. (Effective aspects : Un modèle monadique et typé pour contrôler l'interférence entre aspects)

TLDR
This work brings type-based reasoning about effects for the first time in the pointcut/advice model of AOP in a framework that is expressive, extensible and well-suited for development of robust aspect-oriented systems as well as a research tool for new aspect semantics.

A TYPED MONADIC MODEL TO CONTROL AND REASON ABOUT ASPECT INTERFERENCE TESIS PARA OPTAR AL GRADO DE DOCTOR EN CIENCIAS, MENCION COMPUTACIÓN EN COTUTELA CON LA ÉCOLE DES MINES DE NANTES

TLDR
This work presents EffectiveAspects: a novel approach to embed the pointcut/advice model of AOP in a statically-typed functional programming language like Haskell, and proves a general equivalence theorem that is based on a few conditions that can be established, reused, and adapted separately as the system evolves.

Taming aspects

TLDR
A number of approaches to tame aspects in order to retain their benefits without sacrificing important software engineering properties, like modular reasoning, separate development, type soundness, and controlled interferences are looked at.

Chemical foundations of distributed aspects

TLDR
The aspect join calculus is proposed, an aspect-oriented and distributed variant of the join calculus that addresses crosscutting and provides a formal foundation for distributed AOP, and a minimal aspectjoin calculus is developed that allows aspects to advise chemical reactions.

Taming aspects with monads and membranes

TLDR
This paper combines a monadic embedding of the pointcut/advice model in Haskell with the notion of membranes for aspect-oriented programming to control aspect interference by construction by relying on the type system.

Compositional reasoning about aspect interference

TLDR
This work addresses the issue of reasoning about interference with effectful aspects in the presence of unrestricted quantification through pointcuts and establishes a general equivalence theorem that is based on a few conditions that can be established, reused, and adapted separately as the system evolves.

Compositional Reasoning About Aspect Interference (Full version with proofs)

TLDR
This work addresses the issue of reasoning about interference with effectful aspects in the presence of unrestricted quantification through pointcuts and establishes a general equivalence theorem that is based on a few conditions that can be established, reused, and adapted separately as the system evolves.

Transactions on Aspect-Oriented Software Development XI

TLDR
SAGA is introduced, a general framework that provides a smooth integration of the specification and the run-time checking of both data and protocoloriented properties of Java classes and interfaces and is evaluated by conducting an industrial case study from an eCommerce software company Fredhopper.

References

SHOWING 1-10 OF 34 REFERENCES

StrongAspectJ: flexible and safe pointcut/advice bindings

TLDR
This paper presents a formal definition of the proposed constructs and typing rules, and develops proofs for their type safety properties, and provides a prototype implementation as a plugin for the AspectBench Compiler.

Aspect-oriented programming with type classes

TLDR
The results show that type-directed static weaving is closely related to type class resolution -- the process of typing and translating type class programs.

AspectML: A polymorphic aspect-oriented functional programming language

TLDR
AspectML allows programmers to define type-safe polymorphic advice using pointcuts constructed from a collection of polymorphic join points, and comes equipped with a type inference algorithm that conservatively extends Hindley--Milner type inference.

Expressive scoping of dynamically-deployed aspects

TLDR
This work proposes deployment strategies for parameterized dynamic aspect deployment, which gives full control over the propagation of the aspect on the call stack and within created objects or functions, and permits a deployment-specific refinement of its pointcuts.

An Overview of AspectJ

TLDR
AspectJ provides support for modular implementation of a range of crosscutting concerns, and simple extensions to existing Java development environments make it possible to browse the crosscutting structure of aspects in the same kind of way as one browses the inheritance structure of classes.

Aspectual Caml: an aspect-oriented functional language

TLDR
The design and implementation issues of those AOP mechanisms that give insights into the interaction between AOP features and common features in strongly-typed functional languages such as type inference, polymorphic types and curried functions are described.

On the relation of aspects and monads

TLDR
The aim of this paper is to contrast both mechanisms w.r.t. their capabilities and their effects on modularity, by looking at monads as a way to express tangling concerns in functional programming and by analyzing the extent to which aspects are able to handle those concerns.

A semantics for advice and dynamic join points in aspect-oriented programming

TLDR
This work gives a denotational semantics for a minilanguage that embodies the key features of dynamic join points, pointcuts, and advice and is intended as a baseline semantics against which future correctness results may be measured.

Type Classes with Functional Dependencies

TLDR
The kind of problems that can occur with multiple parameter type classes are illustrated, and how they can be resolved by allowing programmers to specify explicit dependencies between the parameters are explained.

Open Modules: Modular Reasoning About Advice

TLDR
A new, simple formal model for advice as it appears in languages like AspectJ is studied, which yields insights into the nature of modularity in the presence of advice, provides a mechanism for enforceable contracts between component providers and clients in this setting, and suggests improvements to current AOP IDEs.