Javaspaces: Principles, Patterns and Practices (Java Series) (Paperback)

Java Spaces is a clarification, a distillation of many years of research which will form the underpinning of a way of thinking about distributed systems that will be novel to many readers. The simple concepts found in the Java Spaces model are explained by the use of example Java code accompanied by clear descriptions of the code examples in the text.

Like the technology itself this book is a clarification of the issues, not simply a list of features or re-statements of the API's. The authors work hard to present the information in a well ordered and coherent way. The result ... a great book about a new technology that is informative and moreover enjoyable to read.

This is only possible because JavaSpaces is not completely new, but Sun's object oriented evolution of Tuple Spaces developed at Yale University by David Gelerntner. The two lead authors are long standing members of the Yale Linda/Spaces team and worked with all the pre-release versions of JavaSpaces. The third author was responsible for the Sun JavaSpaces implementation and now for Jini and the Jini Community. Their collective experience shines through. From a teaching point of view, it has the feeling of having been honed over many iterations, and from a conceptual viewpoint, the techniques, the patterns, and the way of thinking they introduce can only be the result a long process of elaboration and refinement.

Everything is said with clarity and simplicity. As a reader, you are taken from ground level, one step at a time, with no sudden leaps, or steps left out, until, almost without noticing it, you look down and realise you are flying with the dining philosophers and being presented with a simple solution to their problem. And it goes on from there. All the Java examples are likewise simple, clear and easy to follow, although you do have to read and think about them.

The themes are developed consistently and build on earlier ones. Initially, distributed data structures, synchronisation and communication techniques using JavaSpaces are set out, the last two building on the first. With this core subset, a variety of patterns for using JavaSpaces are explored which show much of its potential. It goes on to look at the new features introduced by Sun, namely leasing, distributed events and transactions which can simplify programming and increase robustness in the face of partial failures. Experience with using these new additions to the Linda paradigm are likely to result in new patterns emerging and the authors invite readers to engage in and share in their development through the book's Web pages and Forum. Finally, all the techniques are pulled together in two more elaborated examples of a distributed collaboration program and a parallel processing program. These examples are worth understanding fully as you will then be ready to go out and startle yourself and the world with what you can now do with JavaSpaces.

Further evidence of the authors' conciseness is that, although a very complete treatment, it is not one of those monster doorstop computer books, but small enough to give you the feeling that you might actually read it all - and once you get started into it, my guess is that you very likely will: it intrigues and challenges you in a way that makes it easy to read and leads you on. As someone else said: It's a bit like a detective novel, and just as you are beginning to shout "but where does this fit in?", you turn the page and they give you the answer.

The book makes the hitherto difficult and arcane world of distributed and parallel programming accessible to anyone with basic Java programming under their belt, and significantly lowers the bar on introducing these topics at undergraduate level.

The ease with which it can be programmed will be where JavaSpaces succeeds in the real world where other similar approaches fail. In the world of computer science research it may not be anything very new, but it is aimed squarely at making the fruits of this work accessible to programmers with problems to solve, and imaginations to let loose, and who just want the means to their ends to be as simple as possible.

If there's a complaint to make of this book, it might be that they do not include an appendix on how to get Sun's free implementation of JavaSpaces up and running. Almost everyone who downloads Jini and JavaSpaces seems to go through an initial struggle (or was that an initiation struggle?) doing this. However, a member of the Jini Community is addressing this issue and a free tool to simplify the start up process will hopefully be available by the end of this year. In the meantime some pointers on the book's web site would be useful (and a better place than the book for information on what should be a transient problem). Right now, the Core Jini book is probably the best resource to turn to for help on this.

I strongly recommend the JavaSpaces book to any sequential programmer who wishes or needs to get to grips with distributed and parallel programming. JavaSpaces, the technology and the book, are the handle and the key that open the door to the world of distributed and parallel programming which, as the book's blurb says, will power the next generation of Internet applications. As they say in the US, do yourself a favour: get in there and let the authors gently blow you away. Your programming world won't be the same again.