Adaptive (that is, self-healing and self-managing) code development is addressed in this short book. The domain focuses on distributed programming, and the scope is the introduction of a new aspect language, which for the first time comprises an option for custom-written error-handling code.
The work is the dressing for broader publication of a doctoral dissertation, and maintains the unquestionable research-oriented character of its origin. It is nevertheless broadly accessible, and wildly captivating for anyone with at least a modest interest in the subject.
The first half is a technical review of the existing general-purpose mechanisms of distributed programming. It covers the origins with Unix sockets, and proceeds through later initiatives to abstract away from the gritty details with remote procedure calls (Sun or Distributed Computing Environment (DCE) flavors), additional further efforts in that direction such as CORBA, the introduction of Java Remote Method Invocation (RMI), and recent middleware standards to facilitate publish/subscribe or point-to-point messaging.
The review comprises simple examples of each mechanism to provide the reader with an impression of each technique as actual code. Of course, the examples are, by necessity, snippets, yet they effectively illustrate practical complexity. The review includes more than a cursory mention of the debate pitting the advocates of abstraction and transparency (who say that distributed code should look like any other nondistributed code) against the advocates of distribution awareness (who say that fundamental differences in at least latency, bandwidth, memory access, failure, concurrency, security, and synchronization should not be papered over with syntactic sugar).
In the second part of this work, the discussion shifts to the programming technique of aspects, the description and mechanics of aspects in Java, the existing implementations, and aspects as a tool for addressing the distribution concern. This latter subject includes a review of a few existing systems; from the information presented, it does not appear that this specialized and young field has presented any research work that encompasses the overwhelmingly complex area of error recovery in a distributed environment.
This is the niche that RemoteJ intends to fill. RemoteJ is an experimental multi-protocol distributed application development toolkit grafted on the Java programming language. It was created as part of this doctoral work to introduce aspect programming for the distribution concern with a provision for error recovery. My modest attempts to procure the toolkit and experiment with it were unfortunately frustrated; the following is based solely on the printed material.
The distribution definition language of RemoteJ aims to identify join points and define pointcuts for the application of advice. It is presented with a relatively simple Backus-Naur syntax, and gives examples that are suitable for a proof-of-concept implementation. Broader application will verify whether the distribution definition language of RemoteJ is adequate to cover the breadth of applications in distributed programming.
The outstanding virtues of RemoteJ are its built-in, plugin-based extensibility to any suitable distributed protocol, and its provision for custom error recovery. The proof-of-concept includes protocol implementation examples for RMI, RESTful hypertext transfer protocol (HTTP), and the Java Message Service (JMS) (point-to-point only). It would be very interesting to assess how flexible the plug-in architecture indeed can be with regard to protocol support. Error recovery includes a few out-of-the-box machine-generated scenarios, and may support arbitrary user-defined recovery routines. Leaving “self-healing” largely as a user exercise may arguably fall short of the autonomic goal, yet in this scope, the bar is impossibly high. Even so, the availability of an error recovery architecture is a giant step in the direction of creating a production-grade toolkit.
The overall promise of RemoteJ is exciting. A few shortfalls may keep this work in the research arena. For example, there is no support when a server is in turn a client of another server. Perhaps its hypothetical growth into a full-fledged open-source offering may provide a path to a bright future for this toolkit.
