Customer Reviews

Design Patterns Explained: A New Perspective on Object-Oriented Design (2nd Edition)

5 star:		(24)
4 star:		(16)
3 star:		(3)
2 star:		(6)
1 star:		(0)

 

 

Trying to understand design patterns based on most texts can be as painful as poking yourself in the eye. The book Design Patterns Explained - A New Perspective on Object-Oriented Design (2nd Edition) by Alan Shalloway and James R. Trott is considerably easier on your eye and your pain threshold...

Chapter List:
Part 1 - An Introduction to Object-Oriented Software Development: The Object-Oriented Paradigm; The UML - The Unified Modeling Language
Part 2 - The Limitations of Traditional Object-Oriented Design: A Problem That Cries Out for Flexible Code; A Standard Object-Oriented Solution
Part 3 - Design Patterns: An Introduction to Design Patterns; The Facade Pattern; The Adapter Pattern; Expanding Our Horizons; The Strategy Pattern; The Bridge Pattern; The Abstract Factory Pattern
Part 4 - Putting It All Together - Thinking In Patterns: How Do Experts Design?; Solving the CAD/CAM Problem with Patterns
Part 5 - Toward a New Paradigm of Design: The Principles and Strategies of Design Patterns; Commonality and Variability Analysis; The Analysis Matrix; The Decorator Pattern
Part 6 - Other Values Of Patterns: The Observer Pattern; The Template Method Pattern
Part 7 - Factories: Lessons from Design Patterns - Factories; The Singleton Pattern and the Double-Checked Locking Pattern; The Object Pool Pattern; The Factory Method Pattern; Summary of Factories
Part 8 - Endings and Beginnings: Design Patterns Reviewed - A Summation and a Beginning; Bibliography; Index

The traditional definitive text for design patterns was written by the Gang of Four. It goes into great detail, but it can be very abstract and hard to put into practical terms for beginners. Design Patterns Explained departs from the largely theoretical information and tries to get as concrete and as practical as possible. The authors pick a number of useful patterns and concentrate on those few entries as opposed to trying to cover everything. They put forth a few case studies and use those to explain the pattern being discussed. This tends to make it much easier to understand why the pattern works well for the problem at hand, and how it translates into Java code. Also, it's written in first-person format with plenty of personal insights and opinions. This also helps to make the text much more readable than most.

In addition to just covering the patterns and how they are coded, the authors also talk about the mindset needed to think and design in patterns. This is an aspect of design patterns that I normally don't see covered well (if at all) in most other books. If you combine the focus on thinking in patterns along with the practical information on the most common ones, you get a book that delivers quite a bit more value than most in this niche.

While any serious design pattern student will want to get the Gang of Four book, this volume would be a much better way to get started...

I read the first edition of the book and was greatly pleased by it. I loved the way it described the reasons patterns were good. In other words, although it clearly explained the patterns in the book, it also explained the underlying approach used by the people who wrote the software that later became described as patterns. The book helped me think like these developers instead of just using solutions they had come up with.

I also liked the way the authors showed how to use the patterns in the real world. I had always thought you used the patterns as solutions to recurring problems. However, the authors described how the patterns were really about a new way to think of the problem you had to solve.

As good as the first edition was, however, it left some gaps. In particular, while the domain analysis approach they espouse called commonality - variability analysis looks great, not enough information on how to actually use it was presented. Also, as XP has become more popular, I had been wondering about how patterns and XP fit into things.

The book addresses these and some additional issues incredibly well. (...)

Overall, I give this 2 thumbs up and recommend reading it even if you've read the first one. It is a much more involved book than the first with new chapters and improvements on the existing ones.

I already had an understanding of design patterns and OO design principals when I read this book (my review of the original GoF Design Patterns is somewhere on Amazon.com).

Honestly, when my friend suggested I read it I snickered: perhaps such a simple book could help him, but I already understood patterns.

But the book did a really nice job of explaining patterns. I'd be lying if I said it didn't help my understanding of some classic patterns. And I appreciated the references to the original Design Pattners book, which was written for a very technical audience and, accordingly, can be hard to understand for more novice developers.

So I'd disagree with the other reviewer who suggested just getting the GoF book. It's hard to follow, with very dated examples. I can't say about his Head First recommendation.

The book could be improved. Perhaps fewer pages comparing system architecture to structural architecture.

But overall, a good effort.

I don't write reviews often but this book was so good that I felt compelled to do so. It's not just a book about design patterns but also about the thought processes that lead to them. After reading this book (the 2nd edition), I was able to find and fix the flaws I knew I had in one of my existing program designs. By learning to isolate concepts that vary, you can create loosley coupled designs that are easy to modify and extend. Thinking in patterns allows you to see the bigger picture in your design without getting caught up in the details. By having a more conceptual view of your software, you can borrow ideas from time tested solutions.

Highly Recommended!

Design Patterns Explained, is easy to read, informative, and like the title suggests, offers a truly new unique perspective on design patterns.

I enjoyed how the authors extend the software "construction" metaphor (software architecture, scaffolding, plugging in code, etc...) a couple steps further, drawing parallels with Christopher Alexander's (a well known architect's) essay The Nature of Order: An Essay on the Art of Building and the Nature of the Universe. In this particular essay Alexander attempts to decompose good architectural design into patterns and the authors of this book clearly take Alexander's work into the realm of design patterns.
Similarly fascinating were the parallels drawn from anthropologist Ruth Benedict's work, where the authors suggest that good design is culturally transcending.

Design Patterns Explained is a nice supplement to Design Patterns: Elements of Reusable Object-Oriented Software [Gamma, et. al.] and should be read concurrently. As other reviews have pointed out; this book does tend to be verbose in sections, it digresses at moments, and is targeted at the introductory (journeyman) level.
Regardless, it's an interesting read.

This book finally showed me the value of design patterns, not as "reusable solutions", but rather as professional best-practices. In fact, I found it so inspiring that I have become a design patterns instructor as a result. If you are interested in patterns but have found the other books difficult to understand, or if you have struggled in your efforts to actually derive value from patterns in your practice, this book can really help you turn the corner. It's a must read for anyone who strives for high-quality software.

I think "... the best thing about this book is the way the book explains their concepts..." I'm not a native-English speaker, but I felt that "I have no difficulty reading this book at all". The author walks you through cover-to-cover by "Explain You Bit by Bit". That was how I loved this book.

I'm a computer science student. I studied every classic pattern of Gang of Four (GoF), 23 patterns, in my Design Pattern course. In our course, we were using the GoF's classic book, "Design Patterns: Elements of Reusable Object-Oriented Software". Even, from the course, I got fascinated, and well-understanding of what all patterns structures are, but I still felt that I could not take full advantages of my software designing. Until I found this book, it took me to the depth of Design Patterns!

I read this book from the first page through the last. I found it Easy-to-Read!!! Even you have no idea of Object-Oriented (O-O) concept at all, you still can read this book. It briefly explains O-O paradigm and UML in the first two chapters. I, who already know O-O, also like them very much. Reading first two chapters helps me review my understanding of O-O and UML very well. The book also shows benefits of using O-O in changing environment (when the system requirements are changing over time).

Then, authors explain design patterns. In every explanation of each Design Pattern, the book gives Intent, Problem, Solution, Consequences, (UML) Diagram, and Implementation. I love the way the book is written. Reading the book makes you feel like you are personally talking to the authors. In each pattern, the author first gave you a problem to exercise your brain. Then, he shows the mistakes that some developers made normally. Finally he explained the concept why the pattern can apply to solve the problem.

If you are a computer-science student like me, interested in O-O, reading this book will help you gain and improve the O-O skills on programing and design. My friends and I agree that students who know O-O and study Design Pattern will learn O-O design better, faster, deeper than those students who don't.

(As you are a software developer) If you are interested in or already working with O-O developing software as a Java, C++, or C# software developer, this book can be your great manual for design your next project. When your team and you know well in Design Pattern, you can reduce discussing time in the design phrase. Using Design Pattern can help your team communication and cooperation.

For anyone have no knowledge of O-O at all, as I said above that you can still ready this book, but I suggest that you should try to get some reading of O-O programming concepts first. However you don't get the concepts up to expert level. With more O-O understanding, you will get Design Patterns faster and deeper.

Only one negative of this book is that the examples are too simple, and fragmental. (But I guess the authors try to make them as easy as possible)

Finally, I did not expect that my review will increase the sale of this book and tell you that you MUST BUY this book. I just want to share my opinions of this book because I am one of who read the book from the first to the last page. I gained more understanding, and also enjoy it. And I Love It!!!

It's now one of my favorites!!!

This book talks a lot more than about design patterns. It talks about what constitutes good design and how design patterns manifest this philosophy. Good design also must include how to elicit concepts from the problem domain and it does this well. This is the only pattern book that talks about all of the following:
* design patterns in an agile environment
* using encapsulation to hide unknowns
* commonality-variability analysis
* separating use from construction and why it is important
* the relationship between patterns and test-driven development

By dealing with all of these issues in one place the book gives a more powerful look into proper design than is possible when dealing with these issues independently.

Design patterns seem to have been the big thing in object oriented programming for a while now, doing a google search on the web for 'design patterns' brings back over nineteen million hits. However, I'd never run into them before in my time as a VB programmer at my first job, so I looked around to try to find a good introductory book that would explain to me both why design patterns are such a good thing to know, as well as how they work. This is the book I ended up buying for myself, and I think it was a good choice.

The book starts off with a gentle introduction to object oriented programming and an introduction to enough UML to allow the reader to read the diagrams in the book. The introduction to OO programming isn't linked to any particular language - instead the authors give us a general understanding of the theory. I applaud this - there's tons of books on how to create objects in whatever language catches your fancy, but this is enough of an introduction to why object oriented programming is special to read the book, while letting the reader pick up the specifics in his language of choice. The introduction to UML is equally basic - it describes the notation used in the book and no more, leaving a complicated subject to be further explained by books that specialize in it.

Part 2 gives an overview of an interesting problem in programming - a program that translates from a CAD/CAM design to an expert program. The inputs could be coming in two different ways, but the expert program is expecting a third input. He goes into a standard object oriented design, describing how he logically manages to paint himself into a corner with well-meaning decisions. The example not only points out some failures of standard object oriented design, but also forms one of two major examples he comes back to further in the book to illustrate how design patterns help. It's part of an example to miss the forest for the trees - some of the mistakes he was making here seemed obvious to me when I was reading them, but I was willing to see where he was going with the solutions.

For the rest of the book he goes into patterns and describes both what sort of problems they're intended to solve, as well as how to apply them. In each case he goes into an example with some level of detail, describing how you would implement them to one degree or another, sometimes presenting Java code, but usually just talking about things at the object level. Each time that he goes into a pattern, he points out how it works in terms of the underlying rules of patterns:

<ul>
<li>Find what varies and encapsulate it.</li>
<li>Favor aggregation over inheritance.</li>
</ul>

He initially brings these up as general guidelines in chapter 8, but then continues to return to them throughout the book, along with such ideas as 'loose coupling over strong'.

This book is very good. It presents a subset of patterns very strongly, showing some of the simpler ones to begin with, and then continuing along by adding new ones, suggesting how patterns may be useful, and generally reinforcing the why and how of patters as well as the what. I think it's a good introductory text for anyone looking to learn what Design Patterns are, whether they're new programmers just starting out, or older ones who need to catch up.

This book does a very good job of explaining most of the patterns presented in the GOF text. It also gives details on good OO design in general. The author has a very friendly style and keeps your attention, and the pattern examples and explanations are clear and well thought out. One of my favorite patterns books.