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 2 in Plain English
Author:
Overland&Morrison
ISBN:
0 7645 3539 0
Publisher:
M&T Books
Pages:
744pp
Price:
£15-99
Reviewer:
Victor Kirk
Subject:
java
Appeared in:
13-4
Before I dive into this book's bad points, a physical description of the book is in order. The book is split into two sections, a reference section and a tutorial section. The reference section is the largest section with just over 500 pages of the book's 700 pages. It is not intended to be a learning Java book, but as a supplement (the book's claim that it useful to veteran Java developers is just plain wrong).

Within the reference section there are 350 pages devoted to regurgitating information about the core Java API. This information can also be found in the documentation that is provided for download or viewing on Sun's web site. There is absolutely no value added here and in most cases is less detailed than Sun's documentation. In some cases (

JSpiltPane
for example), no information is given and the reader is told to actually visit the JavaSoft web site. As far I am concerned this is 350 pages wasted.

The rest of the reference is devoted to short descriptions of keywords and concepts. Unfortunately, many of these descriptions are inaccurate, ambiguous and just plain worthless. Portions of this book seem to have been written in total isolation from a compiler, never mind actual practical Java development. A good example is the treatment given to class member visibility.

Class member visibility is obviously a fundamental concept. Its poor treatment suggests that the authors have either, a poor understanding of the language, or created a list of things they should cover and crossed it off when they wrote something. When discussing the modifiers available for class variables and methods (pages 70 and 100), the book describes 'private protected', something neither I, nor my compiler have ever heard of. Member access is given poor coverage throughout the book. Appendix B gives two differing descriptions for private keyword. The class keyword section in the reference (pg. 34) mentions that Java's default visibility is not private like C++, but fails to state what the default visibility is. In fact package visibility (the default) is never explicitly mentioned anywhere in the book. Finally ALL of the code samples throughout the whole book fail to use any visibility modifiers other than public, everything else is left as default.

Other fundamental concepts given poor treatment are; inner classes, anonymous classes, events, threads and exception handling.

When talking about inner classes, they give the impression that they cannot be used outside of the class they are part of. An example is given demonstrating this, with no explanation why (and is, of course, wrong).

They completely fail to mention anonymous classes, something which is very important for practical development. Events are given a significant proportion of one of the tutorials, but this does nothing but list a few interface methods and give a short code snippet to demonstrate how to derive from an Adapter.

The thread material is dismal, anyone using this will soon have problems. Threads are discussed in the tutorial in the context of animation. Within the tutorial the use of the synchronised keyword is not even used, never mind mentioned. The reference section does not mention the possibility of synchronising on static members, or what this entails. Nor is there any mention anywhere in the book of the common problems and pitfalls associated with multithreaded applications.

The code examples throughout the reference part of the book tend to be trivial and rarely go past the process of instantiating objects. I appreciate that the book is trying to present the material in a simple manner, but if the code doesn't add anything why provide it? The code provided in the tutorial section code is generally poor and would fail most unit inspections, e.g. files are opened, but not closed.

The authors' attitude to exception handling is shocking. Catch blocks only tend to contain a single semi-colon, however they may stretch themselves and add a

println
or
stacktrace
. If exception handling obscures the issue I think a comment would be much better, otherwise readers will adopt this style in their own code.

On the whole this book is very poor and leaves much to be desired. A lot of the book leaves you wondering if the authors have actually ever used Java. I seriously doubt they have ever done any professional software development using the language. You can find a complete replacement and a whole lot more from the same place you probably picked up your compiler from,http://www.javasoft.com.