Among the most significant developments of recent years has been the wide-spread acceptance of cluster computing: A collection of independent server nodes that collectively share the processing load of an application. While an attractive alternative to expensive high-performance servers, clusters present the challenge of distributing an application load on cluster nodes and then coordinating work among the nodes.

The Java Parallel Processing Framework is an open-source toolkit that helps construct cluster-based Java applications. Still at a nascent stage, JPPF recently released version 0.12.0 of their tools:

Java Parallel Processing Framework is a set of tools and APIs to facilitate the parallelization of CPU intensive applications, and distribute their execution over a network of heterogenous nodes. It is intended to run in clusters and grids.

It provides:

• An API to delegate the processing of parallelized tasks to local and remote execution services
• A set of APIs and user interface tools to administrate and monitor the server
• Asynchronous communication model to support a high level of concurrency
• Scalability up to an arbitrary number of processing nodes
• Built-in failover and recovery for all components of the framework (clients, server and nodes)
• Limited intrusiveness for existing or legacy code
• The framework is deployment-free: no need to install your application code on a server, just connect to the server and any new code is automatically taken into account
• Fully documented APIs, administration guide and developer guide
• Runs on any platform supporting Java 2 Platform Standard Edition 5.0 (J2SE 1.5) or later

Note that many of the project's features are also provided by Jini and JavaSpaces. For instance, Jini supports code mobility, and JavaSpaces provides an asynchronous communication model. A recent white paper on grid computing with Jini and JavaSpaces explains Jini features that allow you to easily construct a compute grid.

What do you think about the JPPF project's aims? Compute grids are cheap and easy to build, but many developers still don't consider using them to solve compute-intensive problems. Have you encountered a situation where a compute grid could have been useful? Have you used one?