Rating: 
Summary: learn OO in 'design patter' way
Review: There are 2 ways of learning new concepts and principles:
1. learn principles first, then try to use them
2. observe good implementations first, then learn to appreciate the principles behind themThe authors successfully convince me that the 2nd way is the better way of learning a paradigm like OO. The authors first give us a little principles (Chapter 1), and then intorduce to us the good designs one by one (Part III, IV, V). While explaining these good design solutions (design patterns), authors didn't forget to stop and show us what we have been through, and the principles we can draw from our experience. This is really a joyful and mind-shifting reading. This book is not trying to teach you everything about design pattern and OO. But it lays a very sold foundation in your brain, and force you to think in a new perspective. Of course, you should read GoF after or along with reading this one. Also recommend:
Craig Larman: Applying UML and Design Pattern (this book puts the things you learned into real developement process)
Rating:
Summary: Explained thoroughly and concretely
Review: I have read the Gang of Four book, which I highly respect and view as a kind of Bible for Patterns. The analogy is apt in that you don't read the Bible once, expecting to "get it" the first time through. You need to read, re-read, read commentaries and explainations. And even so, I found the patterns nebulous. Don't get me wrong! The G of Four book is a must have. But this is the first book that took me from the beginning to the end, explaining in concrete examples that I could understand. One of the key points is applying Patterns to the entire software process, not just design, AND MOREOVER, using many Patterns in the solution of software problems. I also really enjoyed the writing style. Someone else has complained that it is written in first person even though there is more than one author. Personally, I don't care how many authors are involved, I want results. And the first person choice brought me into the inner circle, where someone was explaining things directly to me. It is a great read, with an almost ideal style of writing for my personality. They break out bulleted lists (another complaint from someone) that gives me the highlights of what we are going to cover. I cannot explain what a great difference that made. One great lecturer from JPL said when giving a lexture: "Tell them what you're going to tell them. Tell them. Then tell them what you told them." A brilliant speaker, this methodology lends itself to writing I think as much as speaking. Design Patterns I have read and done my best to understand, but this book breaks them down into easy to understand, and more importantly, cases where they can apply in simple language. Possibly most importantly, they describe how learning patterns can be used together with learning OO. I have been doing OO design for many, many years. I read the GofFour, but it was soooo dry, and although I tried hard to put them into practice in my software, I was always disappointed with the results. It felt that the Patterns were tacked on to handle some specific portion of the software. This book, OTOH, addresses the issue of teaching OOD and Patterns at the same time. Even though I considered myself a "good" OO person, I found that after reading this book the Patterns began to fit together with my designs. Wonderful! All this may not mean much to you, but if you are interested in Patterns, the Gang of Four, then please do yourself a favor and buy this book. Not only will you not regret it, it will [pull] you in and teach you in ways you never thought possible. Go for it, you will have no regrets. I have read many, many, many, software books, and this one just shines.
Rating:
Summary: A Nice Introduction to Design Patterns
Review: As an experienced C++ programmer, I have mixed feelings about this book. On one hand, it provides a very nice introduction to design patterns. Although the GoF book remains a must read as well, this book provides a better and easier introduction. On the other hand, this book can be a little tedious because it is written for all levels of programming experience, so at times I felt that it was a bit wordy and that a good 40-50 pages could have been trimmed. I was both happy and disappointed to read the book. I was happy because I found out that I had already used most of the patterns and OOP techniques described in the book but just didn't know what they were called, and therefore I wasn't behind the curve! :-) The flip side, of course, is that I was disappointed not to have learned any new earth shattering techniques. But overall, the book remains a worthwhile read. Software development is getting more complex all the time. Using design patterns formalizes common techniques in use, and more importantly, gives them names and context. This raises the level of discussion among developers, especially at the conceptual level. A further plus is the authors' introduction to UML and their use of it throughout the book. I won't go into details about the contents of the book. Other reviewers have already done a superb job of this. BTW, Metrowerks' PowerPlant users will recognize a number of the patterns described in this book.
Rating: 
Summary: More than a book for beginners. A good surprise !
Review: One of my goals is to read all the books about Design Patterns. I know, it makes a very good business for some bad writters. But not here.
Honestly, when I began this book, I was just thinking about starting "Another Book to Introduce Patterns". It is. But the first thing is : it performs the job very well. Probably because the material comes from a course given by one of the author, the very nature of the patterns is very well and clearly explained, in fact the explanation outperform the one given in the GoF !! So, without any doubt, the book is O.K. for beginners, and I will recommand it as a first book on patterns (with the GoF aside ;-).
The second surprise comes from unexpected thought about patterns : relationships between GoF patterns and Alexandrian patterns and about "pattern process", or how a seniormost pattern leads to a new one. It's a simple, true and new idea exposed here. Last but not least, this book make the relationship between patterns and refactoring, and idea I support for more than one year.
Finally, the reading is very pleasant. So, why not 5 stars ? Well, I reserve this note for very rare books I found "nearly perfect" like the GoF itself...
Rating:
Summary: It Makes a Difference
Review: Synopsis: Trying to find a book that will give you the foundation on how to use design patterns in your problem domain. Context: You have been reading books on design patterns and you understand what your was reading. However, you are not sure where or how to apply the patterns. You are just was not having the ahuh moment when it comes to patterns. Forces: You are trying various ways to use these very important patterns in your day to day work. However, you feel like a high school kids trying to learn Einstein's notes. Solution: Buy and read this book so you can have the foundation to understand how to think about patterns. Consequences: As a result of reading this book
* You will have the required ahuh moment where everything start making sense.
* You will start looking at other design patterns and understanding what they are, and what they are achieving.
* This book is not a catalog of patterns; instead of feeding you a list of patterns it helps you understand all the patterns in all the other books. Think of the motto "Give a man a fish, feed him for a day. Teach a man to fish, feed for life." In this case he is teaching you to understand patterns. Personal Note: I have read some patterns several times and it never really clicked. The other day I was reading about DAO and I caught myself saying this is just like an adapter pattern. That is a sign the writers of this book did a very good job.
Rating:
Summary: May help some students
Review: This book fixes a number of the weaknesses in the "Design Patterns" book by Gamma et al. Unfortunately, it also fixes a number of that book's strengths. First, the benefits. Lots of beginners like the informal and case-oriented approach the authors take. This reads a lot less like someone's PhD dissertation, and shows Java and C++ samples to explain many patterns and concepts. (For some, translating a Smalltalk or even C++ example into Java is difficult enough for the real topic of discussion to get lost.) It also uses the sustained example of a CAD/CAM system to show specific, concrete cases where a pattern might apply. This prolonged example means the reader doesn't have to switch gears to a new application context every time a pattern is put to work, and gives a chance for interactions between multiple patterns to emerge. As near as I can tell, this book came from the class notes of a course taught by one of the authors. That explains the many additional hints about good programming and tips on OO style. It also explains the idiosyncratic order in which topics appear - although it stays close to the content of Gamma et al., it certainly does not stay close to that book's organization. That's where I think Shalloway and Trott start to falter. The organization of this book seems to be built around the CAD/CAM example, not around any inherent properties of the patterns or logical connection to OO topics. That's fine, until you go to an application different from theirs. The focus on specific examples is also a weakness. Design Patterns are too broad to be defined by any one implementation. That means that any example, while it represents one way to apply a pattern, fails to represent a half-dozen others. The literal-minded student comes away with much too narrow an idea of how the pattern can be applied. I'm not sure that replacing the generality of Gamma et al. with exact point solutions is an improvement. Still, enough students tell me this book helps that I believe them. There's a large body of DP literature out there, and some is pretty awful. I find this book undistinguished, but it's on my list of references for beginners who struggle with DP concepts. This may help clarify Gamma et al., but doesn't replace it.
Rating:
Summary: I think this is an ideal introduction to design patterns
Review: Unlike most other, indeed more advanced, books on the topic, this one is written with an informal voice. The authors took pretty complex concepts but managed to make them much easier to understand, aided by concise and relevant examples. The book doesn't pretend to teach everything about design patterns, but provide a very solid foundation that can be integrated by other, more advanced titles. I think this is an ideal introduction to design patterns.
Rating:
Summary: Very Good and Very pleasant to read!!!
Review: This book is to patterns as Fowler's UML Distilled is to UML. It is written in a very accesible language, very pleasant to read and very ilustrative. The examples are generally very good, except for the Abstract Factory and the Decorator. It is very nice and ilustrative the way in wich the autors derive some patterns, especially the cases of Bridge, Adapter and Facade. The authors also share some very interesting insights on object orientation, product of their own empirical experience in the real world, giving the foundations to their discussion. Unfortunately, the authors do not go into the 23 GoF patterns, altough they explain Bridge, Adapter, Facade, Abstract Factory, Singleton, Strategy, Decorator, Observer, Template Method and Factory Method. I would like to say a constructive word about two of the samples: in the Abstract Factory, they depart from a quite simple point to finally get to a more complex solution (the abstract factory itself) without much added value (is like the "Patter Happiness" concept presented in the book Refactoring to Patterns). Something similar happened to me on the Decorator sample. Anyway, I think this book is an excellent buy. It is very well written, very enjoyable and very easy to read. Personally, I liked this book very much and I would recommend it as a companion of the GoF book to anyone who wants to get initiated in the patterns field .
Rating: 
Summary: Decent book, presents good prespective on programming
Review: I picked up this book after reading through the original Design Patterns (GoF). Although they discuss similar topics and this book refers to the GoF book quite frequently, I wouldn't necessarily associate the two with each other despite having similiar book titles. There isn't much code in this book or elaborate examples but it is a nice quick book you can read and is something that can be read easily understood by any level of programmer. In my opinion though you should probably read this book first before you read the GoF book despite this one actually being the one that is supposed to explain the other. To me it felt more like a synopsis and is too brief in many places. More or less it makes a good introduction into design patters but will not be the book that will give you a full understanding of what it really is.
Rating:
Summary: Essential bookshelf material
Review: Having used design patterns since their discovery in the early 90's, I am a seasoned advocate. This book's informal voice deals with patterns in an easy-to-follow, almost jovial pace. From commonality/variance analysis through to concrete examples of use, this book is an ideal companion to anyone involved in using or adopting a design patterns approach. I highly recommend this book for those involved in mentoring or coaching others in the way of patterns.
| 
