by Bruce A. Tate (Paperback, 339 pages);
to the web site
web site: go
to the site
Server and Servlet Container
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.
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.
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.
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.
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.
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.
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.
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.
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.
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
to the Editor are welcome and occasionally abused in public.
Send e-mail to: firstname.lastname@example.org