Sign in to turn on 1-Click ordering.
More Buying Choices
Have one to sell? Sell yours here
Sorry, this item is not available in
Image not available for
Image not available

Tell the Publisher!
Id like to read this book on Kindle

Don't have a Kindle? Get your Kindle here, or download a FREE Kindle Reading App.

Bitter Java [Paperback]

4.0 out of 5 stars  See all reviews (3 customer reviews)
RRP: 40.50
Price: 27.28 & FREE Delivery in the UK. Details
You Save: 13.22 (33%)
o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o
Only 1 left in stock (more on the way).
Dispatched from and sold by Amazon. Gift-wrap available.
Want it Thursday, 4 Sept.? Choose Express delivery at checkout. Details

Book Description

5 April 2002 193011043X 978-1930110434 1

Bitter Java is a book about common Java programming traps (called anti-patterns), their causes and resolutions. Anti-patterns for server side Java programming and architecture are the focus. It is intended for intermediate Java programmers, analysts and architects. The book covers anti-patterns for J2EE concepts such as servlets, JSPs, EJBs, enterprise connection models, and scalability.

There is a popular movement to capture positive design patterns, and an extensive library of design pattern books. Negative designs, sometimes called anti-patterns, are harder to find, but illustrate good programming practices much more graphically than design patterns. Anti-patterns have another benefit: they are fun.

Bitter Java will explore some basic anti-patterns and introduce intermediate to advanced techniques in clear and entertaining language. The book will feature code samples sprinkled throughout the book, and real-life metaphors that are unrelated to programming. The examples are refactored into solutions that work, and are available on a web site for immediate download and use.

Product details

  • Paperback: 339 pages
  • Publisher: Manning Publications; 1 edition (5 April 2002)
  • Language: English
  • ISBN-10: 193011043X
  • ISBN-13: 978-1930110434
  • Product Dimensions: 23.4 x 19 x 2.3 cm
  • Average Customer Review: 4.0 out of 5 stars  See all reviews (3 customer reviews)
  • Amazon Bestsellers Rank: 1,193,848 in Books (See Top 100 in Books)
  • See Complete Table of Contents

More About the Author

Discover books, learn about writers, and more.

Product Description

Amazon Review

A study of Java antipatterns, Bitter Java combines rare readability with strong technical content. It is aimed at beginning to intermediate programmers, and identifies common problems, or antipatterns, which cause server-side Java applications to fail or perform badly. Despite their Java focus, many of the tips apply equally to any language or platform. This is no surprise, since one of the author's themes is that programmers bring previous bad habits into Java development and discover that despite its advantages it is by no means a cure-all. There is even a chapter on Java memory leaks, including a technical discussion of how garbage collection works. Even so Bitter Java is not a negative book. Rather than just pointing out pitfalls it presents a solution for each antipattern. The idea is to learn from the mistakes of others, always an appealing prospect. The author is ex-IBM and packs in plenty of real-world experiences, and spices the text with anecdotes from his kayaking adventures.

An example Internet bulletin board application provides a unifying theme for the book. Topics covered include Servlet and JSP design, JDBC database programming, use of the model-view-controller pattern, enhancing performance with caching and connection pooling, appropriate use of EJBs, and improving the development process. Some of the solutions are simply common sense, while other recurrent themes are refactoring, searching for suitable design patterns, extreme programming, and applying sound coding standards. The author comes over as a tiny bit smug on occasion, but with this excellent set of tips and insights, perhaps he has good reason. --Tim Anderson


"... a great book well worth the time and money for all Java developers." -- -- Michael Yuan, Research Associate,

"...an excellent book about ensuring that your Java projects succeed." -- -- Tracy Pope, Senior Architect, Neoris USA and VP, Forth Worth JUG

"...if you are or aspire to be a Java professional, this could easily become one of the most valuable books in your Java library." Guide Rating ***** -- -- Will Wagers, Focus On Java Guide, About.com

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

"If you're a hired codeslinger creating
J2EE applications or servlets, then this is a good book for your shelf." -- -- Peter Wayner, Slashdot.org reviewer

Sell a Digital Version of This Book in the Kindle Store

If you are a publisher or author and hold the digital rights to a book, you can sell a digital version of it in our Kindle Store. Learn more

What Other Items Do Customers Buy After Viewing This Item?

Customer Reviews

5 star
3 star
2 star
1 star
4.0 out of 5 stars
4.0 out of 5 stars
Most Helpful Customer Reviews
8 of 8 people found the following review helpful
Worthy addition to a Server-Side Java Developer's library
This is a pretty different title compared to most of the other Server-Side Java books out there. Instead of focussing on the APIs that make up the J2EE beast, this book instead concentrates on common design problems and their solutions in your server side applications. And it does a pretty good job of it as well, with something for everybody, except perhaps the experienced J2EE architect.
For the rest of us, this is near-compulsory reading and not just because of the cool extreme sports analogies ;-) The approach of showing how and why something stinks and then demonstrating the solution is arguably the best way to teach, and Bruce leverages this approach very effectively indeed.
I strongly recommend this to any junior to intermediate server-side Java developer who is interested in honing his craft.
Comment | 
Was this review helpful to you?
6 of 6 people found the following review helpful
4.0 out of 5 stars More palitable format for old content 5 July 2002
This is a very well written book which approaches the topic of software patterns from what originally seems like a different approach (anti patterns) but is essentially just another java patterns book.
If you are not yet into software patterns then this is probably the best book to start with of those currently available but for a 2002 and two book it is not the most up to date (No EJB 2.0 ). I think everyone who has the option to move on from EJB 1.1 is doing so, so this is an important issue.
If you already own a book like "Core J2EE patterns" and have understood it then I doubt you will get much out of the book apart from advice on how to kayak Americas most dangerous water.
Probably the books strongest point is that it makes patterns easier for people to accept by using the authors actual experience with real examples of java pitfalls. Often pattern books try to be so generic and abstract that they struggle to get their message across as quickly as they should...
If you are looking for a book to tackle EJB2.0 issues I recommmend "EJB Design Patterns ~Floyd Marinescu" although you will not find it as easy to read.
Comment | 
Was this review helpful to you?
4.0 out of 5 stars I wish I had this book a few years ago 28 Aug 2008
Bitter Java - by Bruce Tate / Manning

A few years ago when I first read "Refactoring: Improving the Design of Existing Code" by Martin Fowler & Kent Beck I realized how many mistakes I have made in my projects.
Now reading "Bitter Java" by Bruce Tate I am somehow in the same situation:
I wish I had this book a few years ago.

The book is really full of antipatterns and ways to avoid them. Understanding antipatterns will help software developers prevent and recover from situations like spaghetti codes or ineffective algorithms to name only some of them.

The focus of this book is Java antipatterns and how to eliminate or reduce them.
The book has 3 parts and 11 chapters, a detailed table of contents, also a detailed index and, as a plus, a bibliography for additional resources. The book contains also examples of Java code that address specific issues in corresponding contents.

In my opinion the book is addressed to intermediate Java programmers or advanced programmers which know Java very well but they develop without a clear set of patterns in mind so they might identify here a lot of common mistakes (antipatterns).

As I said, it has 3 parts.
The first one is about design patterns, antipatterns, and about the Internet standards /technologies used in server-side Java. Part 2 covers the most largely chapters of the book and provides detailed antipatterns in Java programming: about servlet antipatterns , MVC antipatterns, JSP antipatterns , cache management (why use cache, how to use a cache, problems/solutions, synchronizing the cache),
memories issues (memory leaks, lapsed listener leaks, problems/solutions)
and also a very interesting example of an antipattern for String manipulation and for Collections .
Read more ›
Comment | 
Was this review helpful to you?
Most Helpful Customer Reviews on Amazon.com (beta)
Amazon.com: 3.7 out of 5 stars  42 reviews
31 of 32 people found the following review helpful
5.0 out of 5 stars Excellent Book - Full of Java Server-side techniques 29 April 2002
By visualbuilder.com - Published on Amazon.com
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.
15 of 16 people found the following review helpful
5.0 out of 5 stars Learn from others' mistakes 20 April 2002
By Juntao Yuan - Published on Amazon.com
"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.
30 of 36 people found the following review helpful
2.0 out of 5 stars Nice Try, but I was disappointed 1 April 2003
By A Customer - Published on Amazon.com
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
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).
9 of 9 people found the following review helpful
5.0 out of 5 stars Antipatterns are dead! Long live Antipatterns! 20 May 2002
By Todd Vaules - Published on Amazon.com
This is one of the few programming books on the market that is almost impossible to put down. Bruce Tate's ability to combine his passion for extreme sports with real life programming experience makes for a very interesting read. But don't think that means he puffed up this work with superfluous prose. This book is the real deal and packs more learning into it's 399 pages than most of the 800+ page technical tomes on the market.
The basic premise of the book is to define and describe anitpatterns. The author uses antipatterns as a force for good as wells as pointing out their inherent evil. Through the recognition and understanding of antipatterns the developer can learn the hows and whys of sound development process and program architecture.
Whether you are a seasoned developer or relatively new to programming, this book has something for you. The experienced developer will recognize many of the anitpatterns discussed in this book (though may not have known they had been named and categorized). The new developer will learn some very important concepts and situations to avoid.
Bruce's step-by-step refactoring of code will be a real eye-opener for a lot of folks in the Java community. This is some of the most straight forward architectural and procedure based instruction ever put to page. Yes, at times it may seem overly simplistic, but guess what?, that's what it's all about. The essence of good design lies in its simplicity. If you read through all of the examples, in the end you come out well on your way to becoming an architectural master (ok maybe overstated, but you will feel that way).
The book covers all the major components in an enterprise level application. You will get some for valuable tips on such things as MVC, cache management, connection pooling, and scalibility. Whether you are a web developer or a senior level enterprise programmer, there is something for you. This book should be required reading in every development shop and CS department!
19 of 22 people found the following review helpful
5.0 out of 5 stars A great collection of lessons learned the hard way 22 April 2002
By Clyde Adley - Published on Amazon.com
While reading this book, I kept referring colleages past and present to information within as questions about "how should I..." popped up. It's an excellent set of reminders about lessons learned, and old lessons applied to current technology.
The content is very accessible to the intermediate programmer and budding architect, and the examples of implementations with problems followed by refactored improvements highly valuable. It's much better to learn learn from mistakes without making them all yourself, as the book points out.
The chapter on memory management under Java was a refreshing treat. Coming from a C++ background where resources are a major concern, I've heard many Java programmers use garbage collection in Java as a reason not to worry about resources. The book addressed how garbage collection worked in the past as well as current algorithms, and pointed out ways resources can be leaked quite easily. Awareness of a potential problem is one of the best tools a developer has, and the antipatterns addressed in this book will be ones I revisit when starting new projects. It's essentially defensive driving for developers, but fun to read!
Some sections concered areas I've only read about thus far, and it was interesting to see some problems in implementations based largely on following available "how to" guides. The list of suggested follow up reading will keep me busy for quite a while.
Were these reviews helpful?   Let us know
Search Customer Reviews
Only search this product's reviews

Customer Discussions

This product's forum
Discussion Replies Latest Post
No discussions yet

Ask questions, Share opinions, Gain insight
Start a new discussion
First post:
Prompts for sign-in

Search Customer Discussions
Search all Amazon discussions

Look for similar items by category