Bitter Java (Paperback)

by Bruce Tate (Author)

Editorial Reviews

Review
"!!!! Exceptional" -- Today's Books

"A superbly presented guide...an essential, core addition to the Java user's reference shelf collection." -- Wisconsin Bookwatch

"At last we have a book that tackles the problems rather than pretending there are none." -- CVu, the Journal of the ACCU

"Does a great job of articulating a philosophical foundation on which good architects and programmers can build." -- JavaPro Magazine

"It is the rare computer science book that truly captivates me....I just couldn't put Bitter Java down." -- Skip McCormick, co-author of Anti-patterns

"Packed with useful design tips and techniques for the serious Java server-side developer. . . . read it many times." -- VisualBuilder

"Save big bucks by reading this book instead of hiring a consultant." -- CompuNotes

"Will leave you with an instinctive sense for the antipatterns . . . so you can keep your Java brewing smooth and sweet." -- SitePoint Tech Times

Product Description
It is a well-known fact that most software projects fail. Drawing important lessons from failure is the goal of Bitter Java, a systematic account of common server-side Java programming mistakes, their causes and solutions. This book covers antipatterns for base Java and J2EE concepts such as Servlets, JSPs, EJBs, enterprise connection models, and scalability. It illustrates common pitfalls of Java programming through code examples and then presents re-factored code and explains why the new solutions are safe.

Written in an engaging style, this book begins each chapter with an extreme sports adventure gone wrong, and cunningly weaves the moral of the story into the discussion of Java development problems. Bitter Java begins with an overview of antipatterns and lays the foundation for server-side Java development. The author quickly builds momentum with a set of core server-side antipatterns for servlets and JSPs. He uses a bulletin board example to discuss common mistakes in basic server-side design, and iteratively refactors it until he reaches good design. By reusing this example, the author guides the reader through increasingly complex antipatterns of caching, database connections and EJBs. High-level discussions of programming hygiene and performance tuning, complete with related antipatterns, help to round out the coverage.

The intermediate developer is the intended reader of this book but developers at all levels will gain insight from the discussions of basic design patterns for Java JSP programming, round tripping, the perils of ignoring caching and connection pooling. More advanced topics such as performance tuning, EJB and XML are also included.

See all Editorial Reviews

Product Details

• Paperback: 368 pages
• Publisher: Manning Publications; illustrated edition edition (April 2002)
• Language: English
• ISBN-10: 193011043X
• ISBN-13: 978-1930110434
• Product Dimensions: 9.2 x 7.5 x 0.9 inches
• Shipping Weight: 1.3 pounds (View shipping rates and policies)
• Average Customer Review: 3.7 out of 5 stars See all reviews (43 customer reviews)
• Amazon.com Sales Rank: #839,802 in Books (See Bestsellers in Books)

Customer Reviews

Most Helpful Customer Reviews

31 of 32 people found the following review helpful:

5.0 out of 5 stars Excellent Book - Full of Java Server-side techniques, April 29, 2002

By	visualbuilder.com (USA) - See all my reviews

This book is all about learning lessons from common Java server-side development failures. It is aimed at intermediate java developers that have a basic understanding of design patterns.

Bitter Java is all about applications and examples of antipatterns and refactoring. It is about finding a problem and then going through the various solutions (continuous improvement).

We found the relationship between the first two examples ("Magic Pushbutton" and "Magic Servlet") very interesting. The author has a good method of explaining the problems to new Java developers. The first solution included the command and MVC design pattern.
It is refreshing to read a book that comments on techniques included from Jakarta Struts.

Problems addressed in this book include:
· Monolithic Servlets and JSPs
· Caching dynamic content
· Memory leaks
· Database connection overuse
· XML misuse
· EJB Round-tripping
· Entity bean misuse
· Lack of coding standard
· Performance tuning

This is one of those books that you will want to read from beginning to end. We found the many personal stories before each key topic very enjoyable to read. Web page references are used throughout the text (mostly from IBM's web site). This book is packed with useful design tips and techniques for the serious Java server-side developer. Go and buy this book because you will want to read it many times.

24 of 27 people found the following review helpful:

2.0 out of 5 stars Nice Try, but I was disappointed, April 1, 2003

By A Customer

I had high hopes for this book based on an endorsement from a friend of mine. What I found was this book, while presenting some minimally useful information was peppered with errors and generally poor.

The good points: the author is a fairly good writer, presenting technical information in a semi-interesting fashion. If you don't know what MVC is, or the Command pattern, there is some useful information here (read the caveats below).

The bad points: what good information is here is better presented in many other design patterns books. The book's information is really for junior level people and yet is so full of errors (and uncompilable code!) that it is likely to be frustrating to just such a beginner. Be prepared for coding errors such as:

public Integer i = 0;

If you don't know why this is wrong, get a well edited book. What's more, the author borrows liberally from freely available code out on the web (good) but can't even reformat the code to be consistent with his own (bad, bad, bad!). So you are treated to at least a half dozen different code formatting peculiarities during the code examples. As well, he is inconsistent about how he presents code, in some cases presenting a whole class, in other cases just a snippet without any context of how it might be employed in a class (again, a problem for the target audience).

Frankly don't get this book unless you've already tried some of the better books out there like:

Design Patterns
by Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides

or

one of the many Java design patterns books (I won't recommend one in particular, since I've only skimmed them, not read any straight through).

14 of 15 people found the following review helpful:

5.0 out of 5 stars Learn from others' mistakes, April 19, 2002

By	Juntao Yuan (Austin, TX United States) - See all my reviews (REAL NAME)

"I like learning from my mistakes ..., but I would much rather learn from your mistakes." -- Bruce Tate, "Bitter Java", page 313.

If design patterns are success stories, anti-patterns are lessons you can learn from other people's failures. Consultants like Bruce Tate make money to support his Kayak hobby by identifying anti-patterns in customer projects and offering valuable advices to refactor them. Now, he has offered his advices for all of us for [$] in Manning's new book "Bitter Java" (ISBN 193011043X).

So, what exactly are anti-patterns? Are they only relevant to software architects? Now, consider the following questions:

Do you know that Java applications might have memory leaks too? Have you written 500 line servlets or JSP pages? Do you notice that your container managed EJBs cannot scale when the load is high? If any of the answers is "yes", Java anti-patterns might be more relevant to you than you think.

This book avoids discussing anti-pattern in academic terms. Instead, it gives a real world server side Java application that an inexperienced developer is likely to write and then refactors it all the way through various anti-patterns to a scalable, maintainable solution. Tate not only teaches you the anti-patterns you encounter, he also gives a valuable example on the software development process to refactor an poorly written existing application.

The author uses extensive real world code examples throughout the book to explain the problems and why we should avoid them. Like all other Manning books, the code examples are well commented and annotated in the main text. Although the anti-pattern examples in the book are mainly in the context of J2EE application servers, the author has done a good job to generalize the problems and illustrate how they might appear in other Java applications. Anti-patterns such as memory leak, synchronized cache read/write and round tripping can have negative impacts on a big range of Java applications.

The author is very good at comparing the relative merits of different approaches, technologies and patterns. There are numerous comparison tables throughout the article and they are great resources for readers who just want a quick summary of what to do/what not to do in a given circumstance. Examples of those helpful tables include the different EJB types comparison on page 241 and the all anti-patterns listing at the end of the book.

In general it is a great book well worth the time and money for all Java developers, especially if you are working on J2EE projects. Of course, there are also things that could be improved.

1. While I liked the kayak stories, some people might find them distracting. However, those side line stories are well separated from the main content using italic fonts. So, this is really not a problem.

2. In chapter 8, I wish the author could talk more about the trade-offs between performance and code maintainability in CMP (Container Managed Perssistency) EJBs. He could also talk a bit about JDO (Java Data Objects), which is a lightweight entity bean alternative.

3. In chapter 3 and 4, the author mentioned that Jakarta Strut's "action" is essentially his "command" pattern. But since Strut is such a popular tool, it would still be nice to give examples on how to use Strut to achieve MVC model along with the "command" pattern example.