• Corpus ID: 1335828

Aspect-Oriented Programming is Quantification and Obliviousness

  title={Aspect-Oriented Programming is Quantification and Obliviousness},
  author={Robert E. Filman and Daniel P. Friedman},
This paper proposes that the distinguishing characteristic of Aspect-Oriented Programming (AOP) systems is that they allow programming by making quantified programmatic assertions over programs written by programmers oblivious to such assertions. Thus, AOP systems can be analyzed with respect to three critical dimensions: the kinds of quantifications allowed, the nature of the actions that can be asserted, and the mechanism for combining base-level actions with asserted actions. Consequences of… 

Balancing Quantification and Obliviousness in the Design of Aspect-Oriented Frameworks

This paper presents a model for modularizing the crosscutting references found in aspect-oriented frameworks, and an extension to AspectJ is presented that utilizes Java annotations to implement polymorphic advice method parameters.

Aspect-Oriented Programming Reloaded

A new AOP programming model is proposed that enables both crosscutting modularity and modular reasoning, and is implemented by AspectJML, a general-purpose aspect-oriented extension to Java.

Source-Code Instrumentation and Quantification of Events

It is argued that all quantification is over dynamic events, and preliminary work in developing a system that maps dynamic events to transformations over source code is described.

What does aspect-oriented programming mean for functional programmers?

The goal of this paper is to debate the possible causes of the functional programming community's resistance and to raise awareness and interest by showcasing the benefits that could be gained from having a functional AOP language.

Coupling Aspect-Oriented and Adaptive Programming

This chapter compares AOP and AP and discusses their integration, and shows the benefits of the integration are: better support for ubiquitous traversal-related concerns and betterSupport for shy aspect-oriented programming.

Unifying aspect- and object-oriented program design

It is shown that aspects as a separate abstraction mechanism are not essential to aspect-oriented programming, and instead a new construct, quantified binding, similar to the event-handler binding in the implicit invocation style, is at the core of aspect- oriented programming.

Language-independent aspect-oriented programming

The term aspect-oriented programming (AOP) has come to describe the set of programming mechanisms developed specifically to express crosscutting concerns, which are composed, or woven, with traditionally encapsulated functionality referred to as components.

Mostly modular compilation of crosscutting concerns by contextual predicate dispatch

A simple language providing AOP mechanisms, which are enhanced traditional OOP mechanisms are proposed, which show that programs in this language can be only mostly modularly typechecked and compiled.

Type-Based Quantification of Aspect-Oriented Programs

An approach and a language design for quantification based on type hierarchies that is to superimpose a crosscutting type hierarchy over the object-oriented inheritance hierarchy and reveals that typebased quantification improves the robustness of the advising code against base code changes.

The paradoxical success of aspect-oriented programming

The author of this essay finds that much of aspect-oriented programming's success seems to be based on the conception that it improves both modularity and the structure of code, while in fact, it works against the primary purposes of the two, namely independent development and understandability of programs.



Solving the modeling problems of object-oriented languages by composing multiple aspects using composition filters

This paper first illustrates some practical problems of the conventional objectoriented languages and then introduces Composition-Filters solutions to overcome these problems.

Transformation in intentional programming

This paper describes a system that implements intentional programming, focusing on the facilities for program transformation, with emphasis on specifying that order in a compositional fashion, so that transformations are easily re-used.

The implementation of procedurally reflective languages

This work shows how to produce an efficient implementation of a procedurally reflective language, based on the notion of a level-shifting processor, and illustrates in a complete implementation for a particular reflective LISP dialect called 3-LISP.

Object-oriented programming with flavors

The philosophy and some of the major characteristics of Symbolics' newly redesigned object-oriented programming system, Flavors, are described and how the above goals are addressed are shown.

Subject-oriented programming: a critique of pure objects

This paper explores this shift to a style of objectoriented technology that emphasizes the subjective views: Subject-Oriented Programming.

Inserting ilities by controlling communications

An approach is defined that supplements standard object-oriented methods with a general mechanism for injecting ility implementations into the communications between functional components, allowing ilities to be developed, maintained, and modified with minimal impact on functional implementations.

Toward Reusable Synchronisation for Object-Oriented Languages

This research aims to provide a means for achieving flexible and reusable synchronisation within existing object-oriented languages, such as JavaTM or C++.

Programming expert systems in OPS5

Recent Developments in Aspect

This paper summarizes the latest developments in AspectJ, a general-purpose aspect-oriented programming (AOP) extension to Java, and presents a design space for AOP languages that may be of interest to the AOP community.

The art of the Metaobject Protocol

A new approach to programming language design is presented, which resolves fundamental tensions between elegance and efficiency, and a metaobject protocol is presented that gives users the ability to incrementally modify the language's behavior and implementation.