Reuse Contracts homepage

Reuse Contracts

Contents:
Last revision: February 2, 2001

This page is no longer actively maintained, if you want to know more about this topic we encourage you to contact Kim Mens or Tom Mens.

Motivation

 Reuse contracts constitute a methodology for managing reuse and evolution in object-oriented software development. They address the incremental/iterative development of reusable software components and models, and how to build highly customized applications based on these components and models. Much of the inspiration for developing reuse contracts has been drawn from the practical experience in developing object-oriented frameworks. It is a practical method. It builds on existing object-oriented analysis and design methods (in casu UML). Yet, it distinguishes itself from all other methodologies by its formal foundation and support for evolution: the way (reusable) components are reused is formally described in a contract (hence the name "reuse contract"). This forms the basis of tools for managing change and for checking the consistency between models and code. While being formal, the notation is simple enough for every day use (it can be explained in an hour).

We try to be realistic about the role of reuse in software development. With current day techniques, the investment in building reusable components seems only justifiable for systems that can be sold in a relatively broad market and that have a relatively well-known and stable problem domain (such as is the case with most generic application frameworks). For most companies, however, the goal is not to build reusable software libraries, but to provide solutions to customers more efficiently and with more quality. Therefore, reuse contracts adopt a highly evolutionary approach to the development of reusable components.

It is our experience that the importance of change and evolution are heavily under-estimated. Change and evolution are omnipresent in software development: maintenance, changing requirements, technological changes, customization, iterative and incremental development, ... However, change and evolution also hold many risks: erosion of the software architecture and documentation, proliferation of versions, change propagation, upgrade problems, merge conflicts, etc... Reuse contracts try to address some of these problems without burdening the software developer too much.

Achievements

 The research on reuse contracts can be subdivided in three partially overlapping subgroups: methodology issues, tool aspects and formal foundations.

Basic methodology

As a first validation of our ideas we started with the reuse of abstract classes through inheritance. There, a reuse contract documents the way a class is being reused by means of inheritance. The different ways a class can be subclassed is encoded by formal reuse modifiers extension, concretisation and refinement, and their inverses cancellation, abstraction and coarsening. Formal rules were defined that describe what the impact of base class exchanges are on existing applications. This problem is usually referred to as the fragile base class problem. The results from our approach in this particular case can be found in our OOPSLA paper.

As a second case we extended this basic model to incorporate also collaborations between different classes in a system. This work is described in Carine Lucas's PhD thesis.

As a third validation, we have incorporated reuse contracts in the Unified Modeling Language (UML). This enabled us to apply reuse contracts to the many different models available in the UML. Reuse contracts can be developed for all these different models without needing to change the underlying methodology.

Based on the three cases above, we were convinced that reuse contracts were general enough to be applicable to any domain of software development where evolution is important, so we decided to develop a domain-independent formalism (see below).

Formal foundations

Besides the basic methodology a lot of emphasis is put both on the formal underpinnings of the methodology. A domain-independent formal model for reuse contracts was developed by Tom Mens in his PhD thesis. The model is defined in terms of the underlying formalism of graphs and conditional graph rewriting. It is an extension of previous work, in the sense that it encompasses and generalises all previous results. The basic ideas behind this formalism are explained in our Agtive '99 paper.

Tool aspects

Various prototype tools have been developed that integrate reuse contracts in the Smalltalk Visualworks environment. These tools mainly focussed on extracting reuse contracts from existing code and using this information to understand code and assess designs.

Based on the formalism discussed before, new more sophisticated tools can be developed for detecting syntactic and semantic merge conflicts when merging parallel evolutions of the same software artifact. Other interesting results are a normalisation algorithm for removing redundancy in an arbitrary evolution sequence, and for transforming this sequence to a canonical form. As such, the reuse contract approach can contribute to the improvement of existing version control systems and software configuration management tools, and will hopefully lead to the development of next generation version control systems.

Ongoing Work

 We are currently working on extending and ameliorating reuse contracts along a number of axes.

Papers

Journals

Proceedings

Workshops

1999

1998

1997

1996

Dissertations

PhD Theses

Masters Theses

Licenciate Theses

Tech reports

Artifacts

 The main artifacts of this research project are:

Tutorials

Projects