Pierre Cointe

Partial behavioral reflection: spatial and temporal selection of reification

Behavioral reflection is a powerful approach for adapting the behavior of running applications. In this paper we present and motivate partial behavioral reflection, an approach to more efficient and flexible behavioral reflection. We expose the spatial and temporal dimensions of such reflection, and propose a model of partial behavioral reflection based on the notion of hooksets. In the context of Java, we describe a reflective architecture offering appropriate interfaces for static and dynamic configuration of partial behavioral reflection at various levels, as well as Reflex, an open reflective extension for Java implementing this architecture. Reflex is the first extension that fully supports partial behavioral reflection in a portable manner, and that seamlessly integrates load-time and runtime behavioral reflection. The paper shows preliminary benchmarks and examples supporting the approach. The examples, dealing with the observer pattern and asynchronous communication via transparent futures, also show the interest of partial behavioral reflection as a tool for open dynamic Aspect-Oriented Programming.

Explicit Metaclasses as a Tool for Improving the Design of Class Libraries

Existing OO methodologies focus on instance behaviors and reduce the role of a class to object creation. In fact, these methodologies do not address the issue of class design itself.

A generative programming approach to developing DSL compilers

Domain-Specific Languages (DSLs) represent a proven approach to raising the abstraction level of programming. They offer high-level constructs and notations dedicated to a domain, structuring program design, easing program writing, masking the intricacies of underlying software layers, and guaranteeing critical properties. On the one hand, DSLs facilitate a straightforward mapping between a conceptual model and a solution expressed in a specific programming language. On the other hand, DSLs complicate the compilation process because of the gap in the abstraction level between the source and target language. The nature of DSLs make their compilation very different from the compilation of common General-Purpose Languages (GPLs). In fact, a DSL compiler generally produces code written in a GPL; low-level compilation is left to the compiler of the target GPL. In essence, a DSL compiler defines some mapping of the high-level information and features of a DSL into the target GPL and underlying layers (e.g., middleware, protocols, objects, ...). This paper presents a methodology to develop DSL compilers, centered around the use of generative programming tools. Our approach enables the development of a DSL compiler to be structured on facets that represent dimensions of compilation. Each facet can then be implemented in a modular way, using aspects, annotations and specialization. Because these tools are high level, they match the needs of a DSL, facilitating the development of the DSL compiler, and making it modular and re-targetable. We illustrate our approach with a DSL for telephony services. The structure of the DSL compiler is presented, as well as practical uses of generative tools for some compilation facets.

Definition of a Reflective Kernel for a Prototype-Based Language

We present the implementation of Moostrap, a reflective prototype-based language, the interpreter of which is written in Scheme. Moostrap is based on a reduced number of primitives, according to a previous work for denning a taxonomy for prototype-based languages.

A semantics of introspection in a reflective prototype-based language

In Malenfant et al. [19], we have described a reflective model for a prototype-based language based on thelookup o apply reflective introspection protocol. In this paper, we augment our previous protocol by converting it to handle continuations reified as first-class objects. First-class continuations provide much more control over the current computation; during the introspection phase fired by message sending, they make it possible not only to change the behavior of the program for that message but also for the entire future computation. In this paper, we provide this introspection protocol with a formal semantics. This result is obtained by exhibiting a mapping Δ from program configurations to priority rewrite systems (PRS) as well as a mapping from message expressions to ground first-order terms used to query the PRS. Other advantages of this approach are: to ensure the termination of the introspection using the smallest set of formally justified conditions and to provide a clear declarative account of this reflective protocol. The PRS also appears as a meta-level to the base language, independent of the implementation, but from which we derive fundamental clues to obtain an efficient language processor. By our new model, we finally highlight the link between reflection in object-oriented languages and the one originally proposed by 3-Lisp [24], although object-orientation provides reusability to reflection, making it easier to use.

Programmation post-objets : des langages d'aspects aux langages de composants

(Re)using and adapting components are two key issues in the field of software architecture. Yet, enterprises are still waiting for genuine off-the-shelf components. Since 20 years, object-oriented programming has become the de facto programming standard. Nevertheless objects have partially failed to address the scalability requirements introduced by the Internet. One of the unresolved challenges is the building of large software with the appropriate granularity. From this perspective, objects have given incomplete answers to the problem of component assembly and life-cycle management. We introduce the post-object age by discussing, on the one hand, the evolution from objects to components and by introducing, on the other hand the evolution from objects to aspects.

Understanding design patterns density with aspects

Design patterns offer solutions to common engineering problems in programs [1]. In particular, they shape the evolution of program elements. However, their implementations tend to vanish in the code: thus it is hard to spot them and to understand their impact. The problem becomes even more difficult with a “high density of pattern”: then the program becomes easy to evolve in the direction allowed by patterns but hard to change [2]. Aspect languages offer new means to modularize elements. Implementations of object-oriented design patterns with AspectJ have been proposed [3]. We aim at testing the scalability of such solutions in the JHotDraw framework. We first explore the impact of density on pattern implementation. We show how AspectJ helps to reduce this impact. This unveils the principles of aspects and AspectJ to control pattern density.

From (meta) objects to aspects: a java and AspectJ point of view

eWe point some major contributions of the object-oriented approach in the field of separation of concerns and more particularly design-patterns and metaobject protocols. We discuss some limitations of objects focusing on program reusability and scalability. We sketch some intuitions behind the aspect-oriented programming (AOP) approach as a new attempt to deal with separation of concerns by managing scattered and tangled code. In fact AOP provides techniques to represent crosscutting program units such as display, persistency and transport services. Then AOP allows to weave these units with legacy application components to incrementally adapt them. We present a guided tour of AspectJ illustrating by examples the new concepts of pointcuts, advices and inter-type declarations. This tour is the opportunity to discuss how the AspectJ model answers some of the issues raised by post-object oriented programming but also to enforce the relationship between reflective and aspect-oriented languages.

Towards generative programming

Generative Programming (GP) is an attempt to manufacture software components in an automated way by developing programs that synthesize other programs. Our purpose is to introduce the what and the how of the GP approach from a programming language point of view. For the what we discuss the lessons learned from object-oriented languages seen as general purpose languages to develop software factories. For the how we compare a variety of approaches and techniques based on program transformation and generation. On the one hand, we present the evolution of open-ended languages from metalevel programming to aspect-oriented programming. On the other hand, we introduce domain-specific languages as a way to bridge the gap between conceptual models and programming languages.

Un métamodèle pour coupler application et détection des design patterns

A brake lockout system is provided for use in conjunction with the air brake systems of heavy vehicles, such as trucks that are equipped with other air operated equipment to prevent release of a parking brake unless the air operated equipment is in a disengaged condition.