The general algorithm for collaborative computing

The cajo project is primarily focused on the creation of robust, dynamic, fault-tolerant distributed applications. It is designed to make the development of these easily possible. Below are the general concepts of how this is done:

1. Client announces for resource availability via Multicast.
2. Available listening hosts invoke client with self-reference.
3. Client requests as many resources as needed.
4. Client uses resource references.
5. Client releases all remote references.

If the multicasting option is not available, then the first two steps are as follows:

1. Client contacts one or more central resource registries.
2. Client requests references to hosts of the needed resources from the registries.

The remaining steps are the same.

In either case, clients should be prepared that any given remote resource could fail unpredictably. Clients should also be prepared to restart the lost operation with another resource.

A server resource typically provides any, or all, of three general types of functionality:

• It is a specific functional utility.
• It is a host for a client's proxy object, to offload and parallelise computing.
• It is a proxy, to provide the client with local functionality.

The final client step of releasing resources is essential. As a general paradigm; clients should assume that servers will instantiate the resource object on request, and not retain its reference locally. When the client nulls its remote reference to the resource, it can then be automatically reclaimed at the server, via the RMI DGC. (Distributed Garbage Collector)

Now, a clear, general definition of Grid and Cluster computing can be stated as follows:

Grid:	heterogeneous node hardware,	distant proximity,	short-term confederation membership.
Cluster:	homogeneous node hardware,	close proximity,	long-term confederation membership.

Note: as clear as the concepts may be; a significant portion of the community prefers to reverse the names. (I sided with Wikipedia) Irrespective; aside from the performance differences of these two architectures, the cajo project allows the functionality provided by them, to be identical.