Location: Home > Computers & Internet > General > Design patterns : elements of reusable object-oriented software

Design patterns : elements of reusable object-oriented software

Authors: Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides
Publisher: Addison Wesley
Category: Book

List Price: ~~Ł41.99~~
Buy New: Ł24.92
You Save: Ł17.07 (41%)

New (46) Used (10) from Ł19.50

Rating: 4.5 out of 5 stars

35 reviews
Sales Rank: 9442

Media: Hardcover
Number Of Items: 1
Pages: 416
Shipping Weight (lbs): 2.3
Dimensions (in): 9.4 x 7.4 x 1.2

ISBN: 0201633612
Dewey Decimal Number: 005.12
UPC: 785342633610
EAN: 9780201633610
ASIN: 0201633612

Publication Date: March 14, 1995
Availability: Usually dispatched within 1-2 business days
Shipping: International shipping available
Condition: Ships from U.S.A., to anywhere in the United Kingdom! Orders only take 7-10 days! We specialise in service to the U.K. and only ship airmail.

Accessories:

•	Core J2EE Patterns (Sun Microsystems Press)
•	Java Web Services
•	Enterprise JavaBeans (Java Series)

Similar Items:

•	Refactoring: Improving the Design of Existing Code (Object Technology Series)
•	Head First Design Patterns (Head First)
•	Patterns of Enterprise Application Architecture (The Addison-Wesley Signature Series)
•	Effective C++: 55 Specific Ways to Improve Your Programs and Designs (Professional Computing)
•	UML Distilled: A Brief Guide to the Standard Object Modeling Language (Object Technology Series)

Editorial Reviews:

Amazon.co.uk Review
Design Patterns is based on the idea that there are only so many design problems in computer programming. This book identifies some common program-design problems--such as adapting the interface of one object to that of another object or notifying an object of a change in another object's state--and explains the best ways (not always the obvious ways) that the authors know to solve them. The idea is that you can use the authors' sophisticated design ideas to solve problems that you often waste time solving over and over again in your own programming.

The authors have come up with some ingenious ways to solve some common vexations among object-oriented programmers. Want to build a page-layout program that embeds inline images among characters of various sizes? How about building a program that converts files of one format to another? Chances are, some programmer already has thought of a better solution than you will and the recipes you need are here. Solutions are presented in generalised diagrams of data and logic structures. The idea is that you can take the concepts presented here and adapt them--in whatever language you use--to your individual situation. You may have to read some of the chapters several times before you fully understand them, but when you find a solution in this book, it will make your job easier and your results more elegant. --Jake Bond

Customer Reviews: Read 30 more reviews...

5 out of 5 stars

All current comments are valid January 31, 2008
Because I was advised to read this book and had good comments about it, I was really surprised to see even 1 single negative comment when starting my order process. I therefore started my reading with a sort of bitter feeling i was going to get either bored or over flooded with information.

Anyway, in the end I just want to point that yes it is a must read, but its writing could really be simplified. They also tend to repeat things alot, and suprisingly with the same words in a different order, which makes it very confusing, it's like finally understanding how something works and then looking at it in a mirror... I believe they wrote a very complex algorithm to write more pages ;)

5 out of 5 stars

If I could give it 6 stars... June 6, 2007
3 out of 4 found this review helpful

For the last 5 years I have been writing C++ code, and discovering coding 'patterns' for myself. Each time, I thought that there must be a book out there which documents these 'patterns', and would save me months of work figuring them out for myself. This is that book, and it does not disappoint.

The 23 patterns are built on a set of core principles. I was aware of these principles before, but seeing their application in pattern after pattern has given me a much better and deeper understanding of how and why to apply these principles in my own code.

I would probably have used some of the patterns, some of the time. But after such a clear and deep explanation of each one, I now see opportunities to use the patterns frequently. And in each case, I realise why my code will be better with them than if I hadn't used them.

Reading this book immediately improved my coding skills by an order of magnitude.

This book belongs on the shelf of every C++ coder, alongside Meyers 'Effective C++' and Beck's 'Extreme Programming Explained'.

5 out of 5 stars

This is the one the others talk about October 11, 2006
3 out of 3 found this review helpful

I read a couple of design patterns books before this one and quickly realised that I need to get this book as soon as possible. The others I've read all referenced it and as a design patterns catalog it presents patterns in the purest form. It is extremely easy to read in terms of clarity and layout and certainly in a format that will appeal to programmers. Although most examples are either in C++ or SmallTalk you should have no problem keeping up if you specialise in other languages including scripting languages like PHP5.

4 out of 5 stars

Not up-to-date but contains good guidelines August 24, 2006
0 out of 3 found this review helpful

This book was recomended to me during my undergrad degree on computer science; is a milestone of OO Programming, is well written and only a basic skill of OO is needed to read this book.

Unfortunatelly the book doesn't cover modern topic as data persistence, but gives you an overview of the most used general purpose patterns.

4 out of 5 stars

must read August 21, 2006
1 out of 2 found this review helpful

This is a good introduction to patterns and also covers some good implementation issues. It is an old book and the language samples show this - but patterns aren't language specific so this shouldn't be an issue if you focus on the concepts and problems the patterns overcome.