ACCU Home page ACCU Conference Page
Search Contact us ACCU at Flickr ACCU at GitHib ACCU at Google+ ACCU at Facebook ACCU at Linked-in ACCU at Twitter Skip Navigation

Search in Book Reviews

The ACCU passes on review copies of computer books to its members for them to review. The result is a large, high quality collection of book reviews by programmers, for programmers. Currently there are 1918 reviews in the database and more every month.
Search is a simple string search in either book title or book author. The full text search is a search of the text of the review.
    View all alphabetically
Title:
Java Distributed Computing
Author:
Jim Farley
ISBN:
1 56592 206 9
Publisher:
O'Reilly
Pages:
368pp
Price:
$ 32.95
Reviewer:
Henrik Quintel
Subject:
java; networks; CORBA and COM
Appeared in:
11-2
Francis Glassborow writes: As you know it is the policy of ACCU to ensure that anyone who strongly disagrees with a review will have their alternative published. I have taken the liberty of doing a substantial sub- edit of the following because Henrik is not a native English writer. I hope that I have not distorted his views in correcting his English (which is very much better than my German).

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:

<snipped>, as a rule we do not publish content lists. Mark only listed some (his words were: Its main chapters include the following) - Francis Glassborow

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

Summary

This book is excellent for advanced Java programmers and/or for programmers who have experience with OO-Languages. It is also necessary to know the fundamentals of distributed computing. You get an impression of all the factors that are necessary to build a distributed application. The various chapters cover everything for doing that.