Customer Reviews

Bitter EJB

5 star:		(7)
4 star:		(5)
3 star:		(0)
2 star:		(0)
1 star:		(0)

 

 

If you are a Java/J2EE developer, reading this book will save you hundreds of wasted hours.
There are plenty of books on J2EE design patterns and best practices.
Bruce Tate goes well beyond these discussions and outlines the effectiveness of these strategies, antipatterns, and above all: alternatives.

Simply put, this is the only book that puts J2EE into perspective.
Sales/Marketing have convinced developers that EJB is the "golden hammer" for enterprise solutions.
This book will enlighten you to creating effective J2EE applications without falling victim to market hype.

It is my personal opinion that Bruce Tate is the most effective technical writer since Richard Stevens.
The writing is clear and to the concise, every page directly addressing common roadblocks in EJB development.

For readers with a solid understanding of J2EE principles, this book will help you navigate around common pitfalls and outline effective solutions.
For less experienced readers, it will help you plan effectively.

After reading a dozen J2EE books, Bitter EJB stands tall as "required reading".

Bitter EJB couldn't have come at a better time for me. My development team is at a crossroads. Having developed a reasonably complex web-based model-view-controller architecture from scratch in Java, we thought we knew everything. Then it hit us: scalability problems, transactional integrity questions, database portability nightmares... we were in trouble. Ah, but knowing all, we determined that a simple migration of some of our logic to Enterprise JavaBeans would solve everything.

Or would it? We started thinking: Are EJBs really better than JDO? Or home-grown solutions? How about JMS? Does it let us scale too? And what's with these Message Drive Beans? If we go EJB, do we use CMP? Hey, we hand-tuned a lot of JDBC code... aren't we going to see a performance degredation? Why would we choose Entity Beans over Session Beans or the reverse? How do we tackle the complexities of building and testing these components? We read the JavaDocs and specs, but we still had lots of questions, and not a lot of informed answers. Suddenly, we didn't feel so smart. At all.

Thankfully Bitter EJB tackles these issues and more with humor and insight. There are plenty of good books that tell you how to build an EJB or use a message queue from Java. Instead of regurgitating the mechanics, this one tells you the why, why not and when to's of developing with EJBs and related technologies. You won't find a lot of EJB cheerleading in these pages, but rather a whole lot of unbiased, intuitive advice that will help you make the right decisions for your environment, product, team and goals.

This book is a must-have for the serious J2EE developers. For example, many teams realize in EJB development that entity beans are overkill and complex enough to really drag a project down, yet very few books tell you this. Bitter EJB is the exception - it gives tried and true advice from those that have really been there and worked through the issues. In my extensive J2EE development experience I have learned the hard way many of these antipatterns. Do yourself a favor and don't learn these pitfalls the hard way - let Bruce, Mike, Bob, and Patrick join your team and steer you away from common mistakes, and towards best practices.

If you are utilizing J2EE on your current project you owe it to yourself (and your project) to read this book.

I've spent the last several years consulting to numerous companies implementing solution using J2EE technology. This book covers many of the most common mistakes made in J2EE projects. Most of these companies had exceptional expertise in their domains but lacked experience mapping their business needs into J2EE. The result was many variations of the anti-patterns covered in this book, many sleepless nights for the development team and many missed delivery deadlines.

A few of my favorites anti-patterns are: Tangled Threads, Ham Sandwich; Hold the Ham, Application Joins, Rusty Keys, Performance Afterthoughts, Thrash-Tuning, Manual Performance Testing, System Loaded Application Classes, Running with Scissors, and Integration Hell.

Most projects contain at least a half dozen of these anti-patterns. You can rediscover these anti-patterns on your own or benefit from the excellent advice and experience contained in this book.

This book masterfully fills a real void in Java literature. There have been several respectable books written on AntiPatterns for general topics and J2SE. There are also a couple of excellent books on EJB and other J2EE patterns. But, until now, there has been a void of AntiPattern books relating to EJB or other J2EE topics. AntiPattern books fill an important need because they help developers understand the serious problems they need to avoid. With complex topics like EJBs, AntiPatterns are particularly important.
There are a few parts of this book that discuss the pros and cons of the EJB architecture. But, the primary focus of this book is to help EJB developers and designers get the most out of their use of EJB technology. The book does this by focusing on the bitter mistakes that you can make and explaining how to avoid or rectify those mistakes.
I think every EJB developer or designer should read this AntiPattern book and a "positive" pattern book such as EJB Design Patterns or Core J2EE Patterns.
Before reading this book, you should have a solid general understanding of EJBs, such as could be gained from books like Enterprise JavaBeans by Haefel or Mastering EJB by Roman.

Bitter EJB is a terrific book about technology that's hard to get a good grip on. EJB technology is complex, with many pitfalls. Some of those pitfalls are hidden, while others are so obvious they obscure the possible benefits.

Alfred Korzybski once wrote, "There are two ways to slide easily through life: to believe everything or to doubt everything. Both ways save us from thinking." Many people are currently sliding easily through one side or the other of the EJB debate, but the authors of Bitter EJB have clearly done some serious thinking. Some of the familiar EJB criticisms are here, but so are endorsements -- with warnings, to be sure, but endorsements nonetheless -- of some EJB techniques that many others have dismissed. It's an extremely fair and balanced book, and I think nearly everyone who reads it will learn many useful things about when and how to use EJBs, as well as when not to.

Although not a reference manual, the coverage is both broad (covering the various types of EJB) and deep (including discussions of transactions, interfaces, deployment descriptors, build systems, testing, and performance). To top it all off, it's an enjoyable read. It's a must-read for anyone currently or soon to be involved in a project that might be a candidate for EJBs.

This is a must read for everyone who either considers or is implementing EJB-based software. It is not a tutorial, it is the essence of experience, what to do and what not to do (or at least what to watch out for). In a team setting I would make this a mandatory reading.

If you are already experienced EJB developer then you will appreciate the good wisdom and advice in this book. I found it is not a problem solving kind of book but a problem avoiding one. Read before you start your next project and like me you will save many hours of frustration.

I give 4 stars because some chapters are not as useful and overall the book could have better organization. But these are small points. Definitely you should read this book!

As a consultant that's worked for a few big companies that are doing EJB Architecture, I'd like the Architect read this book. Then maybe they would put down the "golden hammer" (EntityBean) and pickup a useful tool. There is too much bangging around with those expensive hammers.

Good book - and I could relate to the adventure stories that open many chapters - I found them interesting and pointed!

I was disappointed by Tate's "Bitter Java". But "Bitter EJB" is totally different story.
I would strongly suggest everyone read it also get "Expert One-on-One J2EE Design and
Development". These too books compensate each other very well. Both of them obviously
favor JDO over Entity Bean. Is JDO the future? still unsure:-)