Customer Reviews

Design Patterns Java™ Workbook

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

 

 

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.

I have read the GoF book and found this book a valuable addition to it in several aspects. First, I am a Java developer so having the examples in Java and UML for the classes helped me quickly comprehend the patterns. Second, are you like me? You read technical books all the time, but two weeks after reading something you have a hard time remembering it because you didn't apply it? This book tries to help in this respect. I found the numerous challenges for each pattern an excellent exercise in testing my comprehension and for motivating myself to think more deeply about how to apply the pattern. Finally, this book is not a simple rehash of the GoF book and provides a new and interesting way to think about the same GoF patterns. I would recommend this book for Java developers pursuing Pattern enlightenment.

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.

If you are old enough to remember Tony Hansen's incredible 'The C++ Answer Book', this is the same thing for Patterns, and in Java. In a lot of ways, I feel like it would be sacrosanct to say anything against this book at all because it truly is something that has been needed for so long. Vlissides' book 'Pattern Hatching' reads like Byron's Manfred: brooding, intellectual, meandering, and at its worst, kind of fussy (but still a great book). This book is the other end of the spectrum. It bends over backwards to constantly recontextualize the discussion and yet it still has the depth to consider trade-offs and challenges in working through implementations. Even though the author recommends Grand's 'Patterns in Java, Vol 1', I recommend this instead. The Grand book is really inconsistent and sloppy, though it has some good parts.

My only reservations is that it teeters into the juvenile at times in ways that are so bizarre, you think, wait a second, a minute ago I was pushing through a paragraph that might keep me thinking for a week and now I feel like an imbecile, being told how method dispatching works in OO languages and how that is the basis of polymorphism (I actually had to fish my thumb out of my mouth during that section).

While the appendices are very smartly laid out, this book isn't quite as meticulous as the Hansen book so some may look at this and say I don't know what I'm talking about. Maybe for that reason, this will end up fading away faster than it might have if the author had spent a little more time trying to work up material that was a bit more challenging.

One final good point: he uses a very good technique in here where he talks about different parts of familiar code that are examples of various Gang of Four patterns. It really is an effective way to get people to realize that patterns aren't an esoteric, academic pursuit. We're all already swimming in them and coders who are not up on them enough to recognize them are probably not going to produce really good code.

Unlike so many other books on this subject, "Design Patterns Java Workbook" is very careful and precise in its usage of words, it is considerably insightful, it is fun to read, and has a unique style that does not try to immitate the GoF book. The challenges are also a great way to keep you on your toes.

This is, hands down, the best design patterns book for java developers that I've come across so far and now sits right next to GoF in my library.

While most books are intent on conveying theory with the aid of examples, here's a refreshing book that actually challenges you to use your mind while reading the book. In essence, the concept of a workbook has existed since our schooling days but never applied in the professional world. The workbook concept brings back some school memories, but in this fast paced world where we are conditioned to act and learn instantaneously, it is kinda cool to think a little bit before getting the solution (Math without calculators concept).
The Workbook provides lots of good examples and tries to give readers a good review of the design patterns as described by the GOF book. This book serves as an effective companion to the GOF book as it does extend the knowledge from the GOF book, but would not necessarily substitute for the original on your bookshelf.
I would rate this book as a MUST HAVE for any of the Java programmers out there.

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!

I found this book to be more readable but less in-depth than Design Patterns (the Gang of Four book). The Java examples were generally understandable but I felt like the attempt to relate each pattern to fireworks was more distracting than helpful and more forced than natural. In contrast, Design Patterns provided realistic examples of where each pattern naturally fits, and included much more information to guide the decision of when to apply a particular pattern.

I found this to be an excellent companion to Design Patterns. It was much easier to read, but I always read the similar section of Design Patterns after each chapter to get a full description. On its own, this book would be good if your goal is to learn the 23 Gang of Four patterns by friendly Java examples, without expecting much explanation regarding the application or common usage of the patterns.

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.

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!