July 3-7, Nantes (France)
Posters and Demos

• Poster submission is no longer possible. See the Call for Posters.

Poster program

The poster display runs from Tuesday evening (during the half industrial day cocktail) until Friday. It will take place at the mezzanine. The posters will be presented during the Tuesday evening cocktail as well as during the Thursday afternoon coffee break.

P1 - A Role-Based Implementation of Context-Dependent Communications Using Split Objects

Jorge Vallejos, Peter Ebraert, Tom Van Cutsem, Stijn Mostinckx, Brecht Desmet, Pascal Costanza, Theo D'Hondt,
Programming Technology Lab, Vrije Universiteit Brussel

We focus on the context-awareness feature in the domain of pervasive computing. Our particular interest is to investigate how context information may influence the communication between software applications. We observe that the response of a message (the behaviour of the message's receiver) may not only depend on its own context, but also on the context of the message's sender. The problem is then how to model such a double influence of the context. We claim that a programming language that does not provide dedicated features to express the context of communications, inevitably leads to the problem of tangling context information with the functional behaviour of applications. We propose the use of a rolebased model to overcome this problem. An application is composed of roles representing its different context-dependent behaviours which are selected according to the context information of the communication. We describe an implementation of context-dependent roles based on split objects, which were presented by Bardou and Dony in their 1996 OOPSLA paper.

P2 - Ambient References: Addressing Objects in Mobile Networks

Tom Van Cutsem, Programming Technology Laboratory, Vrije Universiteit Brussel

A significant body of research in ubiquitous computing deals with mobile networks, i.e. networks of mobile devices interconnected by wireless communication links. Due to the very nature of such mobile networks, addressing and communicating with remote objects is significantly more difficult than in their fixed counterparts. This poster describes ambient references, a novel remote object referencing abstraction in the context of such mobile networks. Remote object references are one of the most fundamental programming abstractions of any distributed object-oriented programming language. The poster describes why novel referencing abstractions are needed and describes the benefits of ambient references over classic remote object references in mobile networks.

P3 - Ambient-Oriented Exception Handling

Stijn Mostinckx, Programming Technology Laboratory, Vrije Universiteit Brussel

Exception handling mechanisms are essential parts of current-day programming language because they provide a clean mechanism to separate the handling of exceptional events from default behaviour. In the context of mobile ad hoc networks, the increasing probability of exceptional events (such as disconnections, software mobility, changing environmental conditions) clearly necessitates the introduction of adequate support to handle exceptions. This poster presents a systematic analysis of the requirements for an exception handling mechanism for mobile ad hoc networks and outlines how these criteria can be mapped onto a set of easily implementable and reusable language constructs.

P4 - Semi-Automatic Garbage Collection for Mobile Networks

Elisa Gonzalez Boix, Programming Technology Lab, Vrije Universiteit Brussel

In the context of mobile networks, distributed garbage collection (DGC) must deal with volatile connections which may break remote references unexpectedly for an undetermined amount of time. This poster discusses the new challenges that mobile networks pose to DGC and describes a new approach called semi-automatic garbage collection to cope with them. The rationale behind semi-automatic garbage collection is that automatic transparent DGC is irreconcilable with such highly partial disconnected network topology. We propose that the responsibility of DGC is shared among collector and developer in such a way that the collector is steered by the developer who has semantic knowledge of the object graph.

P5 - Codevo: Investigating and Visualizing Structures for Code Evolution

Henrik S. Hansen, Christoffer S. Hansen,
Master's students in software engineering at Aalborg University Esbjerg

Codevo is a system for tracking and visualizing software evolution. By collecting the motivation and intent behind version control commits, and by grouping changes in "low-level change" and "composite change" structures, Codevo makes semantically meaningless commits impossible. Composite changes are composed of low-level changes, and can be one of two types: "composite behavioral change" (altering the program behavior), or "composite refactoring" (changing the internal code structure, but not the behavior). The code evolution is visualized using views, which display both the object-oriented structural changes and their metadata.

P6 - Model Level Validation of Component Based Software for Distributed Embedded Systems

Dietmar Schreiner, Karl M. Göschka, Vienna University of Technology

When building a component based application for distributed embedded systems, it's overall behavior depends not only on the contracts applying to the components and their interfaces, but even more so on explicit as well as implicit connectors emerging from component composition, deployment and interaction. Explicit connectors provide additional contracts on resource requirements and information channels. We contribute by showing how to perform model level validation of component and contract composition beyond simple interface matching. Moreover, we discuss a classification of typical component connectors to simplify application development for distributed embedded systems. This avoids the need of extensive knowledge of communication subsystems and the existence of any heavy weight middle-ware.

P7 - Tiny Devices Deserve Object Oriented Technologies

Fred Rivard, Industrial Software Technology

There is a class of devices still programmed the "hard way", by use of languages such as C and Asm. Surprisingly, these devices are all around us: phones, cars, home appliances, toys, various controls and sensors, networks, music players, etc... At their heart, there is one of the nearly 10 billion microcontrollers released every year. But more than 85% of them (8bits, 16bits and low-end 32bits) lack the possibility to be programmed with high-productivity software langages, such as Java. This poster is about IceTea™, a new java-like language that embraces OOP on tiny devices that target deeply embedded or resource constrained applications. With a syntax à la Java, IceTea™ semantics are close to Java's, it has borrowed from C hardware interfaces and from assembly speed and code compacity. IceTea's aims to make it possible to create very small and fast programs with tight requirements using Java-like source code. A first implementation targets Atmel AVR microcontrollers.

P8 - A Systematic Method for the Detection and Correction of Design Defects

Naouel Moha, GEODES - Research Group on Open, Distributed Systems, Experimental Software Engineering,
Department of Informatics and Operations Research, University of Montreal

Design defects are poor design choices that lessen the quality of object-oriented architectures and impede their evolution and their maintenance. A good architecture without defects reduces significantly maintenance costs by easing comprehension and changes. However, the detection and correction of design defects are difficult because of the lack of precise specifications and tools. Our goal is to provide a systematic method to specify design defects consistently and precisely and to generate detection and correction algorithms using refactorings from their specifications semi-automatically. We propose to apply and validate these algorithms on open-source object-oriented programs to show that our method allows the systematic description, detection, and correction of design defects with a reasonable precision.

P9 - Ambient-Oriented Programming in AmbientTalk

Jessie Dedecker, Programming Technology Laboratory, Department of Computer Science, Vrije Universiteit Brussel

A new field in distributed computing, called Ambient Intelligence, has emerged as a consequence of the increasing availability of wireless devices and the mobile networks they induce. Developing software for such mobile networks is extremely hard in conventional programming languages because of new distribution issues related to volatile network connections, dynamic network topologies and partial failures. This leads us to postulate a suite of characteristics of future Ambient-Oriented Programming languages. A simple reflective programming language, called AmbientTalk, that meets the characteristics is presented.

P10 - SmPL: A Domain-Specific Language for Specifying Collateral Evolutions in Linux Device Drivers

Yoann Padioleau, Gilles Muller, OBASCO project, École des Mines de Nantes/INRIA, LINA
Julia L. Lawall, DIKU, University of Copenhagen

Collateral evolutions are a pervasive problem in large-scale software development. Such evolutions occur when an evolution that affects the interface of a generic library entails modifications, i.e., collateral evolutions, in all library clients.

We have studied the collateral evolution problem in the context of Linux device drivers. Currently, collateral evolutions in Linux are mostly done manually using a text editor, or with tools such as sed. The large number of Linux drivers, and complexity of the collateral evolutions, however, implies that these approaches are time-consuming and unreliable, leading to subtle errors when modifications are not done consistently.

To address these problems, we propose a transformation language, SmPL, to specify collateral evolutions. Because Linux programmers are used to exchange, read, and manipulate program modifications in terms of patches, we have built our language around the idea and syntax of a patch, extending patches to Semantic Patches.

P11 - ComDeCo (Composable Derivative Contracts)

Markus Reitz, University of Kaiserslautern

The project ComDeCo aims at providing a component-oriented design and valuation framework for a wide range of derivative contracts. Based on the concept of an Active Document, the principle of thinking in components is transferred to the end-user domain. Because financial engineers often do not have in-depth software development expertise, easy composition techniques superseding low-level, inflexible, and error-prone state of the practice approaches have to be developed. Using ComDeCo's domain-specific framework, current as well as future types of contracts are designed and evaluated efficiently, providing a scalable solution for the problems of shortening product life and time to market cycles.

ComDeCo is an interdisciplinary joint work of the Financial Mathematics Group and the Software Technology Group at the University of Kaiserslautern and the Department of Financial Mathematics of Fraunhofer ITWM within the scope of the cluster of excellence DASMOD (http://www.dasmod.de) of Rhineland-Palatinate, Germany.

P12 - Concurrent Aspects

Angel Núñez, Rémi Douence, Didier Le Botlan, Jacques Noyé, Mario Südholt,
OBASCO project, École des Mines de Nantes/INRIA, LINA

Aspect-Oriented Programming (AOP) promises the modularization of so-called crosscutting functionalities in large applications. Currently, almost all approaches to AOP provide means for the description of sequential aspects that are to be applied to a sequential base program. In particular, there is no formally-defined concurrent approach to AOP. This poster presents Concurrent Event-based AOP (CEAOP), which addresses this issue. Concurrent aspects are modeled and composed using the semantics of Finite Sequential Processes (FSP). The interest of FSP is that it provides a fairly simple model of concurrency that is well documented and supported by a valuable model checker, LTSA. In order to concretize our ideas, we have built a prototype for Java, which makes it possible to implement and compose aspects together with the base program following the FSP semantics.

P13 - On-the-fly Software Evolution using Arachne, a Runtime Aspect Weaver

Nicolas Loriant, Jean-Marc Menaud, OBASCO project, École des Mines de Nantes/INRIA, LINA

Security, networking and prefetching are typical examples of concerns which crosscut system-level applications. While a careful design can help to address these concerns, they frequently become an issue at runtime, especially in the case of long running applications such as web servers.

Arachne is an aspect-oriented system for C applications. It features a general purpose aspect language, and a runtime aspect weaver for C applications on x86/Linux architectures. Arachne has been built to pragmatically explore the advantages and drawbacks of Aspect-Oriented solutions to software evolution issues on "on production" applications. Arachne has already been applied to correct a security issue in wu-ftpd, to extend the Squid web cache with a prefetching policy and to adapt a medical image software. These experiments compared to their hand-written equivalent prove Arachne to be expressive and efficient enough for software evolution.

On-going projects on Arachne are to extend its language to C++ and to adapt it to the Linux kernel. Future work also comprises a distributed extension to Arachne.

P14 - History-based Aspects Using Temporal Logic for Context Awareness in Pointcuts

Charlotte Herzeel, Kris Gybels, Pascal Costanza Programming Technology Lab, Vrije Universiteit Brussel

Recent research in aspect-oriented programming has evolved towards aspect that are triggered based on the occurrence of a series of join points in the execution of a program and past program state: We present HALO, a novel pointcut language based on logic meta programming and temporal logic, which allows one to reason about program execution and (past) program state.

P15 - JTL – the Java Tools Language

Tal Cohen, Joseph (Yossi) Gil, Itay Maman The Technion–Israel Institute of Technology

JTL, (The Java Tools Language, pronounced "Gee-tel") is a novel language for querying Java programs that was designed to server the development of source code software tools for Java, and for programming language extensions. Applications include definition of pointcuts for aspect-oriented programming, fixing type constraints for generic programming, specification of encapsulation policies, etc.

Special effort was taken to support a query by example syntax which does not limit the language's expressiveness. Specifically, JTL relies on a Datalog-like syntax and semantics, enriched with quantifiers and pattern matching which all but entirely eliminate the need for recursive calls. Underlying the semantics is a relational data model which is more suitable for the representation of object-oriented programs than a hierarchical abstract syntax tree.

The JTL processor includes a type inference engine as well as a query analyzer that warns the user when sheen attempts to issue a query that relies on a "closed world assumption".

Demonstration program

Demonstrations will be played during the technical sessions, a first time on Wednesday or on Thursday (see below), and possibly a second time on Thursday in the evening or on Friday in the morning (have a look at the announcements).

D1 - Language Constructs for Context-oriented Programming - A Demonstration of ContextL

Wednesday, 10:30 - 11:00
Pascal Costanza, Vrije Universiteit Brussel
Robert Hirschfeld, Hasso-Plattner-Institut Potsdam

ContextL is one of our first programming language extensions that explicitly support Context-oriented Programming. In Context-oriented Programming, programs consist of partial class and method definitions that can be selected and composed at runtime as needed, encouraging continually adjusting behavior of programs according to their context of use.

The following examples are to motivate the need to provide code depending on its deployment and execution context.

• Mobile applications running on mobile devices might need to dynamically adjust their behavior according to the geographical context in which they are used.
• Mobile code typically depends on the context of the runtime environment in which it is executed, such as applets or software agents.
• Exploration environments create safe contexts in which to execute applications and can considerably help users to learn how to use them.

With contemporary mainstream programming languages, the only way to introduce context-dependent behavior into a program is either by inserting if statements wherever necessary to check for the context in which a program is running, violating one of the fundamental principles of object-oriented programming, namely to avoid explicit conditionals for achieving polymorphic behavior, or else by factoring out the context-dependent behavior into separate objects that can be substituted according to specific contexts of use. Both approaches lead to unnecessarily complicated code that is hard to comprehend and even harder to maintain.

With Context-oriented Programming on the other hand, we can modularize context-dependent parts of a software system using partial class and method definitions which are organized within layers. Layers are composed into or out of the system depending on the context apparent during program execution. The basic concept of layers as partial program definitions has been suggested before, but with our approach we extend this idea by the notion of dynamically scoped layer activation, resulting in a viable approach for expressing context-dependent behavior.

In our demonstration of ContextL we will show and discuss the following.

• The basic language constructs for Context-oriented Programming.
• The development of comprehensive non-trivial examples.
• Implementation issues, especially with regard to retaining efficient method dispatch.
• Future work, including steps towards a notion of first-class contexts.

ContextL is used as a research platform, but has already been used in industrial settings as well. Activities concerning ContextL are carried out in an open-source project which is available at http://common-lisp/project/closer.

D2 - Ambient-Oriented Programming in AmbientTalk: Combining mobile hardware with simplicity and expressiveness

Wednesday, 11:00 - 11:30
Jessie Dedecker, Tom Van Cutsem, Stijn Mostinckx, Theo D'Hondt, Wolfgang De Meuter,
Programming Technology Laboratory, Vrije Universiteit Brussel

Software development for mobile devices (such as smart phones and PDAs) is given a new impetus with the advent of mobile networks. Mobile networks surround a mobile device equipped with wireless technology and are demarcated dynamically as users move about. They turn applications running on mobile devices from mere isolated programs into smart applications that can cooperate with their environment. As such, mobile networks comprise an important part of the hardware landscape of next-generation pervasive computing and Ambient Intelligence applications. To deal with the implications of these radically changing hardware characteristics on the software engineering level, we have proposed a new paradigm of computing named ambient-oriented programming the details of which are presented in the Languages technical track.

The demonstration showcases AmbientTalk, a first exemplar ambient-oriented programming language. In essence, AmbientTalk is a distributed object-oriented programming language. It is a small dynamic language the features of which are entirely geared towards developing software for mobile (ad hoc) networks. Concurrency and distribution are achieved via the use of active objects, akin to the well-known actor model. In the demo, we illustrate the language's design via the demonstration of an application running on a number of PDAs connected via a wireless network. We interleave the demonstration with slides illustrating code snippets from the source code of the application.

The goal of the demonstration is to show how programming in AmbientTalk significantly eases the conceptual burden of developing software for distributed systems where devices are mobile, where connections are volatile and intermittent and where communicating parties often have to be discovered spontaneously in the nearby environment. In order to show where expressiveness and simplicity are gained in comparison to other approaches, we discuss the mechanics of a number of dedicated ambient-oriented language constructs.

D3 - Java and IceTea™ on 8bits AVR RISC microcontrollers using Eclipse

Wednesday, 11:30 - 12:00
Fred Rivard, IST, Industrial Software Technology, in collaboration with ATMEL

The purpose of the demo is to show full Object Oriented Programming on small 8-bits microcontrollers as a reality. In collaboration with Atmel, IST demonstrates Object Oriented software design for the ATMEL RISC AVR Core. OO software is designed on the Eclipse platform and target two 8-bit microcontrollers: AT90CAN128 and ATmega128. These two devices embed 8KB of data RAM and 128KB of Flash program memory and fit very well to embedded applications found in consumer, industrial, security, communications and automotive markets.

Demo's hardware involves a regular PC running Eclipse. The PC also features a CAN network node that sends music frames to a DVK90CAN development. Amongst others things, that board offers many LEDs, a buzzer and a serial port. A second development board that features Ethernet connectivity and a small LCD device is connected to the DVK90CAN board using the serial port. The DVK90CAN uses that second board to display titles of the streamed music. A full-featured Java virtual machine runs on the ATmega128. IceTea, a java-like language, runs on the AT90CAN128. During the demo it will be possible to modify software running on the two boards according to attendees' wishes. Through the use of Eclipse PlugIns, both Java and IceTea romizers will be used in order to generate ROM images that will be downloaded directly to microcontroller Flash program memories. Doing so, attendees will be able to interact and manipulate OOP on small devices. The whole development cycle will also get involved through the use of traditional IDE features (breakpoints, interruptions, memory inspection, code browsing, etc. ).

Software basis of the demo consists of streaming music from a PC to another CAN node, buffering the music. Buffer's load is shown using LEDs while the music is played to the buzzer. The music name is grabbed from the music stream, and sent through the serial port. On the other end of the serial connection, a java program (running on top of a jvm) listens through an opened SerialInputStream for data to be received. Once the music title is received, it is displayed to the LDC display using the library Display class APIs.

D4 - Acceleo : Eclipse and EMF template based system for MDA generation

Wednesday, 14:00 - 14:30
Etienne Juliot, Stéphane Lacrampe, Obeo

Acceleo is an innovative and OpenSource MDA (Model Driven Architecture) code generator, based on eclipse and EMF (Eclipse Modeling Framework). It has been designed to improve software development productivity, durability and agility, but also to make MDA easier to learn and use.

It makes it possible for architects and developers to embed complex and powerful architecture patterns in generators and apply them automatically to functional models. Acceleo is used in the context of the Y development cycle, for gathering the left (functional) and right (technical) parts of the Y altogether to produce automatically application code. Designers can concentrate on high level design models and architects can link efficiently these models with the development phase.

This presentation will demonstrate Acceleo features and how it is used in the context of a real MDA project. A focus will be made on traceability, which deals with synchronisation between models and generated code, one of the main concerns when moving to a model centric approach.

The demo of Acceleo includes the following topics :

• How to make high level models using UML2 or a DSL modeler based on GMF
• How to generate code massively from a PIM to a standard JEE application using Acceleo's chains
• How to design an Acceleo template and use the reflective editor to tune it
• How Acceleo can deal with iterative development process
• How model/code traceability is used to ease developers work, to ensure quality and to implement a perfect integration of the MDA approach within projects in the long run

This presentation will give the audience an illustration of how to use MDA and Acceleo with efficiency and pragmatism. It will try to bring a concrete answer to the question : how to solve the numerous challenges encountered when using a model centric approach in real projects ?

Acceleo is freely available on http://www.acceleo.org with documentation, examples and quickstart.

D5 - OSGi Component Programming

Wednesday, 14:30 - 15:00
Peter Kriens, OSGi Alliance

Eclipse vividly demonstrates the success of component oriented programming because it is based upon a large set of plug-ins that collaborate to deliver the user experience. Not so well known is that the base that enables this collaboration model is very lean, flexible, managed and standardized: It is an instance of the Service Platform as specified by the OSGi Alliance. There are over 12 certified frameworks in the market, three open source (Eclipse Equinox, Knopflerfish, and Apache Felix), and numerous private implementations. The OSGi Service Platform provides an excellent platform for extendable applications that increase flexibility and reduce maintenance cost. OSGi is being adopted in many different designs, from embedded to mobile to enterprise applications.

This demonstration will show you hands-on how to develop applications based on OSGi bundles (plug-ins are bundles). We will start with a simple "Hello World" application that highlights the modularity and life cycle features. This application is then further developed into a web based application that uses services from other bundles, as well as providing services to other bundles. We will show you what is under the covers as well as how Eclipse keeps any complexity under those covers. After this demonstration you will be able to write better, more flexible, more standalone, and more dynamic bundles that can be deployed in any OSGi service platform (Eclipse's Equinox or others).

D6 - A programming environment for the development of modular 3D biomedical image processing applications

Wednesday, 15:00 - 15:30
Alice Villéger, Julien Montagner, Jean-Yves Boire, ERIM, Faculty of Medicine, Clermont-Ferrand
Frédéric Flouvat, LIMOS, Aubière

ImageLib is a free object-oriented development environment dedicated to biomedical image processing. The software package contains a graphical MDI (kernel) to display and handle biomedical images, a programming library (C++ language) to develop new image processing components (plugins) and a rapid prototyping wizard (AutoLib), to simplify the plugin creation process.

The major interest (and originality) of these tools is to provide a framework for creating versatile, user-friendly, modular applications. Users with no programming knowledge can simply use the kernel GUI and import specific existing plugins to process biomedical images according to their needs, while users with basic C++ knowledge can quickly start to develop, test and share advanced image processing methods within the same environment. No specific object-oriented nor graphical programming skills are required.

The programming library provides all the necessary wrapping material (e.g. generic structures based on C++ templates) to develop (and/or import) any kind of image processing methods and manage advanced user interactions. User-written components such as processing functions and image read/write facilities (loaders) are compiled independently as DLLs ; at runtime, the resulting plugin objects are dynamically imported into the kernel environment, which manages all the graphical aspects of 2D/3D image handling (e.g. OpenGL). As a rapid prototyping application, AutoLib provides a simple GUI which automatically generates the appropriate base code to handle communications between a plugin DLL and the kernel interface.

Initially proposed to support the conception of image processing functions, ImageLib specifications have evolved (and are still evolving) to accommodate the needs of a growing number of various users. ImageLib is commonly used by our research team as a shared development environment. Thanks to its open, component-oriented architecture, it has also become a major collaboration tool with our research, biomedical, and industrial partners. Though initially designed to handle biomedical images, ImageLib is generic enough to be used as a framework for general image processing, be it in for research or education purpose.

Developed with Borland C++Builder 6.0 Tested under Windows 2000 and Windows XP Available for download on http://www.u-clermont1.fr/erim/

D7 - The Silver Extensible Java Compiler and Modular Language Extensions

Thursday, 13:30 - 14:00
Eric Van Wyk, Derek Bodin, Lijesh Krishnan, Phil Russell,
Department of Computer Science and Engineering, University of Minnesota

An extensible compiler can easily be extended with a collection of domain-specific language features to define an extended language that raises the level of abstraction to that of a particular problem, even when the problem crosses multiple domains. Such languages have the potential to improve the software development process and software quality by reducing the semantic gap between the programmer's high-level understanding of the problem and the relatively low-level language in which problem solutions are encoded.

In this demonstration of the Silver extensible Java compiler, we show how programmers can create new domain-adapted languages by importing a set of domain-specific language extensions into their extensible host language compiler. The attribute grammar-based extensible compiler framework supports the development of extensions that have two important characteristics. First, language extensions should be complete in that they are as well-developed as host language features and fit seamlessly into the host language. Besides defining the syntax of new language constructs, extensions also define the semantic analyses and optimizing transformations of the new constructs. One aspect of semantic analysis is error checking; extensions should report useful error messages when they are used incorrectly. Second, extensions should be modular so that a programmer can extend the Java host language compiler by selecting a set of previously defined language extensions without needing any implementation-level knowledge of the extensions. Thus we make a distinction between a domain-expert feature designer who implements a language extension and a programmer who uses it by importing it into his or her host language.

Several extensions will be demonstrated. One embeds SQL into Java so that natural syntax and compile-time syntax and type checking can be used for SQL queries. Another introduces condition tables from synchronous languages like RSML-e and SCR. These present complex boolean conditions in an easy-to-read tabular format. A third extension facilitates the writing of computational geometry programs via efficient unbounded integer types and symbolic perturbation to handle data degeneracies and improve program robustness. We also demonstrate general purpose language extensions, for example, one adds algebraic data types and pattern matching constructs similar to those in Pizza. All of these extensions are modular and can be imported together into the Java host language compiler.

All prototypes are available at http://www.melt.cs.umn.edu .

D8 - Latest News from Squeak: the Open-Source Smalltalk

Thursday, 15:00 - 15:30
Stephane Ducasse, LISTIC, University of Savoie

Squeak, http://www.squeak.org/, is an open-source Smalltalk with strong multimedia facilities. After a really brief introduction, this demo will present the latest advances in Squeak using the new version 3.9 which contains a new compiler, new browser frameworks, new package system, a service mechanism, the traits implementation. We will present also Sophie a multimedia open-source frameworks http://www.futureofthebook.org/sophie/, Seaside http://www.seaside.st/, Croquet http://www.croquet.org and Spoon a new micro kernel for Squeak http://www.netjam.org/spoon/. We will present also the latest exciting news about the license.

D9 - AJATO: an AspectJ Assessment Tool

Thursday, 16:00 - 16:30
Eduardo Figueiredo, Carlos Lucena, PUC-Rio, Computer Science Department, Rio de Janeiro
Alessandro Garcia, Lancaster University, Computing Department, InfoLab 21

Aspect-oriented (AO) software development is an emerging paradigm that provides new mechanisms to support the modularization of concerns, which otherwise would crosscut the OO system decomposition. However, the accurate identification of concerns to be aspectized is far from being trivial, and it requires a systematic design assessment and reasoning about multiple modularity principles. Even the aspectization of certain tangled and scattered concerns can negatively affect fundamental software attributes, such as coupling, cohesion, and conciseness. In this context, this demonstration presents an assessment tool, called AJATO, to support the quantitative assessment of AO software artefacts. The goals of the tool are: (i) to compute existing AO metrics, and (ii) to support the application of a heuristics suite.

Most of the AO metrics available in our tool are based on traditional metrics, such as lines of code, and on extensions of those widely used with object-oriented design, such as the Chidamber and Kemerer metrics. Besides, the metrics suite also encompasses new metrics for measuring separation of concerns. Some of the metrics available in AJATO are Concern Diffusion over Components (CDC), Number of Attributes per Concern (NOAconcern), Number of Operations per Concern (NOOconcern), Vocabulary Size (VS), Number of Attributes (NOA), and Number of Operations (NOO).

In addition to the metrics, our assessment tool also implements some heuristics rules in order to automate some modularity analysis about the numbers. For example, the set of heuristics provides contextual information on how the realization of a given concern satisfies other software engineering attributes, such as coupling, cohesion, and size. It also supports the automatic generation of warnings when certain design principles are violated. We present below some of these rules associated to separation of concerns.

R01: IF CDC / VS of CONCERN is high 
     THEN CONCERN is a HIGHLY SCATTERED CONCERN
R02: IF (NOAconcern / NOA is low) and (NOOconcern / NOO is low) for at least one component with HIGHLY SCATTERED CONCERN
     THEN HIGHLY SCATTERED CONCERN is a CROSSCUTTING CONCERN

The investigated heuristics have been derived from our long-term experience on assessing aspect-oriented design and implementation. AJATO also supports the association of application-specific thresholds with the metrics and heuristics.

D10 - Correcting a Buffer Overflow Vulnerability at Runtime with Arachne

Thursday, 16:30 - 17:00
Nicolas Loriant, Jean-Marc Menaud, OBASCO project, École des Mines de Nantes/INRIA, LINA

Arachne is an aspect-oriented system for C applications. It features a general purpose aspect language, and a runtime aspect weaver for C applications on x86/Linux architectures. Arachne has been built to pragmatically explore the advantages and drawbacks of Aspect-Oriented solutions to software evolution issues on "on production" applications. Arachne has already been applied to correct a security issue in wu-ftpd, to extend the Squid web cache with a prefetching policy and to adapt a medical image software.

This demonstration shows Arachne correcting a buffer overflow vulnerability in an echo server. While buffer overflow is a well known vulnerability, it still accounts for more than 50% of the vulnerabilities reported in open source code in 2005. During the demo, we first demonstrate how to exploit a buffer overflow vulnerability to open a remote console with root privileges. To correct the vulnerability without stopping the server, we write an aspect to replace the vulnerable code by a safe one. Finally, we use Arachne to dynamically inject that aspect into the running server without downtime nor sensible slowdown.

D11 - VERSO: a Visualization Framework for the Detection of Design Anomalies and Evolution Phenomena

Wednesday, 13:30 - 14:00
Karim Dhambri, Guillaume Langelier, Houari Sahraoui, Pierre Poulin GEODES, Université de Montréal

VERSO is a prototype to visualize large programs in order to assess and understand their quality characteristics: maintainability, robustness, reliability. This semi-automatic tool uses the expert knowledge paired with data pre-processing to better assist the expert in his analysis. It is built according to the strengths and weaknesses of human vision.

Classes are represented by 3D boxes, interfaces are represented by cylinders, and different metrics representing quality indicators can be mapped to at least three different graphical characteristics: height, color, and twist. These boxes are distributed over a 2D plane according to the architecture tree of the program. Our modified Treemap algorithm saves space and lets the user quickly understand the architecture of the program. Our intuitive navigation system helps the expert to reach the best point of view for each task.

With the help of VERSO, we have observed several anomalies or quality related phenomena that can easily be detected. At the class level, we can detect blobs, shotgun surgeries, and divergent changes among many others. At the package level, we can detect god packages and bad coupling behaviors. At the system level, we can detect commonly accepted problems such as high coupling, low cohesion, and wide and shallow inheritance trees.

In addition to static display of programs, VERSO can also visualize software evolution. A time slider allows navigating from one version to another. This principle helps saving space compared to static visualization, where everything must be displayed on the same screen. Animations between versions let the user appreciate and understand code transformations.

VERSO also allows finding anomalies or quality related phenomena specific to software evolution. For example, we can detect if a class is given too much responsibility over time and need to be refactored, or if a class was renamed. The overall aspect of the evolution also lets us see at what time a problem started, or if it was caused in a single commit.

The demo will present the framework and show some detection cases from real open source software found on the Internet.

Further Information

For further information, please contact the demo chairs Julien Cohen and Hervé Grall at demos-ecoop...please ignore this...@emn.fr