Rating: 
Summary: Great concept, Excellent implementation!
Review: It seems I have been waiting for a book like this since a while! Its a great supplement to GOF book and helps a lot in understanding GOF book.
Since I'm basically a java programmer, I always found it hard to go through the classic GOF book and understand it completely. This book helps in doing that. It has good UML diagrams and sample programs in java to aid in understanding patterns. I think the best way to make use of this book is to read the concepts from GOF book and the examples and exercises from this one.
Patterns in general is a such a concept that its hard to grasp and understand unless applied. This book serves well in that arena by asking one to apply the recently learned concepts and makes one ready to identify the similar situations in projects and work life.
A must buy!
Rating: 
Summary: Even a novice Java programmer can understand
Review: Metsker's book translates the Gang of Four patterns to Java. Along the way, we gain insight into the various implementation options that Java provides. This book uses some neat examples to illustrate the use the concrete use of design patterns. Challenges provoke thought to those new to this world. The examples are interesting enough so that even the expert can appreciate this book.
Rating: 
Summary: GEEKY!
Review: The idea behind this book is a very good one: teaching patterns avoiding excessive formalisms and with a hands on approach. I had great expectations from this title which were only partially met.
The book content is sound and some of the patterns are explained in a decent way, but the workbook approach fails as most of the questions are unclear or just too trivial. I find the choice of using a firework factory to work out all of the patterns weird at best.. it makes for a very boring sequence .. fireworks might be fun to see but who cares to learn about star presses, fuses and chemical batches? Besides squeezing all of the patterns in a single context makes for a very forced result. And how about all the swing code thrown in without a real reason? It is just distracting. The author is certainly competent, and a sharp programmer, but he could not resist the typipcal geeky tendency of making things more complicated than they really are by throwing into the discussion basically everything he likes or knows about... parsers, state machines, swing, recursion, object models etc etc.. not to mention the damn fireworks.. ! ;)
I am still looking forward to a book that offers a clear , no frills explanation of design patterns and presents for each pattern a series of ( a lot of ) examples from different context. That is what is n eeeded to absorb good object oriented design and patterns.. simple, clear explanations and practice, practice, practice. Meanwhile, before you go for "the book" (Design Patterns by Erich Gamma, et al ) I would recommend reading
Design Patterns Explained by Alan Shalloway.
Rating:
Summary: Read this book to understand GoF book better.
Review: This book explains the 23 design patterns discussed in GoF book in such a lucid and interesting way that it actually motivates the reader to understand the content of GoF book better.I bought the GoF book a couple of years ago and being a Java developer, I found the book a "heavy" reading. After reading this book, it was easy for me to understand clearly the ideas explained in the GoF. Congratulations to the author on a great work!
Rating:
Summary: Best practices come forward.
Review: This book is a much needed update to the classic "Design Patterns, Elements of Reusable Object-Oriented Software" (GOF.) There is no longer a need to translate Smalltalk or C++ into Java. The categories that each pattern belongs to (Construction, Extension, etc. ) diverges from the GOF teachings. Although this is unexpected, it does provoke additional critical thought. The implementation of some patterns is subtly changed by the Java interface. There is a chapter dedicated to interfaces, and the UML descriptions that accompany each pattern have been updated to account for them. Special attention is paid to the details of Java throughout. "Design Patterns Java Workbook" also does an excellent job with UML. It demonstrates that an idea can be easily shared without overdoing the documentation. The use of Flyweight in a language that relieves its users of the details of memory management proves for an interesting read. The use of Mediator to maintain relational integrity is down right insightful. The authors style is unassuming, and the fireworks discussions (his examples) are entertaining. The challenges spread throughout this book keep the reader engaged, and thinking deep thoughts. It could easily be used in a classroom setting, or for personal skills building.
Rating:
Summary: Best practices come forward.
Review: This book is a much needed update to the classic "Design Patterns, Elements of Reusable Object-Oriented Software" (GOF.) There is no longer a need to translate Smalltalk or C++ into Java. The categories that each pattern belongs to (Construction, Extension, etc. ) diverges from the GOF teachings. Although this is unexpected, it does provoke additional critical thought. The implementation of some patterns is subtly changed by the Java interface. There is a chapter dedicated to interfaces, and the UML descriptions that accompany each pattern have been updated to account for them. Special attention is paid to the details of Java throughout. "Design Patterns Java Workbook" also does an excellent job with UML. It demonstrates that an idea can be easily shared without overdoing the documentation. The use of Flyweight in a language that relieves its users of the details of memory management proves for an interesting read. The use of Mediator to maintain relational integrity is down right insightful. The authors style is unassuming, and the fireworks discussions (his examples) are entertaining. The challenges spread throughout this book keep the reader engaged, and thinking deep thoughts. It could easily be used in a classroom setting, or for personal skills building.
Rating:
Summary: Excellent Workbook, Not a Reference
Review: This book is not for the faint of heart or beginner. This book assumes some background in patterns or, at the very least, the reader has some other reference texts at hand. I would recommend owning and/or pre-reading the definitive 'gang of four' treatise on this subject "Design Patterns, Elements of Reusable Object-Oriented Software". Other helpful texts include "Applied Java Patterns" and "Design Patterns Explained: A New Perspective on Object-Oriented Design". You will need to make a reasonable commitment to this book. If you are a pattern neophyte, this book will only assist in your understanding of patterns, as mentioned above; you must have other resources available to you. This text does not stand on its own unless you are already very familiar with the subject. The book is relentless with its challenges to the reader. If you follow the author's style you will give your brain quite a workout. You may want to consider working through the book with another developer or two. The insight gained from having more than just your own understanding of the concepts would go a long way towards developing a firm handle on the patterns outlined. The case study used in the book is definitely unique and makes for very engaging reading. The code examples are clear and concise (don't cheat yourself by looking at the solutions in the back until you have completed the assignment). I particularly think that the use of UML throughout the text was very well executed. This book is long overdue and a 'must-have' for anyone serious about developing a clear understanding of software design patterns.
Rating: 
Summary: I don't like the approach...
Review: This book is well written but it asks too many questions. I was hoping for a book that gave examples of the patterns and discussed how to use them. It does a nice job of describing the concepts, but it always stops short of giving a good example of the pattern currently under discussion. It also does something that drives me nuts...it makes me work really hard to understand a concept and then explains that is the wrong way to handle the problem and that you should do it another way. I understand why authors do this, but I don't like technique because I think it creates confusion. All in all I am disappointed with the book.
Rating:
Summary: I don't like the approach...
Review: This book is well written but it asks too many questions. I was hoping for a book that gave examples of the patterns and discussed how to use them. It does a nice job of describing the concepts, but it always stops short of giving a good example of the pattern currently under discussion. It also does something that drives me nuts...it makes me work really hard to understand a concept and then explains that is the wrong way to handle the problem and that you should do it another way. I understand why authors do this, but I don't like technique because I think it creates confusion. All in all I am disappointed with the book.
Rating:
Summary: A Great Java Pattern Book
Review: This is a great Java Pattern book. A must to have book, for those who would like to see how Design Patterns by GOF are implemented Java. I like the way to book was written that challenge and exercise the reader's understanding. Bravo and keep up with the good work.
| 
