Goodreads helps you keep track of books you want to read.
Start by marking “Design Patterns: Elements of Reusable Object-Oriented Software” as Want to Read:
Design Patterns: Elements of Reusable Object-Oriented Software
Enlarge cover
Rate this book
Clear rating
Open Preview

Design Patterns: Elements of Reusable Object-Oriented Software

4.19  ·  Rating details ·  10,348 ratings  ·  369 reviews
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 themse ...more
Hardcover, 416 pages
Published October 31st 1994 by Addison-Wesley Professional (first published 1994)
More Details... Edit Details

Friend Reviews

To see what your friends thought of this book, please sign up.

Reader Q&A

To ask other readers questions about Design Patterns, please sign up.

Be the first to ask a question about Design Patterns

Community Reviews

Showing 1-30
Average rating 4.19  · 
Rating details
 ·  10,348 ratings  ·  369 reviews

More filters
Sort order
Start your review of Design Patterns: Elements of Reusable Object-Oriented Software
Adnan Ali
Read to understand patterns, but please think for yourself when you code.
Jan 28, 2008 rated it did not like it
Shelves: code, nonfiction
I know this is an unpopular opinion, but I think the concept of a design pattern is just this side of bogus.

Part of the issue is that the languages the industry has chosen have weak powers of abstraction and thus these patterns seem necessary. Perhaps it's becoming a cliche (or became one 10 years ago?), but I'm sure some haven't yet been exposed to this thought: in a decent language like Lisp, most of these design patterns are trivial. The patterns are only there to make up for the problems wi
Noah Coad
Nov 14, 2010 rated it liked it  ·  review of another edition
Shelves: professional
A must have primer for any developer working with object oriented code. While it was a decent read from front-to-back (though a bit long), it is even more useful as a reference. Some of the terms are outdated by today's coding conventions, but the principles still apply and it is a fair exercise in mentally converting between the lingo used in the book and what you may be familiar with in C#, Java, or another OOP. One interesting aspect is that you can immediately start to see what programming p ...more
Jun 26, 2019 rated it it was amazing
[Note: This is a reference book; I didn't actually read it cover to cover. I did read the first two chapters in full though.]

For the last couple years, I've been working as a software engineer, and I've found myself getting very confused by a lot of our Java code. Why do we use dependency injection? What's a factory and why do we need them? It felt like everyone else on my team had gotten some memo that I didn't receive.

It turns out that everyone else on my team *did* get some memo that I didn't
Erika RS
Dec 28, 2012 rated it it was ok
Design Patterns is a very important reference and its contents are also important, but it is a rather dull book to read. This is mainly because the bulk of the book contains a catalog of patterns. Like most catalogs, it works better when you come to it looking for something specific.

I have two main criticisms of the patterns themselves, both of which stem more from the time the book was written than from any inherent problems with the patterns. First, each pattern contains a list of benefits and
Matt Hooper
Jun 03, 2007 rated it really liked it
Recommends it for: Software developers
This is the classic software design patterns book.

Much of this material is assumed knowledge in many development shops so a understanding of this book is very valuable. However, there seems to be a design pattern mania and some developers take the information in this book a bit too literally and assume these patterns are inflexible. The patterns themselves are of value but the bigger take away from this book is how to solve problems with object oriented languages. This is an excellent resource f
Milhouse Van Houten
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.
Jul 07, 2010 rated it it was amazing
I'd recommend this book to any Object-Oriented programmer who wants to be even remotely familiar with the approaches being used to write production systems these days... The Design Pattern based approach to software engineering has definitely caught on, and if you aren't familiar with at least the basic patterns, *you need to be* - not only to they make logical sense, but real development teams use the pattern names often, in discussions amongst multiple developers, to describe the systems/conce ...more
Ahmed Salem
Sep 16, 2014 rated it it was amazing
Beautiful Book for very complicated topic for developers and software architects. I liked the first chapter of introduction very much. and one of the best trends I have learned from this book is that, "You don't have to use all design patterns in the software you are making, just use what you think it is useful for the current situation and purpose of the current software you are working on now".

Merged review:

Beautiful Book for very complicated topic for developers and software architects. I lik
Aug 12, 2008 rated it liked it
Ahhhh ... design patterns. Most software engineers have probably used several of the patterns in this book without even realizing it. Still, I found it to be a useful validation of some of my design approaches as well as a valuable resource for streamlining my design. Reading it cover to cover will put any software architect in a position to solve many design issues faster than they may have otherwise.
Nov 15, 2019 rated it really liked it
I go back and reread sections of this book or skim it when I’m trying to think of a way to architect something. It’s pretty dry and the language the examples are in aren’t one that I typically use but easy enough to follow along. The diagrams are harder to get the hang of but otherwise, one of the must reads for anyone writing software.
Mohammad Shaker
Jul 30, 2012 rated it liked it
Probably a fourth read:
3 stars.

First Read:
5 stars. Although an old one, it's a very good book. Maybe the best on design patterns. The joy you feel when you read it and discover that you have implemented the solution by yourself before is really enriching.
Mark Miller
Aug 17, 2013 rated it liked it
I got this book as part of a job which had me programming in C++. I found it very helpful in understanding how to effectively use C++ so that it didn't kill me. It provides a vocabulary such that you can deal with data in a metalanguage of sorts, at least among colleagues (not in the sense of metaprogramming).

As time has passed, I've looked at Design Patterns in a new way. The introduction to the book is worth a read, even if you don't quite get the significance of it. If people would only take
The examples are somewhat out of date. The code can be a bit hard to follow because of this.

Some of the design patterns aren't really design patterns.

You can learn the the basics from this, though, so it's useful. Just be sure to read this with some more knowledgeable programmers so they can explain when the book doesn't.
John Chilton
Jul 08, 2010 rated it liked it
This book is a classic, you should read through it and it should sit on your bookshelf. But you should also read something newer and more accessible on design patterns as well, I recommend Head First Design Patterns.
Sep 05, 2016 rated it it was amazing
It's true that your need for patterns such as these depends heavily on your development stack, but love or hate, use them or don't, I believe it's critical to be familiar with them unless you plan to develop in a silo. ...more
Feb 10, 2018 rated it it was amazing
I've consulted this book on several occasions in my career, but never really read it from beginning to the end.
It's certainly an old one - 1994 (and therefore the code examples are not all that consistent with the modern trends ex. Smalltalk), and in something as fast evolving like software engineering this one is still more than relevant and go-to book for many experienced engineers.

Should be considered in every advanced object-oriented and even general software engineering course in colleges
Michał Niczyporuk
Jan 14, 2018 rated it it was amazing
This is a goodbook. Not an easy read, but definitely worth it for junior/mid-level OO developer. Every design pattern is explained thoroughly, and there are even 'consequences' sections on every one, and one connecting described pattern to other patterns. If you study every pattern you will get a mountain of knowledge.
The book is old. You can tell by Smalltalk and C++ examples. But its also a mountain of knowledge.
Jun 11, 2021 rated it it was amazing
An excellent survey of useful design patterns for object oriented design in software. Although a little dated with reference to technologies and languages (who uses Smalltalk still?), the core ideas and concepts are still very important in 2021’s software engineering world as well.
Jul 26, 2020 rated it it was amazing  ·  review of another edition
A classic.
I first read this book a decade or two ago, and I recently got feedback that I should read it again. It's nice to be more experienced and have more perspective on the text, instead of just taking everything as is. Some of the patterns (like Builder and Observer) I've seen used countless times. Other patterns, like Memento and Mediator, I've never seen in the real world.
If you're serious about software engineering read this book.

I wouldn't recommend this book for beginners - you should
Dec 10, 2020 rated it really liked it  ·  review of another edition
I had to read it cover to cover, although it took so much time. And it will definitely be a good reference book.
Leonora Minton
One-liner: Read it. 4.5 stars
Francesco Abeni
Aug 07, 2013 rated it really liked it
This is definitely a book worth reading.

The most difficult thing in it is not to understand the patterns themselves, but the underlying object-oriented knowledge. In other words: you won't understand patterns if you don't understand object-oriented programming. So, in some ways, this book will teach you OOP even more than it will teach you patterns.

Another drawback is in the examples. There's been a huge evolution since the book was written, and the current web applications are quite different
Every time I read this book it is like peeling an onion. Layers upon layers. And yet this book is still harder to use and process than I want it to be. It has been years since I read this cover-to-cover and certainly I got more out of it this time - but this book is still just at the wrong level for what I want. Then again that's what happens when you are first to a concept - the easier/better way appears later. ...more
Alex Allain
Dec 23, 2008 rated it it was amazing
The best part of this book is the description of design principles. The list of patterns (which take up most of the book) are really just concrete examples of those principles in action. You may find yourself referring to those lists in the future, however, for inspiration. Definitely useful to have around at all times as a reference.
Jan 04, 2013 rated it liked it
I used this fairly extensively as a reference guide, rather than reading it front to back. Coding without using the patterns outlined in this book is a mistake, your code will be easier to write, understand and run.
Otis Chandler
Apr 13, 2007 rated it really liked it
The classic computer science book.
Jul 16, 2008 rated it it was ok
Recommends it for: n00b developers
Shelves: work
Cliche at this point. In Java some of these, like Singleton, are actually anti-patterns. Most developers with 5-10 years OO development experience should already know these anyway.
Ivo Stoykov
Nov 26, 2011 rated it it was amazing
Classic in computer literature. Clear, very well structured and useful book. A must read for everyone interested in software development.
Camilo Uribe
Jan 26, 2013 rated it did not like it
I read this book a couple of years ago and didn't understand anything. Someday I will try Head First Design Patterns ...more
« previous 1 3 4 5 6 7 8 9 10 11 next »
topics  posts  views  last activity   
Convertir OST vers Office 365 1 1 Jul 14, 2021 12:50PM  
Outlook OST to PST Converter 1 1 Jul 14, 2021 12:25PM  
Perspektywy Plik OST przetwornik 1 1 Jul 14, 2021 07:43AM  
wie man Konvertieren ost zu pst 1 1 Jul 14, 2021 07:16AM  
convert ost to Office 365 1 1 Jul 12, 2021 09:41AM  
Migrer OST vers Office 365 1 1 Jul 09, 2021 10:50AM  
Convertir OST a PST 1 1 Jul 08, 2021 07:47AM  

Readers also enjoyed

  • Clean Code: A Handbook of Agile Software Craftsmanship
  • Refactoring: Improving the Design of Existing Code
  • Head First Design Patterns
  • The Pragmatic Programmer: From Journeyman to Master
  • Code Complete
  • Effective C++: 55 Specific Ways to Improve Your Programs and Designs
  • Introduction to Algorithms
  • Domain-Driven Design: Tackling Complexity in the Heart of Software
  • Test-Driven Development: By Example
  • Effective Java
  • The C Programming Language
  • The Clean Coder: A Code of Conduct for Professional Programmers
  • Patterns of Enterprise Application Architecture
  • The Mythical Man-Month: Essays on Software Engineering
  • Clean Architecture
  • Working Effectively with Legacy Code
  • JavaScript: The Good Parts
  • The C++ Programming Language
See similar books…

Goodreads is hiring!

If you like books and love to build cool products, we may be looking for you.
Learn more »
Erich Gamma is a Swiss computer scientist and co-author of the influential software engineering textbook, Design Patterns: Elements of Reusable Object-Oriented Software.

News & Interviews

Need another excuse to treat yourself to a new book this week? We've got you covered with the buzziest new releases of the day. To create our...
32 likes · 6 comments
“Design patterns should not be applied indiscriminately. Often they achieve flexibility and variability by introducing additional levels of indirection, and that can complicate a design and/or cost you some performance. A design pattern should only be applied when the flexibility it affords is actually needed.” 0 likes
“A design that doesn’t take change into account risks major redesign in the future.” 0 likes
More quotes…