Translucid Contracts for Aspect-oriented Interfaces

By: Mehdi Bagherzadeh, Hridesh Rajan, and Gary T. Leavens

Abstract

There is some consensus in the aspect-oriented community that a notion of interface between joinpoints and advice may be necessary for improved modularity of aspect-oriented programs, for modular reasoning, and for overcoming pointcut fragility. Different approaches for adding such interfaces, such as aspect-aware interfaces, pointcut interfaces, crosscutting interfaces, explicit joinpoints, quantified typed events, open modules, and joinpoint types decouple aspects and base code, enhancing modularity. However, existing work has not shown how one can write specifications for such interfaces that will actually allow modular reasoning when aspects and base code evolve independently, and that are capable of specifying control effects, such as when advice does not proceed. The main contribution of this work is a specification technique that allows programmers to write modular specification of such interfaces and that allows one to understand such control effects. We show that such specifications allow typical interaction patterns, and interesting control effects to be understood and enforced. We illustrate our techniques via an extension of Ptolemy, but we also show that our ideas can be applied in a straightforward manner to other notions of joinpoint interfaces, e.g. the crosscutting interfaces (XPIs).

ACM Reference

Bagherzadeh, M. et al. 2010. Translucid Contracts for Aspect-oriented Interfaces. FOAL ’10: Workshop on Foundations of Aspect-Oriented Languages workshop (Mar. 2010).

BibTeX Reference

@inproceedings{bagherzadeh2010translucid,
  author = {Mehdi Bagherzadeh and Hridesh Rajan and Gary T. Leavens},
  title = {Translucid Contracts for Aspect-oriented Interfaces},
  booktitle = {FOAL '10: Workshop on Foundations of Aspect-Oriented Languages workshop},
  location = {Rennes and St. Malo, France},
  month = {March},
  year = {2010},
  entrysubtype = {workshop},
  abstract = {
    There is some consensus in the aspect-oriented community that a notion of
    interface between joinpoints and advice may be necessary for improved
    modularity of aspect-oriented programs, for modular reasoning, and for
    overcoming pointcut fragility. Different approaches for adding such
    interfaces, such as aspect-aware interfaces, pointcut interfaces, crosscutting
    interfaces, explicit joinpoints, quantified typed events, open modules, and
    joinpoint types decouple aspects and base code, enhancing modularity. However,
    existing work has not shown how one can write specifications for such
    interfaces that will actually allow modular reasoning when aspects and base
    code evolve independently, and that are capable of specifying control effects,
    such as when advice does not proceed. The main contribution of this work is a
    specification technique that allows programmers to write modular specification
    of such interfaces and that allows one to understand such control effects. We
    show that such specifications allow typical interaction patterns, and
    interesting control effects to be understood and enforced. We illustrate our
    techniques via an extension of Ptolemy, but we also show that our ideas can be
    applied in a straightforward manner to other notions of joinpoint interfaces,
    e.g. the crosscutting interfaces (XPIs).
  }
}