An Overview of ALIA4J

New programming languages that allow to reduce the complexity of software solutions are frequently developed, often as extensions of existing languages. Many implementations thus resort to transforming the extension’s source code to the imperative intermediate representation of the parent language. But approaches like compiler frameworks only allow for re-use of code transformations for syntactically-related languages; they do not allow for re-use across language families. In this paper, we present the ALIA4J approach to bring such re-use to language families with advanced dispatching mechanisms like pointcut-advice or predicate dispatching. ALIA4J introduces a meta-model of dispatching as a rich, extensible intermediate language. By implementing language constructs from four languages as refinements of this meta-model, we show that a significant amount of them can be re-used across language families. Another building block of ALIA4J is a framework for execution environments that automatically derives an execution model of the program’s dispatching from representations in our intermediate language. This model enables different execution strategies for dispatching; we have validated this by implementing three execution environments whose strategies range from interpretation to optimizing code generation

Aspect Model Unweaving

Since software systems need to be continuously available, their ability to evolve at runtime is a key issue. The emergence of models@runtime, combined with Aspect-Oriented Modeling techniques, is a promising approach to tame the complexity of adaptive systems. However, with no support for aspect unweaving, these approaches are not agile enough in an adaptive system context. In case of small modifications, the adapted model has to be generated by again weaving all the aspects, even those unchanged. This paper shows how aspects can be unwoven, based on a precise traceability metamodel dedicated to aspect model weaving. We analyze traceability models, which describe how aspects were woven into a base, to determine the extent to which an aspect has affected the woven model in order to determine how it can be unwoven. Aspect unweaving is finally performed by applying inverse operations of a sub-sequence of the weaving operations in opposite order. © 2009 Springer Berlin Heidelberg

Modules as Objects in Newspeak

We describe support for modularity in Newspeak, a programming language descended from Smalltalk [33] and Self [68]. Like Self, all computation — even an object’s own access to its internal structure — is performed by invoking methods on objects. However, like Smalltalk, Newspeak is class-based. Classes can be nested arbitrarily, as in Beta [44]. Since all names denote method invocations, all classes are virtual; in particular, superclasses are virtual, so all classes act as mixins. Unlike its predecessors, there is no static state in Newspeak, nor is there a global namespace. Modularity in Newspeak is based exclusively on class nesting. There are no separate modularity constructs such as packages. Top level classes act as module definitions, which are independent, immutable, self-contained parametric namespaces. They can be instantiated into modules which may be stateful and mutually recursive

AspectOptima: A Case Study on Aspect Dependencies and Interactions

Abstract. This paper presents AspectOptima, a language independent, aspect-oriented framework consisting of a set of ten base aspects — each one providing a well-defined reusable functionality — that can be configured to ensure the ACID properties (Atomicity, Consistency, Isolation, and Durability) for transactional objects. The overall goal of AspectOptima is to serve as a case study for aspect-oriented software development, in particular for evaluating the expressivity of aspect-oriented programming languages and how they address complex aspect interactions and dependencies. The ten base aspects of AspectOptima are simple, yet have complex dependencies and interactions among each other. To implement different concurrency control and recovery strategies, these aspects can be composed and assembled into different configurations; some aspects conflict with each other, others have to adapt their runtime behavior according to the presence or absence of other aspects. The design of AspectOptima highlights the need for a set of key language features required for implementing reusable aspect-oriented frameworks. To illustrate the usefulness of AspectOptima as a means for evaluating programming language features, an implementation of AspectOptima in AspectJ is presented. The experiment reveals that AspectJ ’s language features do not directly support implementation of reusable aspect-oriented frameworks with complex dependencies and interactions. The encountered AspectJ language limitations are discussed, workaround solutions are shown, potential language improvements are proposed where appropriate, and some preliminary measurements are presented that highlight the performance impact of certain language features