Reuse Contracts homepage
|
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.
- Based on the reuse contract methodology, we are also working on a number of
practical tools. We aim to provide a complete development environment supported by
reuse contracts, including version control, extraction of reuse contracts from existing code,
detection and resolution of merge conflicts and upgrade conflicts,
checking compliance of code to reuse contracts, assisting in impact analysis and effort
estimation, metrics and heuristics, ...
- We are also looking at how reuse contracts can be useful in different
phases of the software life cycle. Until now we mainly focussed on applying the
methodology to the design and implementation phases, but we are convinced that it can
also be applied to OOA, help with refactoring and versioning, form the basis of an
effort estimation method, ... More specifically we are currently looking at quality metrics.
- Reuse contracts can even provide help for co-evolution, to keep models
in different phases in sync with each other. Currently, we are trying to find out how
the reuse contracts approach needs to be extended in order to cope with this additional
complexity of needing to deal with different models simultaneously.
Papers
Journals
Proceedings
- Conditional Graph Rewriting as a Domain-independent formalism for software evolution. Agtive '99 Proceedings: Applications of graph transformations with industrial relevance. LNCS, Springer-Verlag, 2000.
-
Supporting Disciplined Reuse and Evolution of UML Models.
A paper about
applying reuse contracts to UML collaboration diagrams, published in Selected Papers
of the Proceedings of the First International Workshop UML'98: Beyond the Notation.
LNCS 1618, Springer-Verlag, 1999.
-
Managing software evolution through reuse contracts. First EUROMICRO Working Conference On
Software Maintenance and Reengineering at the Fraunhofer ISST, Berlin, GERMANY, March 17-19, 1997.
-
Reuse Contracts: Managing the Evolution of Reusable Assets. First paper
on reuse contracts , published in the proceedings of OOPSLA'96.
-
PSI: From custom developed application to domain specific framework.
An experience report of one of our industrial partners in the addendum to
the Proceedings of OOPSLA '96.
Workshops
1999
1998
1997
1996
Dissertations
PhD Theses
- Tom Mens, A Formal Foundation for Object-Oriented Software Evolution,
PhD Thesis,
Department of Computer Science, Vrije Universiteit Brussel, 1999.
- Koen De Hondt, A Novel Approach to Architectural Recovery in Evolving
Object-Oriented Systems, PhD Thesis, Department of Computer Science,
Vrije Universiteit Brussel, 1998.
- Carine Lucas, Documenting Reuse and Evolution with Reuse Contracts,
PhD Thesis, Department of Computer Science, Vrije Universiteit Brussel, 1997.
Masters Theses
- Veronica Arganaraz, Definition and Validation of Statically Typed Reuse Contracts
, Masters Thesis, Vrije Universiteit Brussel, 1999.
- Natalia Romero, Managing Evolution of Software Architectures with Reuse Contracts
, Masters Thesis, Vrije Universiteit Brussel, 1999.
Licenciate Theses
- Gerrit Cornelis, Reuse Contracts as a Modular System in Statically Typed
Object-Oriented Languages, Licenciate Thesis, Department of Computer
Science, Vrije Universiteit Brussel, 1997.
Tech reports
- Incremental Design of Layered State Diagrams. An outdated
technical report applying the ideas of reuse contracts to nested state-transition diagrams (statecharts).
Artifacts
The main artifacts of this research project are:
- (1996) An extractor
for Smalltalk, that derives the reuse contracts for existing classes and
decomposes the inheritance links in our basic reuse modifiers.
Note: This is an old version of the extractor included in the Reuse Contract Tools mentioned in the next item.
- (1997) An old and unsupported version of the Reuse Contract Tools is available and its free!
Smalltalk VisualWorks 2.5 (with advanced tools installed) is required.
Fetch the file outs of the Reuse Contract Tools from our download directory.
- (1997) As related work we have been working on framework
development tools for supporting reuse contracts in Smalltalk.
- (1999) A (currently outdated) implementation of a domain-independent reuse contract tool was implemented in PROLOG.
Tutorials
- Powerpoint slides about reuse contracts given by Tom Mens during the course object-oriented software evolution for the European Masters in Object-Oriented Software Engineering (EMOOSE 2000-2001) in January 2001
- Powerpoint slides about reuse contracts given by Tom Mens for the European Masters in Object-Oriented Software Engineering (EMOOSE 1999-2000) in February 2000:
- In the context of IPAVUB (Instituut voor Post-Academische Vorming),
a Dutch course on "Object-Oriented Software Development in Practice" was taught during the academic year 1999-2000.
At the end of the course, reuse contracts were advocated as a technique for managing reuse and evolution of software components.
- ESUG
Smalltalk Summer School 1997. Tutorial
"Reuse Contracts as a Basis for Investigating Reusability of Smalltalk Code"
by Koen De Hondt.
Projects
- A research project called "Compliance Checking in Object-Oriented Systems", funded by the Brussel's Capital Region
(Brussels Hoofdstedelijk Gewest) and Wang Global, was conducted from January 1999 to December 2000.
The topic of this project was co-evolution of object-oriented software design and implementation.
In particular, the project investigated how the reuse contract approach
could be extended to deal with evolution of software artifacts belonging to different phases of the software life-cycle.
In addition, an industrial strength case study assessed the feasibility of the reuse contract approach on a large-scale software project.
- Work on
framework development tools for Smalltalk has been carried out in co-operation with MediaGeniX in the context of a research project, sponsored by the IWT
(Flemish Institute for the Promotion of Scientific-Technological Research in Industry)
and called "Software engineering Methodologieen en Generische Werktuigen voor
Domeinspecifieke Objectgerichte Frameworks"
- Patrick Steyaert worked on a post-doc project called "Reuse Contracts:
Towards an Object-Oriented Methodology for Systematic Reuse and Evolutionary Development".
It was funded by the IWT (Flemish Institute for the Promotion of
Scientific-Technological Research in Industry).
The industrial partners are EDS and MediaGeniX.