This book is excellent for advanced Java programmers and/or for programmers who have experience with OO-Languages.
I think this is the most extreme difference of opinion that I have had in two reviews of the same book (well ACCU members sometimes very strongly disagree with reviews published elsewhere, usually on the grounds that other reviewers do not notice the poor technical quality of a book).
Mark Kuschnir and Henrik Quintel not only disagree about much of the detail but, more importantly, about the target readership. Mark considered it possibly of some use for beginners and low intermediate programmers while Henrik recommends it for advanced Java programmers. As Mark is one of the latter group I am confused but here is what Henrik has to say:
In C Vu 11.1, November 1998, Mark Kuschnir has written a review of this book. I have read this book too and worked with it very intensively. So I have to say that I strongly disagree with the review by Mark. At the top of the article the contents are incomplete. The full contents are:
In the first chapter you get all the reasons and possibilities for distributed applications. You also find an overview of what Java offers and what it does not. The anatomy and the requirements of the development of distributed applications is also given.
The second chapter includes all about sockets, streams, URLs and
ClassLoader. For a better understanding of the main aspects like Writers and Readers these are explained by examples. The basic knowledge is given in a short but complete way.
The next chapter, 'Distributed Objects' gives you not a general overview but details for distributed objects. It is not the sense to teach you RMI but using it on distributed Java programming. There is a comparison between RMI and CORBA. The most important points that belong to the server and object problems are explained in detail. The differences between RMI and CORBA are explained in the sense of the book-title. Finally there is a well-designed example which shows a RMI example on a server.
The chapter on Threads aims to give the reader an overview of difference between normal threads and distributed threads. The author assumes that the reader is familiar with threads, therefore only the main points are mentioned. To make the main differences clear he presents one example of a simple thread and one of a distributed thread. Both examples are clear enough to be extend in your own way.
The chapter titled 'Security' provides information about the security behaviour at several points that you need to know if you want to make distributed computing safe. You get an impression of Agents. In the examples Agents are explained in considerable detail. An advantage is that you can use the example in a distributed system to use distributed objects. The encryption part is in the included example of Agents. In this way you directly see how these two items work together.
Of course there are enough protocols. But the special item in the chapter on 'Message Passing Systems' is that the presented protocol is very open. That means you can use it as you wish. In this case, as in the previous chapter, the author intent is to give an overview of how to design a new protocol or simply modify one. This is necessary if you want to distribute objects. Most protocols that are available on the WWW cannot be used for distributed objects. This is the reason that this chapter is a little bit bigger as the others. You get a very deep and close look inside a protocol for distributed systems.
In the chapter on databases the author gives his opinion. You can decide if it is good or not. It is not fair to say it is bizarre without giving any reason. Like the chapter on threads this chapter gives you an overview of the potential of remote databases and multi-database applications. The chapter contains a very clearly designed example. Because of this you very quickly understand what is going on. For people who have never heard anything about JDBC this is chapter gives a good entry point.
The most extraordinary chapter is the one on 'Bandwidth-Limited Systems.' It handles the monitoring and the management of the bandwidth resources. Monitoring bandwidth is explained by a detailed example. A second example explains raw data monitoring. That example contains the typical consumer/producer situation. In this example you can see what the role of the bandwidth management looks like. The third example is a very good one that shows the practice of an HTML Page Loader. This is explained in theory and practice.
In the chapter titled 'Collaborative Systems' you learn what a collaborative system is. This is important because the next chapter provides a description of how an application for such a system can be built. The first pages of this chapter give you an overview of the theory. After that a lot of listings follow which show the theory in practice. Finally you get a very detailed example about collaboration with RMI. This example is more for the advanced Java programmer.
The chapter on 'Building Collaborative Applications' summarises the sense the complete book. It shows an example of the building of a collaborative application. This application is a chat system. Most of you know such an application. It is used on the Internet. This chapter deeply impresses me because it uses multithreading in a very complex form. If you have really understood this example you can be sure that you also understood the complete book.
The appendix consists of:
Using the Examples in Applets Corba Services JavaSpaces Quick Reference
