OOPSLA 2002


Tracks
Technical Program
Tutorials
Workshops
DesignFest
Educators' Symposium
Doctoral Symposium
Demonstrations
Posters
Student Research
Competition

Student Volunteers
Special Events
Exhibits
Housing Information
Registration Information
Transportation

Wednesday 12:00-12:45 – Convention Ctr - Exhibit Hall 4A

6 Developing and Evolving Java Applications using Coordination Contracts

João Gouveia
ATX Software, jgouveia@atxsoftware.com
Georgios Koutsoukos
ATX Software, gkoutsoukos@atxsoftware.com
Michel Wermelinger
ATX Software, mwermelinger@atxsoftware.com
Luis Andrade
ATX Software, landrade@atxsoftware.com
José Fiadeiro
ATX Software, jose@fiadeiro.org

Coordination contracts are a modelling primitive, based on methodological and mathematical principles, that facilitates the evolution of software systems. Coordination contracts capture the business rules that govern interactions between components. System evolution consists in adding and removing contracts (i.e., changing the business rules) between given components (the participants of the contract). As a result of an addition, the interactions specified by the contract are superposed on the functionalities provided by the participants without having to modify the computations that implement them. In fact, the components are completely unaware they are being coordinated. The contracts specify a set of rules, each with a triggering condition (e.g., a call to a method of one participant), and a rule body stating what to do in that case. Contracts are also unaware of the existence of other contracts. This facilitates enormously incremental system evolution, because explicit dependencies between the different parts of the system are kept to a minimum, and new contracts can be defined and added to the system at any time (even run-time), thus coping with changes that were not predicted at system design time.

The Coordination Development Environment (CDE) we built helps programmers to develop Java applications using coordination contracts. It allows to write contracts, to translate them into Java, and to register Java classes (components) for coordination. The code for adapting those components and for implementing the contract semantics is generated based on a micro-architecture that is based on the Proxy and Chain of Responsibility design patterns. The CDE also includes an animation tool, with some reconfiguration capabilities, in which the run-time behaviour of contracts and their participants can be observed using sequence diagrams, thus allowing testing of the deployed application.