Bitter Java

by Bruce Tate and Bruce A. Tate

Intended for intermediate Java programmers, analysts, and architects, this guide is a comprehensive analysis of common server-side Java programming traps (called anti-patterns) and their causes and resolutions. Based on a highly successful software conference presentation, this book is grounded on the premise that software programmers enjoy learning not from successful techniques and design patterns, but from bad programs, designs, and war stories...

• Format: Paperback
• Language: English
• ISBN: 193011043X
• ISBN13: 9781930110434
• Release Date: April 2002
• Publisher: Manning Publications
• Length: 368 Pages
• Weight: 1.40 lbs.
• Dimensions: 0.8" x 7.4" x 9.3"

Customer Reviews

A Fresh New Perspective

I have long wondered why so many books existed that were API reference books. Such books must sell well because for every new version of an API there are a number of new books that rehash what is freely available on-line. Such books generally offer no thought provoking material and do little to help me solve real world problems. Tate's 'Bitter Java' is NOT one of those books. Tate offers a very insightful and unique way of helping readers to better understand what factors need to be taken into consideration and how to answer real world problems. By looking at 'normal' code, the author makes it clear as to what developers are trying to accomplish and why they did what they did and what the pitfalls are in how they did it. He then takes a page right out of extreme programming and refactors, refactors, refactors until the code is optimized. Each step of the refactoring process is explained in enough detail to understand what the problems were in the original code and what the benefits are in the refactored code.The examples, which the author uses, are consistent across the entire book, which at times makes reading it seem somewhat redundant, but is what makes the examples so understandable. Time does not need to be spent restating what the code is trying to accomplish. The examples are also very prudent. It is very easy to picture the examples as being code that was taken out of a system that you are working on.This book lies somewhere between a patterns book and a java implementation book. At a high level, what Tate advocates in each chapter is the use of a pattern, but he does not attempt to cover a large set of patterns. Instead, he has chosen to look at a variety of common bad practices and advises certain patterns be used to correct them. This book goes into a lot more hands on implementation of patterns than an ordinary pattern book. It is much more suited for hands on development use than the academic nature of most books. This non-academic focus of the book is what makes it so useful.I really enjoy getting people's insight into real world experiences and am often frustrated that I cannot get more people's insight. I would much rather learn from someone else's mistake than my own. This is why I like this book so much. It allows me to build upon the knowledge and experiences of my peers.

Antipatterns are dead! Long live Antipatterns!

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!

Excellent Book - Full of Java Server-side techniques

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 tuningThis 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.

A great collection of lessons learned the hard way

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.

Learn from others' mistakes

"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 ab