Customer Reviews

Patterns in Java, Volume 2

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

 

 

While I liked Volume 1 of this series, this book is just not worth the money. Most of its "patterns" are obvious strategies which anyone who has taken more than a couple CS classes will know already. For example, there are about ten "User Interface" patterns. These consist of things like "If the user needs to enter many pieces of discrete information, use the Form pattern." Many of the other patterns are similarly obvious.

However, there were a few ideas about efficiency and testing which I found useful, so the book is not a total loss. I'd suggest flipping through it at a local bookstore, but that's it.

Yes, it is high time to apply design patterns to Java. Java presents opportunities and challenges that were not present in C++.

In this series, Mark Grand converts well-established design patterns into Java. Unfortunately, he fails to demonstrate even a rudimentary understanding of his material. These books read like hopelessly flawed research papers, not the fruit of experience. I finished both books wondering whether the author had ever actually implemented any of these patterns in a real-world design.

He misinterprets some key points while missing others altogether. Some well-established patterns use inheritance for mixins. That's fine for C++, but Java provides only single inheritance. Wasting inheritance as he does, the author's implementations make it impossible to use inheritance for normal (more important) purposes. Interfaces solve many of the problems that the author creates. In some cases, the implementations contain hard code that flatly contradicts the intended generality of the patterns.

Volume 2 also demonstrates that the author does not know the difference between a coding technique and a design pattern. Some of his so-called "design patterns" (under his own name, of course) are mere coding techniques that have been around practically forever. Assertions provide a typical example.

This book may fool less experienced readers. Too bad they will eventually have to unlearn the garbage they pick up here.

This book gets one star only because it is the lowest rating I can give. Mr. Grand, please stop writing! You're only embarrassing yourself. Please do not release your intended third volume while your first two are in such desperate need of rewrites by a knowledgeable professional.

Around three years ago, I joked with a collegue of mine that a sure way to make a fortune would be to write a book which included the words "Java" and "Patterns" in the title. It would matter little, I argued, what the book contained. Just the title and a half-decent graphic on the front page would suffice.

It seems to me that both Mr Grand and his publishers Wiley are attempting to cash in on this very idea. The problem is that the joke was a bad one in the first place, and that it is now being made far too late in the day.

I hope that the software development community is sufficiently aware that it won't be taken in by this outrage.

This book epitomises so much of what is wrong in the software industry that I wonder if, in a sick kind of ironic way, that this is its only value?

It cashes in on buzzwords in the title but is full of errors and demonstrates a complete lack of understanding of the material by the author.

There is nothing to redeem this book. It is an embarassment.

Please read the Composed Method Pattern in this book. My God! what in the world the author was thinking when he called this a Pattern. I think this book should re-called by author, and evry buyer should get thier money back with interest.

In my opinion, code examples are just as important as the text that explains it. Unfortunately, the author didn't think so. Going through the book and visiting the companion website to get the source code to run was a waste of time.

For the most part, the code didn't work at all! It didn't matter what compiler version you make use of; I used 4 different versions of the JDK. A book is supposed to save you time when you are trying to learn. This book doesn't fit the bill. I still had to go to the web in order to get working examples of the patterns mentioned in the book.

I'm sure the author know's what he talking about. I just think that he should prove it by writing programs that are tested and that compile before shipping it off in a book.

I will be returning this book tomorrow. If I compare my expectations (ie. a "design patterns" book) with what the book contains, it is one of the worst books I've ever seen. Things like "grey out not available menu items" and "use switch statements instead of nested if/elseif" are simply good programming techniques that we all learn; they are not what we come to know as "patterns". It isn't so bad to have a book like this, but it should not be called a patterns book, because this is highly misleading. One who buys a patterns book isn't expecting this kind of elementary information. To be fair to the author, it is the type of material that makes it not acceptable, not how it is written. It presents good programming standards and guidelines, but a 20 page book could accomplish that with simple examples, without repetitive and unnecessary information. If you want a patterns book, don't even consider this.

The new two book series tries to have more patterns and tie them all to Java. One advantage to this approach is that some patterns make sense in Java that do not make sense in other OO language. Apparently from reading Volume 2, it appears that a Volume 3 is planned.<p.

An odd thing about this series is that the first three chapters are the same in both books. I wish they were in Volume 1 only to save me some money, shelf space and to save trees.

It is true that the books gives you a large library of patterns. However, it has been discussed between myself and others that some of the patterns are not really patterns at all. For example, the so-called "Testing Patterns" have been around forever and are methodologies not Patterns. Also, they are not related to Java in any way.

The explanations in this book in no way compare to the explanations found in GoF. The descriptions of patterns in GoF were pretty consistent in understandability. "Patterns in Java" was a real mixed bag. Some patterns had wonderful explanations. Others did not make sense to me even after repeated readings. Most were just okay though.

Many of the code examples seem overly complex to me. Instead of just showing the patterns in isolation, the examples tend try to do something else which masks the patterns itself. Also, I saw some bugs in some of the code and others have told me the same. For example, the singleton code examples claims "If you play all audio clips through the AudioClipManager object, there will never be more than one audio clip playing at the same time." However, from looking at the code, I see a race condition that is not handled.

In summary, if the book was executed properly, it would be incredibly useful to all Java programmers. However, the implementation is very flawed. It is still marginally useful in that it documents a lot of patterns that GoF does not. A second edition, which focused on improving explanations and code examples, is needed to make these books really good.

The author has tried to create a book from very few usable patterns by padding with an irrelevant introduction for a second volume (First fifty pages) then filling the centre section with mind numbingly obvious GUI and coding patterns. The last section on testing patterns gave me the feeling that the only thing the book missed was a 100 page "Introduction to Java" and a "Scraping the bottom of the barrel" pattern.

The books lack of pattern names at the top of the page and a sensible method of quick access to patterns plauged the Vol. 1 as well. Experienced programmers (Ie, those not learning the basics of Java) will not find this book useful enough to justify the purchase and will be very disappointed if they expect design patterns of Gamma, et al standard.

My impressions:
The introduction (UML short and SW Life Cycle) is excellent. I especially liked the collaboration diagrams.

The 'GRASP' (patterns) present good guidelines that can improve your overall class design. (Which classes to introduce, how to distribute the tasks to be performed ...). To get the idea, it is of advantage, when you have previously designed a larger project yourself (seeing that there are many solutions that will result in different gains and tradeoffs). The GRASP help you to explain why.

'GUI Design' improves your sensitiveness in creating user-friendly GUIs (choosing the appropriate interface design, presenting not more than 7 chunks, how and when to deliver feedback, ...).

The chapters 'Organizational Coding' and 'Code Robustness Patterns' explain techniques how to write clean and maintainable code (like the usage of adapter classes, constants in interfaces, finally statements ...). Those will already be known by todays more experienced programmers. But only because of this, they will neither harm anyone nor will they be trash anytime! (Sorry, this refers to very rude other reviews - but it really has to be told.)

From the 'Coding Optimization Patterns' i liked double-checked locking and the (maybe already known) lookup table technique.

The last chapter 'Testing Patterns' is the best general introduction into testing i've seen so far (black, white box, unit, integration , system, regression, acceptance and clean room testing).

Conclusion:
When you come from the GoF book searching for further explanations buy 'Patterns in Java Volume 1' (notice the much improved 2nd Edition!), otherwise you'll be disappointed, here.
The problem that Volume 2 has, is probably the (missed) target group. But it is not a bad book and Mr Grand knows what he writes, believe me.