Enter your mobile number or email address below and we'll send you a link to download the free Kindle App. Then you can start reading Kindle books on your smartphone, tablet, or computer - no Kindle device required.
To get the free app, enter your mobile phone number.
Other Sellers on Amazon
+ $3.99 shipping
+ $3.99 shipping
+ $3.99 shipping
Bitter Java Paperback – April, 2002
All Books, All the Time
Read author interviews, book reviews, editors picks, and more at the Amazon Book Review. Read it now
Customers who bought this item also bought
"!!!! 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
About the Author
Top customer reviews
I've got to agree with the bloke from Australia, the personal adventure stories got tiresome.
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.
You've seen that pattern before.
While not being the first one, he's definitely the first I've seen tying a story on bad Java design to another of him paddling a kayak.
He probably realized that, being a software consultant, putting out a lot of fires at his everyday clients, he needed to spice up the story with some real world downstream canoeing.
It turns out the Java examples are more interesting than the kayaking.
If you have touched any of these subjects:
I'm sure you'll find Bitter Java's preaching interesting.
The books approach is to convert common anti patterns (a worst of breed approach to a problem) to good patterns.
He states many points, and the biggest is that even if you use Java/OOP/EJB/<insert buzz word here>, you'll still easily fall into the common traps of completely non-reusable code.
He doesn't just leave it there, but shows example on how to get out of it.
Bruce points out the most obvious facts about common mistakes, and you sit there nodding, but at the same realize you're doing just those mistakes.
One that JSP/ASP programmers will benefit from is the Model View Controller antipatterns.
On the EJB side he talks about facade objects. While you probably can read about those for free in Suns J2EE pattern Blueprints, it still nice to see real examples.
Some problems might be a little simple, and he enjoys the freedom that many programmers don't have: time to refactor existing code.
All in all, Bitter Java is a good read, using hands on examples with good solutions. I'd like to see Bitter java Advanced, where he'd tackle Java to database decoupling. Maybe I should write one myself.
In Bitter Java, Bruce Tate has collected and catalogued a number of common programming mistakes that he's seen show up over and over again in server-side Java development (these ubiquitous errors are sometimes called "antipatterns"). Each entry includes an explanation of why these traps are so easy to fall into, and describes the basic programming practices each antipattern violates.
The approach of showing how things are commonly done incorrectly, rather than just saying "Here's how to do it right", works quite well. Mistakes are a better teacher than success.
In reading Bitter Java, experienced programmers will nod in familiarity, and less experienced programmers should be able to easily grasp the essence of what is wrong with the examples being presented.
The antipatterns explored in Bitter Java cover a broad range of applications and situations, and Tate supplements the pattern catalog with relevant anecdotes and descriptions of the projects in which they occurred, making the text much more engaging than a simple pattern catalog would be.
A fast and enjoyable read, and has something to offer all but the most experience developer.
Most recent customer reviews
... if you never did (server side) programming. Or had some
other decent education including topics like caching,
antipatterns in this book are too simple for anybody who has
at least some common senses in using...Read more