Arrr! Pirate Flag(Celebrate International Talk Like a Pirate Day) Thar be a hunt for treasure, Mateys!
This site uses cookies to deliver our services, improve performance, for analytics, and (if not signed in) for advertising. By using LibraryThing you acknowledge that you have read and understand our Terms of Service and Privacy Policy. Your use of the site and services is subject to these policies and terms.
Hide this

Results from Google Books

Click on a thumbnail to go to Google Books.

Design Patterns: Elements of Reusable…

Design Patterns: Elements of Reusable Object-Oriented Software (original 1994; edition 1994)

by Erich Gamma, Richard Helm, Ralph Johnson, John M. Vlissides

MembersReviewsPopularityAverage ratingMentions
2,772193,245 (4.13)4
Title:Design Patterns: Elements of Reusable Object-Oriented Software
Authors:Erich Gamma
Other authors:Richard Helm, Ralph Johnson, John M. Vlissides
Info:Addison-Wesley Professional (1994), Edition: 1, Hardcover, 416 pages
Collections:Home Library, Your library
Tags:Programming Reference

Work details

Design Patterns: Elements of Reusable Object-Oriented Software by Erich Gamma (Author) (1994)



Sign up for LibraryThing to find out whether you'll like this book.

No current Talk conversations about this book.

» See also 4 mentions

English (16)  Portuguese (1)  Dutch (1)  Hungarian (1)  All languages (19)
Showing 1-5 of 16 (next | show all)
It held my interest, but I find it hard to incorporate what seem like very abstract lessons like these into my actual programming practice. I guess I just don't think in OO. ( )
  Kenoubi | Sep 6, 2014 |
If there were required reading mandated for any degree involving computer software development, this would be it.

Gamma, et al (AKA The Gang of Four) have given us a comprehensive guide to various software patterns, and it's the least we could do to follow them.

It discourages me to see and hear about professional industries making lousy software that can't communicate with other tools, even those made by the same vendor. It bothers me when there are tools out there that make use of a network connection, but apparently don't play nicely with people using other operating systems or even other interfaces. Why can't I play Scrabble on my iPhone with someone using Facebook's Scrabble app? Why can't I play a co-op game of LittleBigPlanet on my PSP with another user playing on a PS3?

Well, the short answer is that you should be able to do these things, using interfacing, one of the fundamental patterns in this book. Just as the user (usually) doesn't care what's going on behind the curtain with their software applications, as long as they get the right feedback when the click the right buttons, the client-side application shouldn't care about what's going on in the server-side, as long as it gets the right feedback from the server when it sends it the right data. When you hear things like this for the first time, it's kind of eye-opening, but at the same time, when you think about it for a minute, it really makes sense. It's like when you're playing a puzzler game, and you need a hint about how to solve a puzzle; once you see the solution, you smack your head. "That's makes so much sense!" you say, "Why didn't I think of that." Well, consider this book the solution guide to software design.

No, it's not a recipe book (like the O'Reilly Cookbook series), but it does provide examples of the patterns you should be using, and unless you describe your coding style as "anarchist," it should really help you.

If you're a software engineer and get your hands dirty by mucking with software, and you haven't yet read this book, then take off those coding gloves and give yourself about a week to absorb the amazing knowledge this book presents. If you want to go into software engineering, ensure that you have a firm grasp of a particular programming language, and then read this book, preferably before you start interviewing for a job. Then, in your interview, when asked a technical question, you can start off your answer by saying, "Well, The Gang of Four said in their book on design patterns..." And then, you're working in some software engineering field (results may vary).

If you're truly devoted to making yourself a better software engineer, though, you simply must read this book. ( )
1 vote aethercowboy | May 26, 2009 |
This book was really a game-changer. The art of creating a computer program had not been analyzed much at all up until that point - plenty of algorithms had been created by computer scientists, and systems designers had some ideas about API's, but there wasn't a whole lot of direction for people who wanted to engineer applications to do things that user wanted them to do. Some of the patterns in the book are in common use today; others have been relegated to the dustbin; but the larger point is that after this book came out, people started using a whole new language to describe the work they were doing. Today we have UI patterns, management patterns, data access patterns, antipatterns, patterns, patterns, patterns everywhere, and this was the book that really caused the concept to take off.

Is it worth reading today? That's a little tougher. There's no question to my mind that every developer should be familiar with the patterns in this book, but a more modern book on the same topic would probably display source code in a language that more people would more commonly be using. Still, there's no question that if you want to go back to the basics, you go back to Gamma. ( )
  benfulton | Feb 10, 2009 |
The software design bible... ( )
  wanne | Nov 28, 2008 |
The original ( )
  naeemis | Oct 19, 2008 |
Showing 1-5 of 16 (next | show all)
no reviews | add a review

» Add other authors (26 possible)

Author nameRoleType of authorWork?Status
Gamma, ErichAuthorprimary authorall editionsconfirmed
Helm, RichardAuthormain authorall editionsconfirmed
Johnson, Ralph E.Authormain authorall editionsconfirmed
Vlissides, John M.Authormain authorall editionsconfirmed
Booch, GradyForewordsecondary authorsome editionsconfirmed
You must log in to edit Common Knowledge data.
For more help see the Common Knowledge help page.
Series (with order)
Canonical title
Original title
Alternative titles
Original publication date
Important places
Important events
Related movies
Awards and honors
First words
Designing object-oriented software is hard, and designing reusable object-oriented software is even harder.
Last words
Disambiguation notice
Publisher's editors
Publisher series
Original language
Canonical DDC/MDS
Book description
Haiku summary

Amazon.com Amazon.com Review (ISBN 0201633612, Hardcover)

Design Patterns is a modern classic in the literature of object-oriented development, offering timeless and elegant solutions to common problems in software design. It describes patterns for managing object creation, composing objects into larger structures, and coordinating control flow between objects. The book provides numerous examples where using composition rather than inheritance can improve the reusability and flexibility of code. Note, though, that it's not a tutorial but a catalog that you can use to find an object-oriented design pattern that's appropriate for the needs of your particular application--a selection for virtuoso programmers who appreciate (or require) consistent, well-engineered object-oriented designs.

(retrieved from Amazon Thu, 12 Mar 2015 18:12:59 -0400)

(see all 2 descriptions)

  Capturing a wealth of experience about the design of object-oriented software, four top-notch designers present a catalog of simple and succinct solutions to commonly occurring design problems. Previously undocumented, these 23 patterns allow designers to create more flexible, elegant, and ultimately reusable designs without having to rediscover the design solutions themselves. The authors begin by describing what patterns are and how they can help you design object-oriented software. They then go on to systematically name, explain, evaluate, and catalog recurring designs in object-oriented systems. With Design Patterns as your guide, you will learn how these important patterns fit into the software development process, and how you can leverage them to solve your own design problems most efficiently.  

» see all 4 descriptions

Quick Links

Popular covers


Average: (4.13)
1 2
1.5 2
2 12
2.5 1
3 85
3.5 13
4 160
4.5 14
5 181

Is this you?

Become a LibraryThing Author.


About | Contact | Privacy/Terms | Help/FAQs | Blog | Store | APIs | TinyCat | Legacy Libraries | Early Reviewers | Common Knowledge | 138,097,099 books! | Top bar: Always visible