Customer Reviews

JavaSpaces™ Principles, Patterns, and Practice

5 star:		(11)
4 star:		(4)
3 star:		(1)
2 star:		(2)
1 star:		(2)

 

 

This is a great introduction to the JavaSpaces technology, making it accessible to anyone with a basic understanding of Java. The main concepts are thoroughly and simply explained and the programming examples are very well developed and easy to follow. This book would be suitable for introducing undergraduates to basic operating systems concepts such as process synchronization and interprocess communication, as well as to some of the more exciting network based applications, such as distributed transactions and collaborative applications.

It's clear that JavaSpaces technology can greatly simplify the teaching of important operating system and networking concepts such as thread synchronication and interprocess communication. As someone who has taught these courses, I've found that students have a hard time dealing with system semaphore and socket primitives. Quite often the basic concepts you're trying to teach get lost within a forest of implementation details. Not so with JavaSpaces. Check out the nicely developed Dining Philosophers and Readers/Writers examples in Chapter 4. The basic semaphore class is very simple to implement in JavaSpaces, which allows the discussion to focus on synchronization issues. Ditto for the basic Channel classes developed in Chapter 5. As all of these examples show, the use of JavaSpaces technology raises the level of abstraction, thereby making distributed programming much more widely accessible. As further evidence of this, consider the ease with which a very sophisticated internet messenger service is developed in Chapter 10. Making this kind of application accessible to undergraduates is quite impressive.

This is a great book, and I will almost certainly use it the next time I teach our networking course.

Javaspaces is a promising technology for solving difficult problems relatively easily. This book does what it says, it lays out the science behind Javaspaces clearly and concisely with good use cases, patterns and suggestions. The author is very clear and the book flows very well. Upon reading the book I was champing at the bit to experiment with JavaSpaces. It really is a super read. The problem is, however, that Javaspaces is a still-emerging technology. The simplicity and clarity that is documented in the book, does not directly tie over to the actual using of Javaspaces. The current tools are raw and unwieldy, and there are many difficulties trying to actual start a java space up. <scan the javaspaces mailing lists to get a taste>. Also, the mechanism used by the author to discover a javaspace is now considered passe, destined for deprecation. The book desperately needs a section on "JavaSpaces in the real world". Wading through the current tools and resolving the myriads of problems that occur. Also a section on basic Jini discovery services would be helpful, as would an up to date 'how to find a javaspace' chapter. All in all though, I would definitely recommend reading it, just be prepared for a steep Jini/Javaspaces learning curve after reading the book.

Upon opening this book I was excited. Until I try to work with the examples and found that the examples were based on jini 1.0.
The current jini release is 1.2.1 and some of the packages are different. I guess if I knew jini and javaspaces I could modify the examples to work with the new jini version, but then I wouldn't need the book.

This is, quite simply, a stunning book. It is rare that a new technology, such as JavaSpaces is, should have such a mature book so soon after its release. No rehash of the specs this, but the full JavaSpaces programming paradigm.

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 from the [online] site 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. Do yourself a favour: get in there and let the authors gently blow you away. Your programming world won't be the same again.

If you want to create efficient distributed system with simple network programming ;-) Probably JavaSpace is one of the most efficient way to implement such system. The book is explaining such good system and some of it's implementations. There are various examples and all the book is written with a clear English language.

Many people were (including me) complaining about how to start these example programs in our computers. Now, a document is available in Java Developer Connection, that explains these steps. ).

I strongly recommend this book.

Doctors Eric Freeman and Susanne Hupfer were part of the Linda inner circle at Yale, and they know more about tuple spaces than nearly anyone. Hupfer's early graduate research focussed on a problem that looks easy but turns out to be very hard, adding multiple tuple spaces to Linda. She went on to write a thesis that centered on "Turingware," a form of Linda ensemble in which processes and people shared a single coordination framework. Hupfer is now Director of Product Development for Mirror Worlds Technologies and a Fellow of the Yale University Center for Internet Studies. Doctor Hupfer previously taught Java network programming as an Assistant Professor of Computer Science at Trinity College.

Freeman's first research project as a Yale graduate student was another avant garde tuple-spaces project in connection with the "adaptive parallelism" system called Piranha; a program that has adaptive parallelism grow and shrink as it runs. He transferred the Piranha idea to a parallel supercomputer. Freeman implemented all of Lifestreams. At one time, Lifestreams worked only on Unix workstations, so Freeman ported the system to Java to make it platform-independent. He also added encryption to the production version of Lifestreams to protect users' privacy. Lifestreams was Freeman's Ph.D. thesis. Aside from writing stinging rebuttals in the pages of the "Computer-Human Interaction Bulletin", Doctor Freeman is a co-founder and Chief Technology Officer of Mirror Worlds and co-inventor, with Gelernter, of the patent-pending Lifestreams technology. He is also a Fellow at the Yale Center for Internet studies. The company was one of only thirty companies given early access to Sun's Jini technology. The most exciting recent news is that Lifestreams has been bundled on a compact disc for the new Sun Microsystems Sun Ray 1 enterprise Internet appliance.

The JavaSpaces project at Sun Microsystems originated with Bill Joy; Ken Arnold was in charge of it and he is the lead engineer. He is responsible (along with Jim Waldo, Ann Wollrath and Bob Scheiffler) for the actual JavaSpaces design. Arnold, one of the original architects of the Jini platform, serves as the Jini Technology Community Coordinator for Sun Microsystems, Incorporated. Prior to Jini, Arnold worked with Waldo on Remote Method Invocation and object serialization team. Arnold was the main implementor of JavaSpaces.

Freeman, Hupfer, and Arnold are also also co-authors of this amazing book. This serendipitously concise, yet expressive, book teaches you how to use JavaSpaces technology to design and build distributed applications. It is intended for computer professionals, students, and Java enthusiasts - anyone who wants experience building networked applications. Through experimentation with the code examples, you'll develop a repertoire of useful techniques and patterns for creating space-based systems.

I highly recommend it!

This book is very well thought out and written in a clear and refreshingly simply style.

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.

I asked myself a key question, "Does this book repeat the infomation given from the JavaSpaces FAQ?" The answer is NO. I am glad that none of the information that is freely available over the web (FAQs, examples, text, tutorials, etc) is covered in this book. That makes the book worth buying.

I really like the overall presentation of the material of this book....It should be a textbook in many distributed computing classes. It covers many of the topics discussed in a parallel and distributed computing class (best of all, with a Java bias!) Consistent definitions of key terms make the book easier to read as well as more appealing to academia.

I also like the thorough code explanation in this text. All of the classes are explained almost line-by-line. The code throughout this book is very well explained.

I love this book! If you want to understand JavaSpaces, this book a great way to go. It explains each feature in an easy-to-read fashion and then shows off the feature in code. It also presents patterns and idioms and serves as an introduction to ways of exploiting distributed and/or parallel computing (for example, distributed arrays).

I much preferred this book to "The Jini Specification" which unfortunately wasn't quite what I was expecting from the reviews of that book. I'd say, making a comparison to O'Reilly's "Java in a Nutshell", that this JavaSpaces book is akin to the first half of the Nutshell book, and the Specification book is akin to the second, reference half.

If you want to do some JavaSpaces work then this is the book to get!

The book explains the concepts of the JavaSpaces technology in a simple manner.But at the end, I felt this book could have been trimmed a lot.There was an overkill where examples were concerned.There were a lot of repetitions in the book with the same concepts being emphaisized again and again.The same stuff could have been explained in fewer pages.But again, its better that a book goes for more examples than no examples at all!! And also we could have done with a few tips on how exactly to run the program.The book contains all the code to write a JavaSpaces application, but does not give you any insight at all as to how you actually run the application.For e.g could have had a couple of pages on how to start a Space from the command line , which lookup service to use and why(Jini lookup service or the rmiregistry),how to start a lookup service, the requirement of having a policy file and so on. I had a really tough time figuring out these things.But otherwise, if you want to learn about JavaSpaces and what it is all about, its a good book to refer to.