Bitter Java

Rating:
Summary: What a waste of time
Review: Don't bother buying the hard copy of this book. The so-called
antipatterns in this book are too simple for anybody who has
at least some common senses in using servlet/jsp/j2ee.

Maybe useful to true beginners, but then the free PDF version
should suffice.

Rating:
Summary: Good java anti-patterns book
Review: good sections on the ejb and web tier with common anti-patterns illustrated. however most materials are introductory and i was hoping for more advanced techniques and advice to writing good j2ee app. this is definitely a good first book to understanding how to write/architect j2ee app the right way.

Rating:
Summary: Good But Could Have Been Better
Review: I'm mixed on this one. This books attempts to present refactoring in a way that inexperienced developers can understand. In that respect, I think the author delivers. If you're a beginner (or maybe into mid-level), get this book when you're past the fundamentals stage. Advanced programmers, however, will already be aware of most of the material from experience. I think it would have been better to target either either advanced developers with more complex topics and code, or just fine-tune this text a little to target advancing beginners to mid-level programmers.

Rating:
Summary: A Must Read For Serious Java Programmers
Review: If you're just learning how to program in Java, then Bitter Java is not for you. If you've written a few (or many) Java programs and want to become a better programmer, then I can highly recommend this book. It's jam packed with useful insights, that can only come from years of real world experience.

In the first section, Tate spends a fair amount of time explaining what 'anti-patterns' are, and why you should look for, document and exterminate them. Personally, I felt that this section could have been shorter--but, if you are not familiar with design patterns, it's worth reading.

The rest of the book is dedicated to various anti-patterns that the author has encountered, and ways of recognizing and fixing them. Unlike other design books, that tend toward the incomprehensibly abstract, this book is crammed with concrete examples that show a) a piece of 'broken' code and b) the changes (refactoring) that can be made to improve it. 'Bitter Java' is probably the most approachable book I've ever read on the subject. Near the beginning the author asserts that many programmers are 'into' extreme sports (I've never met any, but hey) and sprinkled throughout the book are short tales about his sporting experiences. While not related to Java, they usually serve to illustrate a point or two and help to make the book that much more readable.

For a short book (~320 pages), the author manages to cover a fairly wide swath of server-side Java technology, and some of the worst practices associated with them. He hits on topics such as Servlets, JSP, EJBs, connection pooling, connection topology and caching. On top of that, he devotes a chapter to 'Hygiene' (coding style, or lack-thereof), some basic OO principals and some XP principals. All of these practices are discussed in terms of how they can reduce the occurrences of anti-patterns and make them easier to find and fix if they do occur.

The only negative thing that I can say about 'Bitter Java' is that some of the example code wouldn't pass a compiler--little things like misspelt variable names and questionable exception declaration. Considering the nature of the book (high level design) and the suggested audience (intermediate Java programmers), this is a minor flaw. (To be honest, it seems to occur in almost every book on programming.)

All things considered, I'd give 'Bitter Java' about a 9 out of Ten. If I have anything to say about it, every programmer in my office will be reading this book...

(In the interests of honesty, I should mention that I was given this book in exchange for posting a review of it. I'll also mention that I've paid for many books that weren't nearly as insightful.)

Rating:
Summary: Nice Try, but I was disappointed
Review: Not a bad book really ...
... if you never did (server side) programming. Or had some
other decent education including topics like caching,
modularisation, Model-View-Controller.
For EJB there are better books (as Tate acknowledges)
like Roman's Mastering EJBs or more general:
Core J2EE patterns.

So if you are just starting programming in
university, Bitter Java might give you a taste of
the real world.

Again, it is not a bad book, but very basic.
A little bit wordy perhaps -- I do not
mind his kayaking excursions -- but the text itself.
Three years ago as a one-hour
presentation I might have liked to listen to Bruce Tate,
but in 2002 as book this is absolutely boring

Rating:
Summary: Probiotic Java
Review: Tate is trying to make a boring subject more fun.
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:
# JSP

# EJB
# servlets
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.

/Thomas

Rating:
Summary: Absolute Rubbish
Review: The author himself is one of the reviewers who gave this book 5 stars. That made me wonder if others who think highly of this book are somehow related to Mr. Tate. His friend? Family member? Colleague?

To me, this book is absolute rubbish. Claims big but delivers nothing. Don't believe me? Get the PDF version before you waste your money. Read the bookstore's refund policy because you'll need it.

Rating:
Summary: Absolute Rubbish
Review: This book is well written but I was expected something more advanced. If you have been a real J2EE developer for at least a year, you would probably have run across some if not most of the problems already. You also would have worked around them using solutions from other Java books you have.

This is a good book for new developers. They should be able to recognize problems early on after reading this book.

Rating:
Summary: great book
Review: this is a really well written book, is a fun read, and offers a lot of bad programming examples. you'll enjoy it (really-you will).

Rating:
Summary: A great collection of lessons learned the hard way
Review: 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.