- Paperback: 368 pages
- Publisher: Addison-Wesley Professional (June 25, 1999)
- Language: English
- ISBN-10: 0201309556
- ISBN-13: 978-0201309553
- Product Dimensions: 7.5 x 0.9 x 9.2 inches
- Shipping Weight: 1.2 pounds (View shipping rates and policies)
- Average Customer Review: 3.4 out of 5 stars See all reviews (19 customer reviews)
- Amazon Best Sellers Rank: #3,339,846 in Books (See Top 100 in Books)
Enter your mobile number or email address below and we'll send you a link to download the free Kindle App. Then you can start reading Kindle books on your smartphone, tablet, or computer - no Kindle device required.
To get the free app, enter your mobile phone number.
JavaSpaces¿ Principles, Patterns, and Practice
Use the Amazon App to scan ISBNs and compare prices.
JavaSpaces Principles, Patterns, and Practice delivers an exciting introduction to the world of distributed, high-performance computing on Java's Jini platform using the new JavaSpaces API. Written for academic and business developers, this guide will help you begin using the Jini platform by outlining its powerful, elegant solutions for distributed computing.
After a foreword by distributed computing pioneer David Gelernter, the book provides a short technology overview describing the makeup of JavaSpaces. The authors atomize their description of JavaSpaces as an overseer application that lets programs running on separate computers store and share persistent data. While the JavaSpaces API is by itself remarkably simple, this book demonstrates with deliberate fanfare the resolution of common distributed computing problems using complex design patterns.
Early sections look at the basics of reading, writing, and searching for data stored in JavaSpaces as well as presenting task and result bags as solutions to managing work done in parallel. The book also elaborates on the readers/writers problem, well-known within the field of computer science, and even offers a means of addressing it. The authors use code samples from a chat message server and a model of a paging system using message channels during their discussion of message passing and communication with JavaSpaces.
One section on distributed patterns presents some common solutions to doing work in parallel, including the Marketplace pattern, illustrated with an e-commerce bidding application. Further sections cover distributed events and transactions as they apply to JavaSpaces. The book closes with two excellent examples, one for a distributed messaging service and another for a brute force attack on encrypted passwords.
With the debut of JavaSpaces, business developers gain access to distributed processing previously available only to academic researchers. The JavaSpaces solution, along with JavaSpaces Principles, Patterns, and Practice, will let any Java developer audition distributed computing for the first time. --Richard Dragan
"I am very impressed with this book. It's well written, with easy to understand and well-explained code examples. It shows with its many examples how JavaSpaces can be used to simplify the design of solutions to problems common to many distributed applications. It also covers Jini's programming model. I would recommend this book to anyone who is planning to use JavaSpaces, but also to anyone who is starting out doing distributed systems in general." -- artima.com - a resource for Java and Jini Developers
If you are a seller for this product, would you like to suggest updates through seller support?
Top Customer Reviews
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.
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.
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.
Most Recent Customer Reviews
The current jini release is 1.2.Read more
A very clear and exciting book.Read more