Accepted Papers

Microprints: A Pixel-based Semantically Rich Visualization of Methods

Stéphane Ducasse, Michele Lanza, Romain Robbes

Understanding classes and methods is a key activity in object-oriented programming, since classes represent the primary abstractions from which applications are built, while methods contain the actual program logic. The main problem of this task is to quickly grasp the purpose and inner structure of a class. To achieve this goal, one must be able to overview multiple methods at once. In this paper, we present microprints, pixel-based representations of methods enriched with semantical information. We present three specialized microprints each dealing with a specific aspect we want to understand of methods: (1) state access, (2) control flow, and (3) invocation relationship.


Towards a Taxonomy of SUnit Tests

Markus Gälli, Michele Lanza, Oscar Nierstrasz

Although unit testing has gained popularity in recent years, the style and granularity of individual unit tests may vary wildly. This can make it difficult for a developer to understand which methods are tested by which tests, to what degree they are tested, what to take into account while refactoring code and tests, and to assess the value of an existing test. We have manually categorized the test base of an existing object-oriented system in order to derive a first taxonomy of unit tests. We have then developed some simple tools to semi-automatically categorize tests according to this taxonomy, and applied these tools to two case studies. As it turns out, the vast majority of unit tests focus on a single method, which should make it easier to associate tests more tightly to the methods under test. In this paper we motivate and present our taxonomy, we describe the results of our case studies, and we present our approach to semi-automatic unit test categorization.


A New Object-Oriented Model of the Gregorian Calendar

Hernán Wilkinson, Máximo Prieto, Luciano Romeo

Smalltalk-80 provides the classes Date and Time to model time domain entities. These abstractions cover the basic needs of most programs but they are not enough when complex observations about time have to be programmed. ANSI Smalltalk added the classes Duration and DateAndTime. Squeak augmented the model with the abstractions Timespan, Year, Month and Week. While the Squeak model provides abstractions to cover almost all the observations within the time domain, we argue that it lacks some abstractions and that it does not properly model the problem domain. In this paper we present a new set of classes that model entities of the time domain based on a simple metaphor. This model proved to us to be very powerful and easy to use. It allows programmers to design and program time related issues better than current implementations.


Runtime Bytecode Transformation for Smalltalk

Marcus Denker, Stéphane Ducasse, Éric Tanter

Transforming programs to alter their semantics is of wide interest, for purposes as diverse as off-the-shelf component adaptation, optimization, trace generation, and experimentation with new language features. The current wave of interest in advanced technologies for better separation of concerns, such as aspect-oriented programming, is a solid testimony of this fact. Strangely enough, almost all proposals are formulated in the context of Java, in which tool providers encounter severe restrictions due to the rigidity of the environment. This paper present ByteSurgeon, a powerful library to transform binary code in Smalltalk. ByteSurgeon takes full advantage of the flexibility of the Squeak environment to enable bytecode transformation at runtime, thereby allowing dynamic, on-the-fly modification of applications. ByteSurgeon operates on bytecode in order to cope with situation where either the source code or a full compiler is not available, while providing appropriate high-level abstractions so that users do not need to program at the bytecode level. We illustrate the use of ByteSurgeon via the implementation of method wrappers and multi-methods, and report on its efficiency.


Open Aspect

Robert Hirschfeld, Stefan Hanenberg

Open Aspects are our approach to face unplanned changes in systems that are based on aspect-oriented composition at runtime. They support explicit adaptation models, allowing developers to describe system change events to be observed, and corrective actions to be taken. These events and actions cover both the base system affected by aspects as well as the aspects affecting the base system themselves. The proper combination of change events and corrective actions allows for conditional just-in-time runtime re-composition. This paper offers a detailed discussion of difficulties related to change in aspect-oriented systems and a description of consistency constraints inherent to them. An implementation illustrating Open Aspects and their application is provided.


Co-evolving Code and Design with Intensional Views � A Case Study

Kim Mens, Andy Kellens, Frédéric Pluquet, Roel Wuyts

Intensional views and relations have been proposed as a way of actively documenting high-level structural regularities in the source code of a software system. By checking conformance of these intensional views and relations against the source code, they supposedly facilitate a variety of software maintenance and evolution tasks. In this paper, by performing a case study on three different versions of the SmallWiki application, we critically analyze in how far the model of intensional views and its current generation of tools provide support for co-evolving high-level design and source code of a software system.


Towards Unified Aspect-Oriented Programming

Noury Bouraqadi, Abdelhak Seriai, Gabriel Leblanc

Aspect-Oriented Programming (AOP) is a paradigm that aims at improving software modularization. Indeed, aspects are yet another dimension for structuring applications. The notion of aspect refers to any cross-cuting property. This definition encompasses both functional (business) and non-functional (infrastructure) properties. However, most approaches for AOP focus on only one category of aspects: either functional aspects or non-functional ones. This paper aims at bridging the gap between those two families. We present a solution for describing both functional and non-functional aspects in a uniform fashion. This solution relies on reflection and mixin-based inheritance.


Inter-Language Reflection

Kris Gybels, Roel Wuyts, Stéphane Ducasse, Maja D�Hondt

Meta programming is the act of reasoning about a computational system. For example, a program in Prolog can reason about a program written in Smalltalk. Reflection is a more powerful form of meta-programming where the same language is used to reason about, and act upon, itself in a causally connected way. Thus on the one hand we have meta-programming that allows different languages or paradigms to be used, but without causal connection, while on the other hand we have reflection that offers causal connection but only for a single language.This paper combines both and presents inter-language reflection that allows one language to reason about and change in a causally connected way another language and vice-versa. The fundamental aspects of inter-language reflection and the language symbiosis used therein, are discussed. Moreover the implementation of two symbiotic reflective languages is discussed: Agora/Java and SOUL/Smalltalk.