Customer Reviews

Java RMI

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

 

 

I bought this book a few days ago, and I'm satisfied with it.

If it's an introduction to RMI that you're looking for, then you will not regret your choice: the author gives a good overview of RMI and the related topics, like sockets, streams, serialization and threads. As a "side effect", sometimes this book is a bit off topic, especially during the long description of what threads are and how to use them.
I would have liked to read something more about RMI over IIOP.

It looked correct and clear in the explanation, and I must dissent from a previous reviewer:
1) the author does not write that java.io.File is not serializable, but that its serialization is not obvious and it explains why;
2) arrays are really not serializable because they do not implement the Serializable interface (just check the java API).

The book is not intended for the advanced RMI programmer: I think Java.RMI from AW (Pitt-McNiff) is more suited for this purpose.
In conclusion, not the best book about RMI, but a satisfactory introduction.

I personally have a very high opinion of the technical level
and presentation of this book. The author gives enough substance
to all RMI components as well as enough how-to information for
a typical TMI deployment. What I apperciated most however is
that it's replete with small pieces of wisdom on distributed
systems design (e.g., scalability) that were eye-opening. It
also illustrates the distributed way of thinking through teaching to ask the right question at design phase.
It's true that it talks about more than strict RMI but that's hardly a shortcoming.
The reader wanting to see onl RMI stuff will find his way by picking the right chapters (you can't miss them).
Overall, excellent technical depth, good job.

Many books on specific technologies fall into one of the following categories: a reference book (merely reformatting the javadocs), a simplistic tutorial (is there already a "RMI for Dummies"?), or a guide strictly for those already knowledgable on the subject. Java RMI is not a mere substitute for the javadoc, instead it manages to teach distributed programming (RMI is merely the platform used) and share the author's experience in this field in a way appropriate for both newcomers and old hands alike.

In the manner of a mathematician, Grosso starts from basic principles and builds one level at a time. He assumes the reader is familiar with java programming generally but assumes nothing about network or distributed programming. So, he starts by laying the foundation of streams and sockets. (Obviously, some readers may skim or skip these chapters.) With tons of example code throughout the book, in one early chapter he builds an example of a distributed application using sockets directly instead of RMI. Then, introducing RMI, he reimplements the example using RMI to demonstrate the advantages of this approach. Preferring not to depend on other sources, he also includes an excellent treatment of threading, in which even those experienced writing multi-threaded software will find useful advice, such as some of the patterns to reduce the granularity of locks needed for synchronization (as always, with explicit examples).

Throughout the book Grosso considers the example of a bank ATM machine. Going far beyond just teaching the mechanics of using RMI to write distributed software, Grosso emphasizes the questions and tradeoffs that must be addressed to design good distributed software. (Again, this is why i say the book addresses distributed programming in general, while also covering the specifics of RMI.) The ATM example is sufficiently robust to apply all the lessons.

Overall, this book is a tremendous success, managing to treat distributed programming and the details of RMI in a book appropriate for programmers of all levels. The often conversational style of the text makes for easy reading, and the wealth of example code makes the lessons very concrete. I highly recommend this book.

I agree with a previous reviewer, the book attempts to cover too many areas. Although multithreading in Java is important to understand, 100 pages on the topic seems excessive for a book on RMI. Other books such as "Java Threads" by Oaks and Wong and "Concurrent Programming in Java" by Doug Lea cover multithreaded programming clearly and in more detail.

Quite a few interesting concepts are discussed but lack detail. Just when it starts to get interesting the discussion ends. Issues like client-side caching, security, object vs native data type passing etc. could have filled up the 100 or so pages (2 chapters) that were used on threads.

For a basic but excellent intro to RMI (and other distributed concepts) see "Network Programming" by Elliotte Rusty Harold. For an excellent (and very advanced) book on RMI you cannot beat "java.rmi" by Pitt and McNiff. A detailed (probably somewhat specific) example of a distributed 3-tier database application is in "Database Programming with JDBC and Java" by George Reese (but some issues are dealt with simplistically in Reese's book).

In short, Java RMI is unfortunately lacking the usual O'Reilly quality. It discusses a number of issues regarding distributed applications and covers some interesting ideas, but lacks the required detail.

The book is well organized from the basic technology to hgh level, deep technology. If someone wants to know RMI itself, this
book will be useless. But if someone really wants to know what distributed system is and how the distributed system is implemented using RMI, this book is very helpful.

Explanation is too cluttered and a lot of material is off topic(threads, sockets,..). On the other hand topics like the newer 1.2 Activation is not covered in detail. I felt "Java.rmi" book by Esmond Pitt to be a more useful resource.

The majority of recent computer books are cut and paste jobs written by
overly perky hackers with limited communication skills; most appear to
have been hastily assembled over a few weekends from screen and code
dumps, with a smattering of text added to provide some semblance of
continuity. This book bucks that trend. Ostensibly it is a book about
RMI. However, it goes much further and provides an excellent
introduction to building distributed applications in Java using RMI as
its interface protocol. The books starts with basic distributed
programming using sockets, continues to develop its ideas using RMI, and
then progresses to more advanced topics, such as serialization,
scalability, multithreaded servers, and security policies. A lot of
nicely worked out examples are provided along the way. Highly
recommended.

I ordered it from Australia. And it arrived on time and the book looks like new.

RMI has evolved a lot from 2001, this book is rather outdated.

But I'll only comment on the serialization chapter (10).

It gives some bad advice for doing serialization (read Effective Java for that), and even has this passage, commenting on the internals of java.util.ArrayList, which is serializable, and has an internal Object[] field marked as "transient".

"But hidden in here is a huge problem: ArrayList is a generic container class whose state is stored as an array of objects. While arrays are first-class objects in Java, they aren't serializable objects."

That's the reason he thinks it is marked as transient. Well, serializing arrays worked from day 1 (depending on the element references being serializable themselves of course), and this just reveals a big misunderstandment on the author's part about the code he read. (Surely enough, an ArrayList's internal array can be far bigger than its actual contents, so it would be a bad idea to depend on default serialization for this field).

This sort of stuff just doesn't boost my trust.

This book can actually be covered in 1/5 of the pages. It is ironic that the author stated that the reader should have a certain amount of java experience, and yet he went on to cover many general java topics (e.g. serialization, threading, sockets, security etc) in great length.