Advice is a mechanism used by advanced object-oriented and aspect-oriented programming languages to augment the behavior of methods in a program. Advice can help to make programs more modular by separating crosscutting concerns more e#ectively, but it also challenges existing ideas about modularity and separate development.

Aspect-oriented programming (AOP) is a new programming paradigm whose goal is to more cleanly modularize crosscutting concerns such as logging, synchronization, and event notification which would otherwise be scattered throughout the system and tangled with functional code. However, while AOP languages provide promising ways to separate crosscutting concerns, they can also break conventional encapsulation mechanisms, making it di#cult to reason about code without the aid of external tools.

Aspect-Oriented Programming (AOP) promises the modularization of so-called crosscutting functionalities in large applications. Currently, almost all approaches to AOP provide means for the description of sequential aspects that are to be applied to a sequential base program. In particular, there is no formally-defined concurrent approach to AOP, with the result that coordination issues between aspects and base programs as well as between aspects cannot precisely be investigated. This paper presents Concurrent Event-based AOP (CEAOP), which addresses this issue. Our contribution can be detailed as follows. First, we formally define a model for concurrent aspects which extends the sequential Event-based AOP approach. The definition is given as a translation into concurrent specifications using Finite Sequential Processes (FSP), thus enabling use of the Labelled Transition System Analyzer (LTSA) for formal property verification. Further, we show how to compose concurrent aspects using a set of general composition operators. Finally, we sketch a Java prototype implementation for concurrent aspects, which generates coordination specific code from the FSP model

Formal study of aspect-oriented languages is di#cult because current theoretical models provide a range of features that is too limited and rely on encodings using lower-level abstractions, which involve a cumbersome level of indirection. We present a calculus, based on Abadi and Cardelli's object calculus, that explicitly models a base language and a variety of point cut description languages. This explicit modeling makes clear the aspect-oriented features of the calculus by removing the indirection of some existing models. We demonstrate the generality of our calculus by presenting models for AspectJ's open classes and advice, and HyperJ's compositions, and sketching a model for DemeterJ's adaptive methods.

Abstract. Advanced techniques in separation of concerns such as Aspect-Oriented Programming, help to develop more maintainable and more efficient applications by providing means for modularizing crosscutting concerns. However, conflicts may appear when several concerns need to be composed for the same application, especially when dealing with around advice. We call this problem the Aspect Composition Issue (ACI). Based on our experience in programming aspects, this paper presents a language called CompAr, which allows the programmer to abstractly define an execution domain, the advice codes, and their execution constraints. The CompAr compiler then evaluates the definitions in order to check if the execution constraints are fulfilled. Using a concrete AOP case study, we show how to use the CompAr language in order to detect and avoid ACIs.

Aspect-Oriented Programming (AOP) and related techniques propose solutions to the problem of crosscutting requirements, usually by providing a weaver that reimplements major parts of a compiler. This paper proposes XML based "operators" as an extensible aspect language. We work on XML representations of abstract syntax trees (AST) for the base language. These can be generated by modifying an existing compiler and allow us to use XML tools for tree query and manipulation. A prototype that encompasses constructs from several aspect languages, in particular AspectJ and Composition Filters, has been implemented.

Abstract not found

Aspect Oriented Programming can arbitrarily distort the semantics of programs. In particular, weaving can invalidate crucial safety and liveness properties of the base program. In this article, we identify categories of aspects that preserve some classes of properties. It is then sufficient to check that an aspect belongs to a specific category to know which properties will remain satisfied by woven programs. Our categories of aspects, inspired by Katz’s, comprise observers, aborters and confiners. Observers introduce new instructions and a new local state but they do not modify the base program’s state and control-flow. Aborters are observers which may also abort executions. Confiners only ensure that executions remain in the reachable states of the base program. These categories (along with three other) are defined precisely based on a language independent abstract semantics framework. The classes of properties are defined as subsets of LTL for deterministic programs and CTL * for non-deterministic ones. We can formally prove that, for any program, the weaving of any aspect in a category preserves any property in the related class. We give examples

Some solutions proposed in the original design pattern literature were shaped by techniques as well as language deficiencies from object-oriented software development. However, new modularity constructs, composition and transformation mechanisms offered by aspect-oriented programming address deficiencies of object-oriented modeling. This suggests classical design pattern solutions to be revisited. In our paper we point out that aspect-oriented programming not only allows for alternative representations of proposed solutions, but also for better solutions in the first place. We advocate a native aspect-oriented approach to design patterns that emphasizes on improving design pattern solutions both during development and at run-time. We use a simple yet effective method to analyze and describe different solutions based on variation points, fixed parts, variable parts, and optional glue, employing dynamic run-time weaving.

The term rule-based program is meant to include definite clause programs, SOS specifications, attribute grammars, and conditional rewrite systems. These setups are widely used for the executable specification or implementation of language-based tools, e.g., interpreters, translators, type checkers, program analysers, and program transformations. We provide a pragmatic, transformation-based approach for expressing and tracking changes in rule-based programs in the course of program evolution. To this end, we design an operator suite for the transformation of rule-based programs. The operators facilitate steps for clean-up, refactoring, and enhancement. We use SOS-based interpreter examples to illustrate evolution of rule-based programs. We use logic programming to execute the examples, while the relevant evolution operators are made available as logic meta-programs.