Customer Reviews


10 Reviews
5 star:
 (5)
4 star:
 (1)
3 star:
 (3)
2 star:    (0)
1 star:
 (1)
 
 
 
 
 
Average Customer Review
Share your thoughts with other customers
Create your own review
 
 

The most helpful favourable review
The most helpful critical review


16 of 17 people found the following review helpful
5.0 out of 5 stars Excellent
A superb book. The explanations were clear and every time I thought of a question the author immediately answered it which just shows how much thought went in to the book.

As someone who, stupidly, never really looked at patterns before I have to say this book was perfect. If you take the time with some of the chapters, particularly the one about the Bridge...
Published on 12 Sep 2004 by C. Jack

versus
3.0 out of 5 stars Tedious and long winded if you are experienced
It's easy to read but tedious if software design is not new to you. The book reads like the author chatting to an inexperienced developer and trying to instil his own personal experience. Personally I don't want to read about someone else's career. I want to be able to put names to patterns that I have frequently had to derive myself so that I can demonstrate at job...
Published on 15 Jun 2011 by Karla Parussel


Most Helpful First | Newest First

16 of 17 people found the following review helpful
5.0 out of 5 stars Excellent, 12 Sep 2004
By 
C. Jack "colinjack" (Edinburgh) - See all my reviews
(REAL NAME)   
A superb book. The explanations were clear and every time I thought of a question the author immediately answered it which just shows how much thought went in to the book.

As someone who, stupidly, never really looked at patterns before I have to say this book was perfect. If you take the time with some of the chapters, particularly the one about the Bridge pattern, then you can come up with the actual pattern before the author gives it. You can do this because the authors give you the information and context you need to work out what the solution will be.

The only slightly annoying point about the book is that the self satisfaction of the authors sometimes gets in the way of more important matters, however that doesn't spoil a good book.

I would recommend that anyone who enjoys this book goes on to look at the books written by Craig Larman, Robert C. Martin and Joshua Kerievsky. They all cover object oriented design and patterns in more detail.
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


13 of 14 people found the following review helpful
5.0 out of 5 stars Fantastic! EVERY software engineer should have this book!., 19 July 2005
I would strongly recommend that *every* student or practising software engineer should read this book, even "experts" in object-oriented or pattern-based programming.
The authors essentially teach the reader how to design software better. They walk the reader through various approaches to a systems design example throughout the book, finally culminating with the approach of combining software patterns with CVA (Commonality and Variability Analysis). It is just so obvious but no-one ever seemed to think of it before.
From reading this book I now have a lot more clarity in thinking through the analysis and design of software and am producing implementations that are far more maintainable. For that I cannot thank the authors enough.
In summary : GET THIS BOOK!
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


1 of 1 people found the following review helpful
4.0 out of 5 stars Not about design patterns, but about good design, 19 Jan 2010
By 
Florian Pilz (Bolton, UK) - See all my reviews
(REAL NAME)   
The target of this book isn't to explain Design Patterns. It tries to teach you about good design by applying well-known principles (strong cohesion, weak coupling, ...) and by explaining several possibilities to order your thoughts.

The book is really easy to understand, too easy for me. The author repeats himself very often in the first half. The first third of the book is an slow introduction to what will come (his intentions, absolute basic thinking and definitions, an example which will be used later on and a chapter about design patterns in building).

These were the reasons I disliked the book in the beginning, it becomes constantly better after the Facade Pattern. He explains all patterns very well, so I think everybody will understand it. It can get somewhat boring if you know the pattern already or already have a responsibility-like thinking of objects (like I did).
Nonetheless I fould at least something interesting in every chapter, most often observations of his own practice were helpful.

What I found most interesting was the Bridge Pattern (really good explained) and the Analysis Matrix (a way to develop a good system from scratch, I liked it more than his CVA-approach [Commonality and Variability Analysis], because CVA is just proper OO-thinking).

His linkage to XP / agile development is generally just "works with agile development, too". What he refers to is most often the style of thinking.

To summarize: Even if I didn't found this book exciting from page to page, I fully agree with his opinion. Nothing in this book is false (I think thats an important thing to say about a technical book).
His quotes from other books are really gorgeous, they explain everything in short. His definitions made in the beginning are very good and neat (cohesion, coupling, aggregation, ...) I liked the recommodations in the end, it's always good to have an opinion on some books to know what to read next.

Whom I recommend this book:
He often refers to the old style of OO-thinking (nouns and verbs) and tell how to improve your OO-thinking to his new style. So I would recommend this book to everyone who already was involved in some projects, but doesn't know Design Patterns at all or is used to the old OO-thinking. I wouldn't recommend this book to beginners, because imho you need some experience to understand why patterns are helpfull or the way of thinking is superior.
If you already know some patterns and have a responsibility-like OO-thinking, this book will bore you most of the time. But like said, it's not wrong and there is a nugget around sometimes, e.g. the Analysis Matrix.

In the end I found it worth reading.

I expected more patterns, thats why I will read the classic Design patterns : elements of reusable object-oriented software next.
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


5.0 out of 5 stars Very insightful, 25 Oct 2013
Verified Purchase(What is this?)
Right from the start this book began to change the way i think about the design of my software. Within weeks it has led me to creating much more powerful designs that I previously was capable of. Explained very well in a form that anyone with programming knowledge can understand.
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


1.0 out of 5 stars Poor as a textbook or a reference, 9 April 2013
By 
O. Sklyar (Switzerland) - See all my reviews
(REAL NAME)   
Verified Purchase(What is this?)
Whether you are an experienced developer or a novice, whether you looking for a reference or a text book this book will be of little help. In brief, it is too primitive for an intelligent reader.

Just like the majority of books in the field of computing, this one suffers from being written in an over-trivialised fashion and language and lacking a grounded logical structure.

In detail it suffers from the following issues. The book claims thinking in patterns and new paradigm of design, yet it merely repeats one and the same idea over and over again in a fairly unstructured way, which could be introduced and explained just once. The over-trivialised language, the quality of examples, the narrative, the overuse of the first form make it a pain to read if the reader has a habit of reading literature in general. The explanations are too wordy yet not too insightful, quite often they come to repeating what has been said before a number of times. Code examples could be more involved, more consistent and more accurate (in particular one should not be seeing 'myObject' variable names in a code snippet addressing a particular problem). Finally, the visual presentation of the book is quite poor: too many font styles and sizes on one page, yet not syntax highlight in code examples; the quality of tables and diagrams is poor, there is too much whitespace and repetitions of the table of content so the book could really be one third of the current size if formatted properly.
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


5.0 out of 5 stars Great book well written., 16 Jan 2013
Verified Purchase(What is this?)
This review is from: Design Patterns Explained: A New Perspective on Object-Oriented Design (2nd Edition) (Software Patterns Series) (Kindle Edition)
What can I say? This book is well presented and written. If you need a start in OO and patterns this is the best place to start.
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


3.0 out of 5 stars Tedious and long winded if you are experienced, 15 Jun 2011
By 
Karla Parussel (Munich, Germany) - See all my reviews
(REAL NAME)   
Verified Purchase(What is this?)
It's easy to read but tedious if software design is not new to you. The book reads like the author chatting to an inexperienced developer and trying to instil his own personal experience. Personally I don't want to read about someone else's career. I want to be able to put names to patterns that I have frequently had to derive myself so that I can demonstrate at job interviews that I know about patterns.

A pattern is a solution that comes up enough times that it might as well have a name. By their very nature patterns are obvious solutions if you understand the fundamental principles of software engineering and think about the problem for long enough. The problem almost always defines the solution. Unfortunately this book tries to describe a new perspective on Object Oriented design that frankly just isn't actually new. As with any technology, how it is actually used in practise evolves over time and changes from how it was first envisaged. Whilst reading this book a colloquial expression often came to mind that Dr Watson could have said to Sherlock Holmes if he had just stated the blindingly obvious.

This is most definitely not a reference book. You have to wade through bumpf about design and the personal experiences of the authors to find the sections describing specific patterns. Concise is not a word that I would use to describe this book. It's useful to know the names of patterns because it aids communication with other engineers, but if you want to find out what someone else is referring to then it will be faster to use wikipedia.

The only thing that I really learnt from this book was about the pitfall of implementing double checked locking in Java. Unfortunately Wikipedia gave a much more useful explanation.
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


3.0 out of 5 stars Should have been titled "Design Patterns BADLY Explained", 3 Oct 2010
Verified Purchase(What is this?)
I bought this book as I had been struggling with the GoF's classic patterns book ("Design patterns : elements of reusable object-oriented software" http://www.amazon.co.uk/gp/product/0201633612). I found that heavy going, and thought this might be a more gentle and easy to understand introduction to design patterns.

What I didn't realise is that the bulk of this book, ie the parts that describe the patterns themselves, does nothing more than rehash what the GoF did, but not as well. The depth (or lack of) that this book covers was in the first few pages of the GoF's description of each pattern, and the heavy stuff that the GoF added was missed out from this book altogether. What's worse is that the GoF had far better examples that made the patterns easier to understand. With the descriptions here, you just started to get the idea of what the pattern was about when the chapter ended. You were left with a feeling of being dropped right at the crucial moment.

To make matters worse, the "dozens of code examples" promised on the back of the book turned out to be very short and unhelpful. Whilst it's important to concentrate on only those bits of code that are relevant to the issue being discussed, you need enough code to see what's going on. This book has very little. In fairness, the web site has a lot more code to download, but the book should have had more code shown, instead of forcing you to wade through the downloaded files.

If you just want to learn the patterns, then you're WAY better off with the GoF book, and just skip anything you find too heavy.

This book spends far too much time on irrelevant points (like discussing things he's not going to cover). For example, it spends a whole chapter describing an example situation, making out that it's going to be a major part of the book, but then you find that it is then not used very much in the rest of the book. The bits that re used could have been described in one paragraph. What a waste of time!

The one thing that the GoF book doesn't do, that this one attempts to do is explain how to decide which pattern to use. This is a very important issue, as learning the patterns is really only the beginning. You need to know how and when to apply them. This books spends some time describing how to analyse your problem domain, and how to decide which patterns might be appropriate.

Unfortunately, this is all done in a fairly vague manner, and so it far less useful than it could have been. Had this part been done well, the book would have been worthwhile, even with my other complaints. However, as this part was fairly unclear, I don't think the book warrants more than three stars. The authors keep dropping hints about their courses, but if this is the way they teach, I can't see the courses being much good. I certainly wouldn't pay money to have them teach me!

It could be that repeated reading of the analysis section of the book might eventually help, but I don't have the time or interest to bash through it over and over again in the hope that it make become clearer. I'm sure there are better ways to learn this stuff.

A great disappointment.
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


5.0 out of 5 stars Please read to improve your code, 16 Oct 2009
By 
R. Grieve (UK) - See all my reviews
(REAL NAME)   
Really good narrative style that makes it easy to understand and, more importantly, remember the patterns listed in this book, and when and where to use them.
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


2 of 3 people found the following review helpful
3.0 out of 5 stars Too wordy, 15 Dec 2010
By 
J. Garrard (UK) - See all my reviews
(REAL NAME)   
Verified Purchase(What is this?)
I bought this instead of the GoF book because I had read reviews that the GoF book was too impenetrable, and this book was far more friendly. This was a mistake.

It certainly has a lot of explanation in it, but verbose does not necessarily mean clear. I found that the explanations were just too long winded for me to grasp the essence of each pattern. I got lost in the rambling.

I gave up when I reached the Bridge pattern chapter. This comes directly after the Strategy pattern chapter and although the patterns overlap to a very great degree it immediately starts describing yet another example problem domain in excruciating detail. As soon as I started reading the problem I thought, OK, so we can use the Strategy pattern here, it's exactly the same problem. The Strategy is never mentioned in the entire Bridge chapter. The same problems of using inheritence to solve multiple heirachies are labouriously explained once more, and the Bridge is given as the solution, which seemed identical to the Strategy. I ended up with no clue as to the difference between the two patterns after trolling through an incredible 32 pages on the Bridge!

I have since obtained a copy of the GoF book and was staggered to find that just by looking at the Bridge class diagram and reading the 2 page Motivation section I was instantly able to understand the difference. The GoF book seems far clearer in every respect. I'm not sure if this is because I've been a developer for many years, it may be that beginners find it more obscure, but I found the concise, clearly seperated explanations brilliant.

So for me as an experienced developer, the GoF book wins easily over this one. YMMV.
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


Most Helpful First | Newest First
ARRAY(0xadec0798)

This product

Only search this product's reviews