Design Patterns: Elements of Reusable Object-Oriented Software (Addison-Wesley Professional...

Design Patterns: Elements of Reusable Object-Oriented Software (Addison-Wesley Professional Computing Series) | Erich Gamma, Richard Helm, ... | The lingua franca for OO design

books:

Design Patterns: E...

	Design Patterns: Elements of Reusable Object-Oriented Software (Addison-Wesley Professional Computing Series) Erich Gamma, Richard Helm, ... Addison-Wesley Professional, 1994 - 416 pages average customer review:based on 249 reviews view larger image
	for more information click here

highly recommended

A new language... for talking about proper designs

In software development, reuse is The Holy Grail. Reusing existing software artifacts is the most cost-effective way to reduce development time and effort. But code snippets and finished software components are not the only artifacts which can be reused. I am sure you already reuse your prior development experience when facing new challenges. This book is just about that. The Gang of Four (GoF) - as the authors are popularly known - were the first to record experience in object-oriented design to help developers improve their programming skills. As the book preface says, it "describes simple and elegant solutions to specific problems in object-oriented software design."

The GoF's book is the essential catalog of object-oriented design patterns:

1. Creational patterns make a system independent of how its objects are created, composed, and represented (e.g. object factories).

2. Structural patterns present ways to organize objects: how classes and objects are composed to form larger structures (e.g. wrappers, composites, and proxies).

3. Last, but nor least, behavioral patterns are concerned with the assignment of responsibilities among objects (e.g. chains of responsibility, publisher/subscribers, etc.).

Methodologies teach us how to proceed in software development projects, design patterns complement them by showing us elegant solutions to many of the problems we repeatedly face in the course of a software development project. Once you understand design patterns (and have an "Aha!" experience with them), they act as real eye-openers. As the authors claim, you will never see your designs in the same way.

P.S.: Many of the design patterns which are described in this seminal book are now part of the mainstream programming vocabulary, so you will probably find you already know of many of the design patterns described in this book.

for more information click here

The lingua franca for OO design

This book is a catalog of 23 design patterns that can be used to solve various problems in OO programs. Something that I don't think that other reviewers have mentioned is that once you become familiar with patterns, the debugging process can frequently be simplified as you can often quickly identify where a pattern has been implemented incorrectly and caused a problem. It also leads to quicker understanding of programs as you can see it as groups of interacting patterns that provide a better and more understandable demarcation of the areas of responsibility.

I find it useful even when working on non OO projects as well written code uses abstraction and encapsulation often results in equivalent constructs in procedural langauges.

I give it 4 stars because of the writing style. It tries to be very abstract but some of the descriptions lean too heavily on a specific terse example problem that I feel sometimes obscure the generic problem class the pattern addresses.

Note that this book is not written for any specific language (though the code examples are written in C++ and smalltalk).

for more information click here

Great book!

Very useful for languages that use classes, like Synopsys VMMM framework for SystemVerilog.

It's the classic text on design patterns

My only critique of the book is that it is very heavy on examples. It is all relevant and if you have the time to read and digest it all you will be a better programmer. However, there are more consice books that do a better job of distilling the important concepts of design patterns and books that provide better modern approachs. This is the type of book that you have to read in school becuase it is a classic. I would equate to classic literature like Homer or War and Peace. They are important in a scholarly sense if you wants a deep historic understanding of the topic. However, you can understand and use design patterns without reading other books and you will save a lot of time.

Another good analogy is the way calculus is taught in school. First they teach you in-depth complicated way. They take you through all the steps the inventor went through to come up with it. Then they show you the short cuts that are used in common practice. You have a better understanding of the topic because you know the hard way but you would be foolish not use the short cuts.

So you can read this book and get an indepth understanding or you can skip this step and go straight the a consice book that shows you how patterns are used practically today.

for more information click here

odi et amo

Object orientation is about dynamic binding, encapsulation, inheritance, and polymorphism. It's not necessarily about 20 patterns and their permutations. If you understand the basics, then you're set. But unless you're in an environment like Smalltalk where you can see OO unadulterated, then GoF is the next best thing.

The authors carefully format their presentation, and cross reference patterns for completeness. They review double dispatching (callbacks), pluggable adapters, lazy initialization, factories, deep vs shallow copying, and delve into detail, showing how misapplications can lead to unintended consequences.

GoF emphasizes early on that inheritance is overused. There are too many deep, inflexible layers of inheritance out there, a habit GoF helps snap.

Sometimes though, they lose the forest in the trees. Key ideas get lost in sub-topics, and while it took me awhile to be convinced that some patterns had a unifying idea, others are redundant.

For example, a Strategy is similar enough to a State pattern, since both extend functionality conditionally through collaboration rather than inheritance, and both will likely involve callbacks and fit the Visitor pattern as well. And instead of the Adapter, Mediator, and Observer patterns, I would have preferred a generalized discussion on event dependency and pluggable adapters with specific examples in increasing complexity and differentiation.

But there's an allure to the idea of 'patterns', and it helps sell components. 'Polymorphism' and 'Smalltalk': bad marketing. They sound like diseases and phobias. The names were fine in the early 90s, but now they are marketing to a wider audience upon whom those fine points will be lost. 'Patterns' and 'Java': good marketing.

All cynicism aside, this book is the only comprehensive analysis of object-oriented design patterns, with examples from programming languages mainstream and obscure, and goes so far as to advance an abstract set which we can all share. Now, whether or not seasoned developers will toss their old semantics out in favor of these is debatable, but younger programmers may find this reference to be their generational touchstone. Architects of any stripe should find something to ponder within its pages.

for more information click here