Renaud Pawlak

JAC: A Flexible Solution for Aspect-Oriented Programming in Java

This paper presents JAC (Java Aspect Components), a framework for aspect-oriented programming in Java. Unlike language such as AspectJ which are mostly class-based,JAC is object-based and does not require any language extensions to Java. It uses the Javassist class load-time MOP. An aspect program in JAC is a set of aspect objects that can be dynamically deployed and undeployed on top of running application objects. Aspect objects may define three kinds of aspect methods: wrapping methods (that wrap application methods and provide the ability to run code before and after the wrapped methods), role methods (that add new functionalities to application objects), and exception handlers. The aspects composition issue is handled through a well-defined wrapping controller that specifies for each wrapped object at wrap-time, runtime or both, the execution order of aspect objects.

JAC: an aspect-based distributed dynamic framework

In this paper, we present the Java Aspect Components (JAC) framework for building aspect‐oriented distributed applications in Java. This paper describes the aspect‐oriented programming model and the architectural details of the framework implementation. The framework enables extension of application semantics for handling well‐separated concerns. This is achieved with a software entity called an aspect component (AC). ACs provide distributed pointcuts, dynamic wrappers and metamodel annotations. Distributed pointcuts are a key feature of our framework. They enable the definition of crosscutting structures that do not need to be located on a single host. ACs are dynamic. They can be added, removed, and controlled at runtime. This enables our framework to be used in highly dynamic environments where adaptable software is needed. Copyright

SPOON: A library for implementing analyses and transformations of Java source code

This paper presents SPOON, a library for the analysis and transformation of Java source code. SPOON enables Java developers to write a large range of domain‐specific analyses and transformations in an easy and concise manner. SPOON analyses and transformations are written in plain Java. With SPOON, developers do not need to dive into parsing, to hack a compiler infrastructure, or to master a new formalism. Copyright

An Automatic Aspect Weaver with a Reflective Programming Language

This short paper presents A-TOS (Aspect-TOS (TCL Object System)), an aspect-oriented framework that allows the programmer to define its own specialized aspects and to weave or remove them at runtime. Since A-TOS is based on a configurable and semantic-reliable object-wrapping technique, it is able to solve what we call the Aspect-Composition Issue (ACI), i.e., to detect and solve many semantic conflicts when weaving the different aspects together.

AVal: an Extensible Attribute-Oriented Programming Validator for Java

Attribute-oriented programming (@OP) permits programmers to extend the semantics of a base program by annotating it with attributes defined in an attribute domain-specific language (AttDSL). In this article, we propose AVal: a Java5 framework for the definition and checking of rules for @OP in Java. We define a set of meta-annotations to allow the validation of @OP programs, as well as the means to extend these meta-annotations by using a compile-time model of the programs source code. AVal is fully integrated into the Eclipse IDE. We show the usefulness of the approach by using examples of its use applied to three AttDSLs: an @OP framework that helps programming Simple API for XML parsers, an @OP extension for the Fractal component model called Fraclet, and the JSR 181 for web services definition. Copyright

Dynamic wrappers: handling the composition issue with JAC

Modern applications, and especially distributed ones, need flexibility and dynamic evolution. These goals can be partially reached with separation of concerns. However, a static approach is not sufficient when trying to get dynamic adaptation during the application execution-time. We present the JAC (Java Aspect Components) framework that meets dynamic adaptation by using the notions of dynamic wrappers in order to achieve separation of concerns for non-functional programs, and of wrapping controllers to implement the composition of wrappers (maybe coming from different programmers) at wrap-time and at call-time.

Distributed separation of concerns with aspect components

The paper presents A-TOS, an aspect oriented reflective middleware for distributed programming. It provides a very special kind of entity called aspect components that implement global and transversal properties of (distributed) applications like security, fault tolerance, transactions, and so on. Since the application code does not directly refer to the aspect components, A-TOS achieves clean and powerful separation of concerns based on a wrapping composition model. Its adaptability and aspect distribution capabilities make it well suited to aspect oriented programming in a distributed environment.

AspectTAZ : a new approach based on aspect oriented programming for object oriented industrial messaging services design

Since 1994, we have designed and prototyped several industrial messaging services over different platforms. Our experiments have been based on the ISO-MMS standard and TASE.2. This paper describes lessons learned from these projects, and some of our activities in designing the next generation of industrial messaging services. Faced with the fast changing world of communication protocols, a stringent requirement for these services is to be easily adaptable to new protocols (ONC-RPC and CORBA in the past, now SOAP/XML). Recent software engineering research introduced the notion of aspect-oriented programming (AOP) to cope with such a need in adaptability. This paper demonstrates the viability of this approach in addressing our requirement.

Programming Robots with Events

We introduce how to use event-based style to program robots through the INI programming language. INI features both built-in and user-defined events, a mechanism to handle various kinds of changes happening in the environment. Event handlers run in parallel either synchronously or asynchronously, and events can be reconfigured at runtime to modify their behavior when needed. We apply INI to the humanoid robot called Nao, for which we develop an object tracking program.

Using Event-Based Style for Developing M2M Applications

In this paper, we introduce how to write M2M applications by using INI, a programming language specified and implemented by ourselves that supports event-based style. With event-based programming, all M2M communication can be handled and scheduled. Programmers may use existing built-in events or define their own events. We apply our approach in a real M2M gateway, which allows gathering and exchanging information between sensors and machines in the network. The results shows that our work proposes a concise and elegant alternative and complement to industrial state-of-the-art languages such as Java or C/C++.