Most Helpful Customer Reviews
29 of 33 people found the following review helpful:
2.0 out of 5 stars
Nice Try, but I was disappointed, April 1, 2003
By A Customer
This review is from: Bitter Java (Paperback)
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 or 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).
Help other customers find the most helpful reviews
Was this review helpful to you? Yes
No
15 of 16 people found the following review helpful:
5.0 out of 5 stars
Learn from others' mistakes, April 19, 2002
This review is from: Bitter Java (Paperback)
"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.
Help other customers find the most helpful reviews
Was this review helpful to you? Yes
No
11 of 11 people found the following review helpful:
4.0 out of 5 stars
Java for skydivers, April 10, 2002
This review is from: Bitter Java (Paperback)
I think it's clear that Java has reached maturity. However, many programmers have felt how hard it is to see Java kicking and screaming through childhood and adolescence. There's often a right way to write Java code, and many many wrong ways. This book is for those who have loved and lost, and who don't mind trying again. One of the common criticisms of Erich Gamma's seminal "Design Patterns" (or more relevantly, William Brown's "Antipatterns") is that they make for fun reading, but the ideas are awfully hard to put into practice. Well, this book connects current design theory to a useful implementation, as long as you are programming in Java. There is a slight disconnect between some of the Java examples and strict theory (for example, Gamma would never have seen fit to include a mini-antipattern like "Too Many Web Page Items"... too basic for his style), so this book feels more like the lessons learned (the hard way) from a Java consultant rather than a formal textbook. Which of course is what it is. On the down side, I thought I would like the "adventure stories" that start each chapter, but in the end they feel like they are a too-obvious attempt to reach the Boulder Colorado Yuppie Java Programmer market. Another criticism is that some of the figures are too basic to deserve space on the page and seem to be placed there to add some color and break up the text. Comments like "I suppressed a triumphant smile and again reviewed the [other programmer's bad] code" or "we have compiled... all of the good programming examples. They work." feel like a lecture from a "white knight" programmer parachuting in to save your deranged Java project. Bruce Tate is Smarter Than You. ...and he is, or at least he's smarter than *me*. I've never worked on a large-scale Java project, and a lot of the topics he mentions (cache management and preventing database connection thrashing, for example) are things I've never thought of trying. Other sections like the short course in good Internet coding standards in chapter 2 seem a bit brief (and to be fair, the author admittedly suggests skipping to chapter 3 for some programmers). Luckily, I love the clear summaries of the antipatterns at the end of each chapter for those programmers like me who like to read from the back of a book to the front. But for all reader types, this book contains many great lessons that should be learned before ever starting a coding project. If your Java project isn't going well, or if you're just starting another Java "free fall", I highly recommend reading this book. At its best, the antipatterns in this book seem like common sense - but don't let that deter you from thinking that you need to read this book. You can learn this stuff before you start coding, when you're in the middle of a bad Java project, or you can learn it the hard way like the author. It's your choice. I guess I was expecting a little more bitterness from the Java and not the author, but sometimes life is hard.
Help other customers find the most helpful reviews
Was this review helpful to you? Yes
No
|
