Java RMI

Rating:
Summary: Cluttered and Too much unwanted material
Review: 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.

Rating:
Summary: Cluttered and Too much unwanted material
Review: 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.

Rating:
Summary: Some useful information but generally disappointing
Review: 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.

Rating:
Summary: A decent introduction to RMI
Review: 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.

Rating:
Summary: Excellent RMI and distributed computing wisdom
Review: 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.

Rating:
Summary: a great book for programmers of all levels
Review: 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.

Rating:
Summary: Really nice book for distributed system developer.
Review: 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.

Rating:
Summary: Good Book on Distributed Programming in Java
Review: 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.

Rating:
Summary: too much unnecessary material
Review: 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.

Rating:
Summary: Too Many Technical Errors
Review: This is the worst O'Reilly book I ever purchased. There are two general problems: 1. The book is bloated with long-winded explanations that don't add anything to the understanding (you would think this was a Wrox book) and 2. I have found several technical errors in Chapter 10, alone.

In all fairness, Chapter 10 is the only chapter I read from front to back but there are several beginner errors in that chapter: the author says java.io.File is not Serializable and then he says arrays in Java are not serializable. There seems to have been very little technical editing. If the rest of the book is as bad as Ch. 10 this book is a dud.

I own three RMI books (soon to be two): this one, the Oberg one, and the one by Pitt & McNiff. This one is definitely the worst. I'll be putting mine up for sale soon (or dumping it in the recycle bin).