Method Proxy-Based AOP in Scala

@article{Spiewak2009MethodPA,
  title={Method Proxy-Based AOP in Scala},
  author={Daniel Spiewak and Tian Zhao},
  journal={J. Object Technol.},
  year={2009},
  volume={8},
  pages={149-169}
}
This paper describes a fully-functional Aspect-Oriented Programming framework in Scala ‐ a statically typed programming language with object-oriented and functional features. This framework is implemented as internal domain-specific languages with syntax that is both intuitive and expressive. The implementation also enforces some static type safety in aspect definitions. 

Figures from this paper

MorphScala: safe class morphing with macros
The goal of this paper is to design an easy type-safe metaprogramming API for Scala to capture generative metaprogramming tasks that depend on existing definitions to generate others, by writing
Integrating legacy systems with MDE
TLDR
This paper explores how models, aspects and generative techniques can be used in conjunction to alleviate the implementation of multiple wrappers in OO languages such as Java.

References

SHOWING 1-10 OF 22 REFERENCES
An Overview of the Scala Programming Language
TLDR
This paper gives an overview of the Scala language for readers who are familar with programming methods and programming language design.
An Overview of the Scala Programming Language (2. Edition)
TLDR
This paper gives an overview of the Scala language for readers who are familar with programming methods and programming language design.
Using pointcut delta analysis to support evolution of aspect-oriented software
TLDR
A delta analysis is introduced to lighten the problems of evolution of aspect oriented software by allowing encapsulation of cross-cutting concerns.
Aspect-oriented programming and modular reasoning
  • G. Kiczales, M. Mezini
  • Computer Science
    Proceedings. 27th International Conference on Software Engineering, 2005. ICSE 2005.
  • 2005
TLDR
Using aspect- oriented programming enables modular reasoning in the presence of crosscutting concerns, and using aspect-oriented programming enables modules in the absence of such concerns.
Evolving an embedded domain-specific language in Java
TLDR
The experience of evolving a domain-specific language embedded in Java over several generations of a test framework is described, showing how the framework changed from a library of classes to an embedded language.
DSL implementation using staging and monads
TLDR
Two new programming language mechanisms, program staging and monadic abstraction, are introduced that provide the expressive power that allows the construction of many compiler components as reusable libraries, and provide the structure necessary to reason about the implementation.
A Machine Model for Aspect-Oriented Programming
TLDR
This paper introduces a lightweight, objectbased machine model for aspect-oriented languages based on objectoriented ones that is centered around delegation and relies on a very dynamic notion of join points as loci of late-bound dispatch of functionality.
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.
Principles and Design Rationale of Composition Filters
TLDR
This chapter aims at explaining the principles of composition filters, in particular its aspect-oriented composition capabilities, and to provide insight into the motivations and design rationale decisions behind the composition filters model.
A Model-driven Pointcut Language for More Robust Pointcuts
TLDR
Improved modularity and separation of concerns do not only intend to aid initial development, but are conceived such that developers can better manage software complexity, evolution and reuse, which can seriously hamper the evolvability of the software.
...
...