Towards a Taxonomy of Aspect-Oriented Programming.

As programs continue to increase in size, it has become increasingly difficult to separate concerns into well localized modules, which leads to code tangling- crosscutting code spread throughout several modules. Thus, Aspect-Oriented Programming (AOP) offers a solution to creating modules with little or no crosscutting concerns. AOP presents the notion of aspects, and demonstrates how crosscutting concerns can be taken out of modules and placed into a centralized location. In this paper, a taxonomy of aspect-oriented programming, as well as a basic overview and introduction of AOP, will be presented in order to assist future researchers in getting started on additional research on the topic. To form the taxonomy, over four-hundred research articles were organized into fifteen different primary categories coupled with sub-categories, which shows where some of the past research has been focused. In addition, trends of the research were evaluated and paths for future exploration are suggested

A Pure Embedding of Roles: Exploring 4-dimensional Dispatch for Roles in Structured Contexts

Present-day software systems have to fulfill an increasing number of requirements, which makes them more and more complex. Many systems need to anticipate changing contexts or need to adapt to changing business rules or requirements. The challenge of 21th-century software development will be to cope with these aspects. We believe that the role concept offers a simple way to adapt an object-oriented program to its changing context. In a role-based application, an object plays multiple roles during its lifetime. If the contexts are represented as first-class entities, they provide dynamic views to the object-oriented program, and if a context changes, the dynamic views can be switched easily, and the software system adapts automatically. However, the concepts of roles and dynamic contexts have been discussed for a long time in many areas of computer science. So far, their employment in an existing object-oriented language requires a specific runtime environment. Also, classical object-oriented languages and their runtime systems are not able to cope with essential role-specific features, such as true delegation or dynamic binding of roles. In addition to that, contexts and views seem to be important in software development. The traditional code-oriented approach to software engineering becomes less and less satisfactory. The support for multiple views of a software system scales much better to the needs of todays systems. However, it relies on programming languages to provide roles for the construction of views. As a solution, this thesis presents an implementation pattern for role-playing objects that does not require a specific runtime system, the SCala ROles Language (SCROLL). Via this library approach, roles are embedded in a statically typed base language as dynamically evolving objects. The approach is pure in the sense that there is no need for an additional compiler or tooling. The implementation pattern is demonstrated on the basis of the Scala language. As technical support from Scala, the pattern requires dynamic mixins, compiler-translated function calls, and implicit conversions. The details how roles are implemented are hidden in a Scala library and therefore transparent to SCROLL programmers. The SCROLL library supports roles embedded in structured contexts. Additionally, a four-dimensional, context-aware dispatch at runtime is presented. It overcomes the subtle ambiguities introduced with the rich semantics of role-playing objects. SCROLL is written in Scala, which blends a modern object-oriented with a functional programming language. The size of the library is below 1400 lines of code so that it can be considered to have minimalistic design and to be easy to maintain. Our approach solves several practical problems arising in the area of dynamical extensibility and adaptation

Incremental programming with extensible decisions

This paper proposes a new model of programming, in which the behavior of a program can be defined as separate decision point branches. Allowing more precise expression of the condition determining when a branch should be chosen at a decision point leads to better support for incremental programming. This model can be viewed as a fundamental mechanism underlying both OOP and AOP, which can serve as lower-level building blocks that can be put together into the higher-level constructs present in many AOP systems.

Incremental Programming with Extensible Decisions

Languages that support incremental programming, that is, the construction of new program components by specifying how they differ from existing components, allow for clean separation of concerns. Object-oriented languages support incremental programming with inheritance and dynamic dispatch features: whenever a message is sent, a decision occurs, but the branches of the decision can be specified in separate components. Aspect-oriented programming and predicate dispatching both introduce language mechanisms that improve on this support by allowing an extensible decision to depend on information about the message send other than just the dynamic type of the receiver or arguments. A small prototype language is presented that unifies the best features of these mechanisms, providing uniform support for incremental programming whether concerns are crosscutting or not. The language is demonstrated with a running example, a small data structure library that is incrementally extended with optimizations and new operations

Incremental Programming with Extensible Decisions

Keywords Aspect-oriented programming, predicate dispatching, incremental programming, extensibility, separation of concerns 1. INTRODUCTION Incremental programming is defined by Cook and Palsberg as the construction of new program components by specifying how they differ from existing components [9]. A language that supports incremental programming allows for clean separation of concerns, because a component that involves multiple concerns can be expressed as a sequence of components, one per concern, each one extending or overriding the behavior in the previous components without requiring modification or duplication of code. This can improve the understanding, maintenance, and re-use of software. Object-oriented programming (OOP) languages typically support incremental programming with inheritance and dyTo appear in the 1st International Conference on Aspect-Oriented SoftwareDevelopment (AOSD), April 2002, Enschede, The Netherlands