Bitter Java by Bruce A. Tate (Paperback, 339 pages); ISBN 1-930110-43-X

Reviewed by: Songmuh Jong, send e-mail
Published by: Manning Publications, go to the web site
Author's web site: go to the site
Requires: Web Server and Servlet Container
MSRP: USD$44.95/CAD$67.95

This book discusses some design patterns and their issues and solutions for Java programming. The author uses VisualAge for Java, Websphere and DB2 as his tools, but the principles can be applied to any Java project. The codes are developed with JDK 1.2.2. Some, but not all, of them have been compiled, but not tested, in JDK 1.3.1. The author uses the term "antipattern" for a flaw in design. In addition, he attempts to have a unique descriptive term for each antipattern. If you jump from one chapter to another without specific order, you might be puzzled by all the new terms. Fortunately, the book has a good index on the keywords and the pages they are described.

Before reading this book, one must understand that the author is a consultant. The writing style reflects his professional way of presenting idea and solutions. Instead of clear-cut sectioning as in other technical books, the author chooses a verbal style with small talks aiming to entertain his clients. Readers must read the book word by word to find out the hidden idea and hints. Although it adds burden to readers, keep in mind that Corporate America pays big bucks for this type of consulting. Reading this book is like having a consultant guiding you on various aspects of project design for server-side Java coding. You could save big bucks by reading this book instead of hiring a consultant. If you don't have the patience to read this book, then you have to prepare to hire a consultant with high hourly fee.

Because of the writing style, the author suggests that you glance over the entire book to get the outlines. Then go back to specific chapters as you need it. This is exactly what the readers must do. Unlike the foreword to this book says, this is not a book that you can read from cover to cover unless you are a very experienced project managers who have gone through all the server-side Java projects. Because this book discusses "antipatterns," at least half of the examples are examples of how not to code in your application. Do not blindly copy and paste the codes from this book to your projects.

The best idea begins at the chapter (3) that discusses servlets. The author points out that model-view-controller is not necessarily separated by the client/server boundary. Even the server-side codes can have view components. The same discussion extends into the next chapter (4) when it discusses JSP and coupling JSP with servlets.

Everyone knows that resource pooling is a good technique for application design. The author expands on this idea in chapter 5 and discusses cache management. Notice that cache management is usually the domain of JVM or container supplier. Even the books specialized on Servlet Programming do not say much about this aspect. This chapter is a welcome discussion for this area.

Memory Leakage is an important consideration when it comes to programming. The author pounds on this topic in chapter 6. Although JVM comes with Garbage Collection, there are still some instances where memory leaks can occur. it's nice to see a summary on a list of possibilities that will cause memory leaks.

Network connections are very expensive. The author tackles this subject and discusses connection pooling and other connection cleanup techniques in chapter 7. This chapter also includes the discussion of XML misuse and solution. XML is not discussed in a standalone chapter because the author calls it mini-antipatterns. It is not clear why XML is included in this but not another chapter.

Enterprise Java Beans represents the most complex server-side Java design. The authors discusses it in chapter 8. This is the only chapter that comes with a complete application called BBS. This is also the only chapter that the codes are not developed by the author, but provided by someone else.

The author concludes the book by looking at two aspects of general programming issues and solutions and how antipatterns can help project designs. Chapter 9 discusses programming hygiene. This chapter is not limited to Java programming, it is about bad programming practices in general, although some of the discussion is still Java-specific. Next (chapter 10) he looks at the topic of scalability and performance. Scalability is probably the most commonly mentioned and the most abused word in enterprise computing. It is not simply an issue of software design, it is also a matter of hardware distribution. The last chapter talks briefly about sweet parting thoughts and gives this book a sound conclusion.

This book should not be treated as a regular computer science book. It is a recollection of a consultant's professional career on Java programming. All the new Java programmers should read this book by finding the specific chapter that is related to the current project. It might save the projects many design flaws down the road. Experienced Java programmers and project leaders will benefit from this book by comparing notes out of experience. It might even save the need for a consultant. If you are a consultant for Java programming, this book is your baby.

Letters to the Editor are welcome and occasionally abused in public. Send e-mail to:




© Copyright 2000-2006 All rights reserved. legal notice
home | previous reviews | forums | about us | search | store | subscribe


Forums Search Home Previous Reviews About Us Store Subscribe