In most aspects, advice are synchronously executed by application threads, which may cause high overhead if advice execution is frequent or computationally expensive. When synchronous advice execution is not a necessity, asynchronous advice execution has the potential to parallelize program and advice execution on multicores. However, asynchronous advice execution requires communication between threads, causing some overhead. In order to mitigate such overhead, we introduce buffered advice, a new AOP mechanism for aggregating advice invocations in a thread-local buffer, which is processed when it is full. For asynchronous processing of full buffers, the communication overhead is paid only once per buffer, instead of once per advice invocation. We present an enhanced AOP programming model and framework based on AspectJ, which ease the use of buffered advice and support pluggable, custom buffer processing strategies. As case study, we optimize an existing aspect for data race detection using buffered advice. A thorough evaluation with standard benchmarks confirms that the use of buffered advice yields significant speedup on multicores.

JavaScript is widely used to build increasingly complex Web applications. Unsurprisingly, these applications need to address cross-cutting concerns. Therefore support for aspect-oriented programming is crucial to preserve proper modularity. However, there is no aspect-oriented extension of JavaScript that fully embraces the characterizing features of that language: dynamic prototype-based programming with higher-order functions. In this paper, we present AspectScript, a full-fledged AOP extension of JavaScript that adopts higher-order programming and dynamicity as its core design principles. In AspectScript, pointcuts and advices are standard JavaScript functions, bringing the benefits of higher-order programming patterns to define aspects. In addition, AspectScript integrates a number of state-of-the-art AOP features like dynamic aspect deployment with scoping strategies, and user-defined quantified events. We illustrate AspectScript in action with several practical examples from the realm of client Web applications, and report on its current implementation. AspectScript is a practical extension that provides better modularity support to build Web applications, and that will eventually make it possible to empirically validate the benefits brought by advanced aspect language mechanisms in an evergrowing application domain.

An essential part of modern enterprise software development is metadata. Mainstream metadata formats, including XML deployment descriptors and Java 5 annotations, suffer from a number of limitations that complicate the development and maintenance of enterprise applications. Their key problem is that they make it impossible to reuse metadata specifications not only across different applications but even across smaller program constructs such as classes or methods.

To provide better enterprise metadata, we present pattern-based structural expressions (PBSE), a novel metadata representation that offers conciseness and maintainability advantages and is reusable. To apply PBSE to enterprise applications, we translate PBSE specifications to Java annotations, with annotating classes automatically as an intermediate build step. We demonstrate the advantages of the new metadata format by assessing its conciseness and reusability, as compared to XML and annotations, in the task of expressing metadata of J2EE reference applications and a mid-size, commercial, enterprise application.

In aspect-oriented programming languages, advice evaluation is usually considered as part of the base program evaluation. This is also the case for certain pointcuts, such as if pointcuts in AspectJ, or simply all pointcuts in higher-order aspect languages like AspectScheme. While viewing aspects as part of base level computation clearly distinguishes AOP from reflection, it also comes at a price: because aspects observe base level computation, evaluating pointcuts and advice at the base level can trigger infinite regression. To avoid these pitfalls, aspect languages propose ad-hoc mechanisms, which increase the complexity for programmers while being insufficient in many cases. After shedding light on the many facets of the issue, this paper proposes to clarify the situation by introducing levels of execution in the programming language, thereby allowing aspects to observe and run at specific, possibly different, levels. We adopt a defensive default that avoids infinite regression in all cases, and give advanced programmers the means to override this default using level shifting operators. We formalize the semantics of our proposal, and provide an implementation. This work recognizes that different aspects differ in their intended nature, and shows that structuring execution contexts helps tame the power of aspects and metaprogramming.

Embedded domain-specific languages (EDSLs) are said to be easier to compose than DSLs that are implemented by preprocessors. However, existing approaches focus on composition scenarios where the use of abstractions from one domain does not affect the interpretation of abstractions from another domain. This leads to programs that exhibit scattering and tangling symptoms if multiple EDSLs with crosscutting domain semantics are used. To address this issue, we propose an architecture for embedding DSLs that makes use of meta-object protocols and aspect-oriented concepts to support crosscutting composition of EDSLs. This enables to write modularized EDSL programs where each program addresses one concern.

Developing complex software requires that functions be implemented over a variety of recursively defined data structures. While the design (and modeling) of structures is itself difficult, complex data can require even more complex functions. In this paper, we introduce a declarative form of traversal-based generic programming that modularizes functions over a structure using function-objects. Our approach is supported by a library and set of generative tools, collectively called DemeterF, which are used to implement modular, adaptive functions. While our traversals support high-level abstractions resulting in modular and extensible functions, we retain genericity, flexibility and performance through traversal generation and inlining.

Model composition is a common operation used in many software development activities---for example, reconciling models developed in parallel by different development teams, or merging models of new features with existing model artifacts. Unfortunately, both commercial and academic model composition tools suffer from the composition conflict problem. That is, models to-be-composed may conflict with each other and these conflicts must be resolved. In practice, detecting and resolving conflicts is a highly-intensive manual activity. In this paper, we investigate whether aspect-orientation reduces conflict resolution effort as improved modularization may better localize conflicts. The main goal of the paper is to conduct an exploratory study to analyze the impact of aspects on conflict resolution. In particular, model compositions are used to express the evolution of architectural models along six releases of a software product line. Well-known composition algorithms, such as override, merge and union, are applied and compared on both AO and non-AO models in terms of their conflict rate and effort to solve the identified conflicts. Our findings identify specific scenarios where aspect-orientation properties, such as obliviousness and quantification, result in a lower (or higher) composition effort.

Aspect-Oriented Modeling (AOM) provides support for separating concerns at the design level. Even though most AOM approaches provide means to execute the composition of the modularized concerns to obtain a composed model, it is also possible to keep the concerns modularized at the implementation level by targeting an aspect-oriented platform. Model-driven approaches have emerged to support both alternatives via tools. Clearly, these choices are not equivalent. Rather, they have a direct impact on several dimensions, including maintainability. Hence, the main research problem addressed by this work is to figure out which alternative provides for shorter maintenance time. To answer this question, we have conducted a series of quantitative studies and experiments.

Writing detailed API (Application Programming Interface) documentation is a significant task for developing a good class library or framework. However, existing documentation tools such as Javadoc provide only limited support and thus the description written by programmers for API documentation often contains scattering text. Occasionally, it also contains tangling text. This paper presents that this problem is due to crosscutting concerns of API documentation. Then it proposes our new tool named Comment-Weaver, which provides several mechanisms for modularly describing API documentation of class libraries or frameworks written in Java or AspectJ. It is an extended Javadoc tool and it provides several new tags for controlling how the text manually written by the programmers is scattering and appended to other entries or how it is moved from the original entry to another entry to be tangling. Finally this paper evaluates CommentWeaver by using three class libraries and frameworks: Javassist, the Java standard library, and Eclipse. It showed that CommentWeaver resolves the problems of scattering or tangling text and it adequately reduces the amount of description written by programmers for API documentation.

Advice is a mechanism, widely used in aspect-oriented languages, that allows one program component to augment or modify the behavior of other components. When advice and other components are composed together they become tightly coupled, sharing both control and data flows. However this creates important problems: modular reasoning about a component becomes very difficult; and two tightly coupled components may interfere with each other's control and data flows.

This paper presents EffectiveAdvice, a disciplined model of advice, inspired by Aldrich's Open Modules, that has full support for effects. With EffectiveAdvice, equivalence of advice, as well as base components, can be checked by equational reasoning. The paper describes EffectiveAdvice as a Haskell library in which advice is modeled by mixin inheritance and effects are modeled by monads. Interference patterns previously identified in the literature are expressed as combinators. Parametricity, together with the combinators, is used to prove two harmless advice theorems. The result is an effective semantic model of advice that supports effects, and allows these effects to be separated with strong non-interference guarantees, or merged as needed.

Statically typed aspect-oriented programming languages restrict application of around advice only to the join points that have conforming types. Though the restriction guarantees type safety, it can prohibit application of advice that is useful, yet does not cause runtime type errors. To this problem, we present a novel weaving mechanism, called the type relaxed weaving, that allows such advice applications while preserving type safety. We formalized the mechanism, and implemented as an AspectJ compatible compiler, called RelaxAJ.

Over the last five years, several systems have been proposed to take distribution into account in Aspect-Oriented Programming. While they appeared to be fruitful to develop or improve distributed component infrastructures or application servers, those systems are not underpinned with a formal semantics and so do not permit to establish properties on the code to be executed. This paper introduces the aspect join calculus -- an aspect-oriented and distributed language based on the join calculus, a member of the π-calculus family of process calculi suitable as a programming language. It provides a first formal theory of distributed AOP as well as a base language in which many features of previous distributed AOP systems can be formalized.

The semantics of the aspect join calculus is given by a (chemical) operational semantics and a type system is developed to ensure properties satisfied by aspects during the execution of a process. We also give a translation of the aspect join calculus into the core join calculus. The translation is proved to be correct by a bisimilarity argument. In this way, we provide a well-defined version of a weaving algorithm which constitutes the main step towards an implementation of the aspect join calculus directly in JoCaml.

We conclude this paper by showing that despite its minimal definition, the aspect join calculus is a convenient language in which existing distributed AOP languages can be formalized. Indeed, many features (such as remote pointcut, distributed advice, migration of aspects, asynchronous and synchronous aspects, re-routing of messages and distributed control flow) can be defined in this simple language.

A considerable amount of research, especially within the OO and AOSD communities, has focused on understanding the potential and limitations of various composition techniques. This has led to a large amount of proposals for alternative composition techniques, including many variations of message dispatch, inheritance, and aspect mechanisms. This paper makes the case that there is no single perfect composition technique that suits every situation, since different techniques incur different trade-offs. The proper composition technique to use depends on the particular design problem and its requirements (e.g. w.r.t. adaptability, reusability, understandability, robustness, etc. of the various elements of the design). However, most programming languages limit the available composition techniques to a very few. To address this, we propose a novel composition model. The model provides dedicated abstractions that can be used to express a wide variation of object composition techniques ("composition operators"). Examples include various forms of inheritance, delegation, and aspects. The proposed model unifies objects (with encapsulated state and a message interface) and composition operators; composition operators are specified as first-class citizens. Multiple composition operators can be combined within the same application, and composition operators can even be used to compose new composition operators from existing ones. This opens new possibilities for developing domain-specific composition operators, taxonomies of composition operators, and for reuse and refinement of composition operators. To validate and experiment with the proposed model, we have designed and implemented a simple language, that we also use in this paper to show concrete examples.

Aspect-oriented programming languages modularize crosscutting concerns by separating the concerns from a base program in aspects. What they do not modularize well is the code needed to manage interactions between the aspects themselves. Therefore aspects cannot always be composed with other aspects without requiring invasive modifications. This paper proposes a join point model that makes it possible to express aspect composition itself as an aspect, liberating the composed aspects from composition-specific code. We have implemented this new join point model in our Oarta language, an extension of AspectJ, and we show how to use it to write aspects that manage aspect interactions.

An important element of understanding a software code base is to identify the repetitive patterns of code it contains and how these evolve over time. Some patterns are useful to the software, and may be modularized. Others are detrimental to the software, such as patterns that represent defects. In this case, it is useful to study the occurrences of such patterns, to identify properties such as when and why they are introduced, how long they persist, and the reasons why they are corrected.

To enable studying pattern occurrences over time, we propose a tool, Herodotos, that semi-automatically tracks pattern occurrences over multiple versions of a software project, independent of other changes in the source files. Guided by a user-provided configuration file, Herodotos builds various graphs showing the evolution of the pattern occurrences and computes some statistics. We have evaluated this approach on the history of a representative range of open source projects over the last three years. For each project, we track several kinds of defects that have been found by pattern matching. This tracking is done automatically in 99% of the occurrences. The results allow us to compare the evolution of the selected projects and defect kinds over time.

This paper introduces a new aspect-oriented programming language, AspectMatlab. Matlab® is a dynamic scientific programming language that is commonly used by scientists because of its convenient and high-level syntax for arrays, the fact that type declarations are not required, and the availability of a rich set of application libraries.

AspectMatlab introduces key aspect-oriented features in a way that is both accessible to scientists and where the aspect-oriented features concentrate on array accesses and loops, the core computation elements in scientific programs.

Introducing aspects into a dynamic language such as Matlab also provides some new challenges. In particular, it is difficult to statically determine precisely where patterns match, resulting in many dynamic checks in the woven code. Our compiler includes flow analyses which are used to eliminate many of those dynamic checks.

This paper reports on the language design of AspectMatlab, the amc compiler implementation and related optimizations, and also provides an overview of use cases that are specific to scientific programming.

Many software security policies can be encoded as aspects that identify and guard security-relevant program operations. Bugs in these aspectually-implemented security policies often manifest as ambiguities in which aspects provide conflicting advice for a shared join point. The design and implementation of a detection algorithm for such ambiguities is presented and evaluated. The algorithm reduces advice conflict detection to a combination of boolean satisfiability, linear programming, and regular language non-emptiness. Case studies demonstrate that the analysis is useful for debugging aspect-oriented security policies for several existing aspectual security systems.

The integration of third-party aspects into applications creates security challenges. Due to the intrusive impact of aspects, one cannot guarantee that the dynamic composition of aspects does not lead to misbehavior. The newly composed aspect typically has many, if not unrestricted, rights to read and modify attributes of the base system. AspectJ, amongst other AOP systems, suffers from this limitation, which makes the composition of independently developed aspects riskful.

We have defined and prototyped a run-time policy enforcement model based on execution history to protect programs from untrusted aspects. The dynamic nature of the approach has the advantage that up to date run-time information allows more accurate decision making. We have built a prototype for AspectJ and illustrate its use in a realistic example. Our evaluation shows that practical use of such a solution is feasible and that run-time overhead can be limited.

Puma is a framework for the development of applications that analyze and, optionally, transform C or C++ source code. It supports ISO C and C++ as well as many language extensions of the GNU Compiler Collection and Microsoft Visual C++. Aspects played an important role during the design and implementation of the framework. It is written in the AspectC++ language. By employing AOSD concepts, we gained a clean separation of concerns and, thereby, very good configurability and extensibility. All these - ilities are of vital importance for our project, because the available manpower for maintenance tasks is limited. This paper briefly describes the design principles behind Puma.

COBOL is still an important language for building mission critical enterprise systems, and there is huge amount of existing COBOL programs. We have been developing an aspect-oriented COBOL and its development environment. We are applying aspect orientation to strengthening internal control in enterprise information systems. Understanding existing COBOL programs is critical for applying aspect orientation to them, because programmers are not able to write aspects without understanding the existing programs. We have developed an environment for understanding existing COBOL programs and developing COBOL aspects. This paper describes the environment and a experience of applying it to improve internal control implemented in a small information system.