An Overview of the Coyote Project

Vinny Cahill
Distributed Systems Group
Department of Computer Science
Trinity College Dublin
Email: vinny.cahill@cs.tcd.ie
WWW: http://www.dsg.cs.tcd.ie/~vjcahill


The Coyote project is investigating the use of object-orientation, computational 
reflection, and metaobject protocols (MOPs) to support dynamic customisation of 
(system) software. 

Keywords: reflection, metaobject protocol (MOP), open implementation, aspect-
oriented programming, distributed object computing, CORBA, IIOP, TMA

1. Motivation

The goal of Coyote is to provide support for the construction of (system) software that 
can be dynamically (i.e., at runtime) customised to meet changing non-functional 
requirements (e.g., to implement different performance trade-offs or support different 
levels of fault tolerance or security.) 

This kind of dynamic customisation is particularly important in the context of 
middleware such as database management systems, on-line transaction processing 
monitors, and distributed object request brokers.  These systems are characterised by 
the need to support a range of end-user applications, each with different requirements, 
simultaneously and on behalf of different users. Dynamic customisation provides a 
means of tailoring the behaviour of the system to the needs of the current mix of 
applications and users at runtime. 

One approach to achieving this kind of customisation is based on the use of 
computational reflection and, in the context of object-oriented programming, 
metaobject protocols. 

Our research is proceeding along two fronts. On the one hand, we are developing the 
Iguana reflective programming model and implementing it for both C++ and Java. On 
the other hand, we are conducting a number of case studies concerning the use of 
reflection to support dynamic customisation of distributed object systems and 
telecommunications management applications. 

2. The Iguana programming model

Iguana is a language-independent reflective programming model designed with 
support for dynamic customisation of system software as one of its main goals. Key 
features of the original Iguana model include:
- Multiple, fine-grained MOPs: objects within a single program can use different 
object models;
- Reification categories: programs can choose which object model features are to be 
reified;
- MOP declaration: Iguana defines syntax for defining MOPs consisting of meta-level 
class and reification category declarations;
- MOP selection: Iguana defines mechanisms for associating application objects with 
one or more MOPs;
For more details see [Gowing96].

Current work within the Coyote project is addressing:
- the design of a revised (and somewhat simplified) model;
- investigation of the semantics of subtyping and inheritance in the presence of 
reflection - especially when selective reification is used;
- investigation of techniques to reduce the overheads associated with supporting 
dynamic customisation - especially the use of partial evaluation and dynamic code 
generation;
- the implementation of the revised Iguana model for C++ and Java.

3. Case Studies

In parallel to the development of Iguana, we are exploring the use of reflection in a 
number of case studies designed both to identify requirements on Iguana and, 
eventually, to serve as a test-bed for evaluating Iguana technology.

3.1 Dynamic customisation of distributed object systems
Of particular interest is the use of reflection to support dynamic customisation of 
distributed object systems. In particular, we are investigating the use of reflection to 
construct an Object Request Broker that can be dynamically adapted to meet different 
application requirements. Our first step in this direction is an implementation of IIOP 
that can be dynamically configured to support disconnected operation for mobile 
computing.

3.2 Telecommunications management applications
Another area of interest is the use of reflection in telecommunications management 
applications.

3.3 Aspect-oriented programming
Finally, we are exploring the use of reflection as a means of integrating different, and 
logically orthogonal, aspects of distributed programming - distribution model, 
persistence, synchronisation, atomicity - with application code. See [Dempsey97] for 
an overview.


References
[Gowing96]  Meta-object Protocols for C++: The Iguana Approach
Brendan Gowing and Vinny Cahill
Proceedings of Reflection '96

[Dempsey97] Aspects of System Support for Distributed Computing
John Dempsey and Vinny Cahill
ECOOP '97 Workshop on Aspect-oriented Programming




--------------5C7E06F925332E800C7FBF78--