The TAILOR Project - Concepts and Tools for Unanticipated Software Evolution

Topics

The major contribution of the TAILOR Project is improved support for Unanticipated Software Evolution on the levels of programming languages, run-time environments, and development tools.

Integration of Roles and Perspectives

The starting point of the project was the integration of two advanced object models, roles and perspectives. We have shown that it is possible to achieve that integration on the basis of two fundamental programming language features: object-based inheritance and identity-preserving object replacement

Our previous work on object-based inheritance had already shown that role models can easily be implemented by way of proper delegation. The approach is to let each role played by an object o be another object that delegates to o. Delegation ensures that during message dispatch and method execution, both o and the role object to which the message has been sent behave as a single consistent entity.

During the course of the TAILOR Project, we have examined what is missing from such a delegation model in order to be able to model perspectives as well. One of the main strengths of perspectives, as we perceive them, lies in their ability to add new properties to an existing object without affecting its identity, that is, without the need to notify existing references to that object. Nevertheless, all existing clients immediately can make use of its new "features". Therefore, this is a fruitful mechanism in the context of unanticipated software evolution.

A combination of delegation and a construct for atomic, identity-preserving object replacement allows for perusal of the respective advantages of roles and perspectives on a case-by-case basis.

Load-time Transformation of Java Classes

Another important goal of the TAILOR Project was to allow unanticipated evolution of software components, or in general, software (programs, libraries) that only exist in precompiled form. We have developed JMangler, a well-received approach for transforming Java classes just before they are loaded and linked into a running program. JMangler takes care of intercepting the class-loading mechanism of Java in a platform-independent way, and coordinates the cooperation of independently developed transformer components.

Conditional Program Transformations

The simultaneous work on load-time transformation of Java classes in the TAILOR Project, aspect-oriented programming as part of joint work with the University of Twente, and refactorings as a major topic in our software technology courses, has led to the insight that all of these fields can be based on a common notion of conditional program transformations - (program) transformations that can only be performed under certain conditions. Since then, the notion of program transformations has started to play an increasingly important role in the project. Although we are still working on an approach that integrates the various application scenarios for program transformations, we have already been able to lay important foundations: interference analysis for, and formal foundations of conditional program transformations on the conceptual level, and conditional program transformations as a basis for aspect-oriented programming languages and for refactoring tools.