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

6 – Developing and Evolving Java Applications using Coordination Contracts

João Gouveia
ATX Software

Georgios Koutsoukos
ATX Software

Michel Wermelinger
ATX Software

Luis Andrade
ATX Software

José Fiadeiro
ATX Software

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.