|
Design Patterns: Elements of Reusable Object-Oriented Software (Addison-Wesley Professional Computing Series) (Hardcover)
by Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides
| Category:
Design patterns, Software development, IT, Technology |
| Market price: ¥ 558.00
MSL price:
¥ 548.00
[ Shop incentives ]
|
| Stock:
Pre-order item, lead time 3-7 weeks upon payment [ COD term does not apply to pre-order items ] |
MSL rating:
 Good for Gifts |
| MSL Pointer Review:
A modern classic in the literature of object-oriented development, it's a book of design patterns that describe simple and elegant solutions to specific problems in object-oriented software design. |
| If you want us to help you with the right titles you're looking for, or to make reading recommendations based on your needs, please contact our consultants. |
Detail |
Author |
Description |
Excerpt |
Reviews |
|
|
|
Author: Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides
Publisher: Addison-Wesley Professional
Pub. in: January, 1995
ISBN: 0201633612
Pages: 395
Measurements: 9.5 x 7.7 x 1.2 inches
Origin of product: USA
Order code: BA00543
Other information: 1st edition
|
|
Rate this product:
|
|
- Awards & Credential -
An Amazon.com top 1,200 book bestseller as of November 22, 2006. |
|
- MSL Picks -
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 undocument- ed, 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.
Each pattern describes the circumstances in which it is applicable, when it can be applied in view of other design constraints, and the consequences and trade-offs of using the pattern within a larger design. All patterns are compiled from real systems and are based on real-world examples. Each pattern also includes code that demonstrates how it may be implemented in object-oriented programming languages like C++ or Smalltalk.
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.
(From quoting Publisher and Fernando Galiano, Spain)
Target readers:
Programmers, Computer Science majors, Amateurs programmers, and University lecturers.
|
|
- Better with -
Better with
The C++ Programming Language (Special 3rd Edition)
:
|
|
Customers who bought this product also bought:
 |
Head First Design Patterns (Head First) [ILLUSTRATED] (Paperback)
by Elisabeth Freeman, Eric Freeman, Bert Bates, Kathy Sierra
Written in a typically Head First refreshing style, this is one of the easiest to read and absorb among the major reference sources for design patterns. |
 |
Refactoring: Improving the Design of Existing Code (Hardcover)
by Martin Fowler, Kent Beck, John Brant, William Opdyke, Don Roberts
Full of code examples in Java, easy to read and right into target, this book is a masterly and comprehensive reference on refactoring. |
 |
The Pragmatic Programmer: From Journeyman to Master (Paperback)
by Andrew Hunt, David Thomas
A classic reading on programming ranking with Code Complete and The Mythtical Man-Month. |
 |
The Mythical Man-Month: Essays on Software Engineering, 20th Anniversary Edition (Paperback)
by Frederick P. Brooks
Focusing on the human elements of software engineering, this classic offers insight for anyone managing complex development projects. |
 |
The C++ Programming Language (Special 3rd Edition) (Hardcover)
by Bjarne Stroustrup
Presents the complete C++ language and a discussion of design and software development issues. Provides an emphasis on tutorial aspects aimed at the serious programmer. |
|
|
Dr. Erich Gamma is technical director at the Software Technology Center of Object Technology International in Zurich, Switzerland.
Dr. Richard Helm is a member of the Object Technology Practice Group in the IBM Consulting Group in Sydney, Australia.
Dr. Ralph Johnson is a faculty member at the University of Illinois at Urbana-Champaign's Computer Science Department.
John Vlissides is a member of the research staff at the IBM T. J. Watson Research Center in Hawthorne, New York. He has practiced object-oriented technology for more than a decade as a designer, implementer, researcher, lecturer, and consultant. In addition to co-authoring Design Patterns: Elements of Reusable Object-Oriented Software, he is co-editor of the book Pattern Languages of Program Design 2 (both from Addison-Wesley). He and the other co-authors of Design Patterns are recipients of the 1998 Dr. Dobb's Journal Excellence in Programming Award.
|
|
From the Publisher:
Now on CD, this internationally acclaimed bestseller is more valuable than ever!
Use the contents of the CD to create your own design documents and reusable components. The CD contains: 23 patterns you can cut and paste into your own design documents; sample code demonstrating pattern implementation; complete Design Patterns content in standard HTML format, with numerous hyperlinked cross-references; accessed through a standard web browser; Java-based dynamic search mechanism, enhancing online search capabilities; graphical user environment, allowing ease of navigation.
First published in 1995, this landmark work on object-oriented software design presents a catalog of simple and succinct solutions to common design problems. Created by four experienced designers, the 23 patterns contained herein have become an essential resource for anyone developing reusable object-oriented software. In response to reader demand, the complete text and pattern catalog are now available on CD-ROM. This electronic version of Design Patterns enables program- mers to install the book directly onto a computer or network for use as an online reference for creating reusable object-oriented software.
The authors first describe what patterns are and how they can help you in the design process. They then systematically name, explain, evaluate, and catalog recurring designs in object-oriented systems. All patterns are compiled from real-world examples and include code that demonstrates how they may be implemented in object-oriented programming languages such as C++ and Smalltalk. Readers who already own the book will want the CD to take advantage of its dynamic search mechanism and ready-to-install patterns.
|
This book isn't an introduction to object-oriented technology or design. Many books already do a good job of that. This book assumes you are reasonably proficient in at least one object-oriented programming language, and you should have some experience in object-oriented design as well. You definitely shouldn't have to rush to the nearest dictionary the moment we mention "types" and "polymorphism," or "interface" as opposed to "implementation" inheritance.
On the other hand, this isn't an advanced technical treatise either. It's a book of design patterns that describes simple and elegant solutions to specific problems in object-oriented software design. Design patterns capture solutions that have developed and evolved over time. Hence they aren't the designs people They reflect untold redesign and recoding as developers have struggled for greater reuse and flexibility in their software. Design patterns capture these solutions in a succinct and easily applied form.
The design patterns require neither unusual language features nor amazing programming tricks with which to astound your friends and managers. All can be implemented in standard object-oriented languages, though they might take a little more work than ad hoc solutions. But the extra effort invariably pays dividends in increased flexibility and reusability.
Once you understand the design patterns and have had an "Aha!" (and not just a "Huh?") experience with them, you won't ever think about object- oriented design in the same way. You'll have insights that can make your own designs more flexible, modular, reusable, and understandable - which is why you're interested in object-oriented technology in the first place, right?
A word of warning and encouragement: Don't worry if you don't understand this book completely on the first reading. We didn't understand it all on the first writing! Remember that this isn't a book to read once and put on a shelf. We hope you'll find yourself referring to it again and again for design insights and for inspiration.
This book has had a long gestation. It has seen four countries, three of its authors' marriages, and the birth of two (unrelated) offspring. Many people have had a part in its development. Special thanks are due Bruce Andersen, Kent Beck, and Andre Weinand for their inspiration and advice. We also thank those who reviewed drafts of the manuscript: Roger Bielefeld, Grady Booch, Tom Cargill, Marshall Cline, Ralph Hyre, Brian Kernighan, Thomas Laliberty, Mark Lorenz, Arthur Riel, Doug Schmidt, Clovis Tondo, Steve Vinoski, and Rebecca Wirfs-Brock. We are also grateful to the team at Addison-Wesley for their help and patience: Kate Habib, Tiffany Moore, Lisa Raffaele, Pradeepa Siva, and John Wait. Special thanks to Carl Kessler, Danny Sabbah, and Mark Wegman at IBM Research for their unflagging support of this work.
Last but certainly not least, we thank everyone on the Internet and points beyond who commented on versions of the patterns, offered encouraging words, and told us that what we were doing was worthwhile. These people include but are not limited to Ran Alexander, Jon Avotins, Steve Berczuk, Julian Berdych, Matthias Bohlen, John Brant, Allan Clarke, Paul Chisholm, Jens Coldewey, Dave Collins, Jim Coplien, Don Dwiggins, Gabriele Elia, Doug Felt, Brian Foote, Denis Fortin, Ward Harold, Hermann Hueni, Nayeem Islam, Bikramjit Kalra, Paul Keefer, Thomas Kofler, Doug Lea, Dan LaLiberte, James Long, Ann Louise Luu, Pundi Madhavan, Brian Marick, Robert Martin, Dave McComb, Carl McConnell, Christine Mingins, Hanspeter Mossenbock, Eric Newton, Marianne Ozcan, Roxsan Payette, Larry Podmolik, George Radin, Sita Ramakrishnan, Russ Ramirez, Dirk Riehle, Bryan Rosenburg, Aamod Sane, Duri Schmidt, Robert Seidl, Xin Shu, and Bill Walker.
We don't consider this collection of design patterns complete and static; it's more a recording of our current thoughts on design. We welcome comments on it, whether criticisms of our examples, references and known uses we've missed, or design patterns we should have included. You can write us care of Addison-Wesley, or send electronic mail to design-patterns@cs.uiuc. You can also obtain softcopy for the code in the Sample Code sections by sending the message "send design pattern source" to design-patterns-source@cs.uiuc.
Mountain View, California - E.G.
Montreal, Quebec - R.H.
Urbana, Illinois - R.J.
Hawthorne, New York - J.V.
August 1994
|
|
| View all 11 comments |
Ben Mofaz (MSL quote), Israel
<2007-01-11 00:00>
There is no question that design patterns are an important part of object-oriented development, and this is the definitive work on that topic. As good as it is, it does have its weaknesses, although some of them can be dismissed as points that are mere personal preference. For example, I would have preferred that the code examples be written in Java, but I would not penalise the book because of that. In addition, the style of the writing is very academic, but that is probably due to the authors' background and may even have been done deliberately.
However, I did sometimes find the UML diagrams more confusing than helpful, and the code samples were somewhat sparse. The explanations were largely adequate, although I sometimes found myself having to re-read the description of a pattern many times before I felt that I understood it. Even though, I would sometimes wind up being confused about the difference between two patterns or exactly what a pattern represented. Part of this I think has to do with the nature of design patterns - they are by definition somewhat high-level and abstract. Even so, I could not help but think that they could have been described better, which is why I only give this book four stars. |
Peter Adell (MSL quote), USA
<2007-01-11 00:00>
This book is a classic computer science text. This is probably the one computer book that every computer programmer and software developer should read. It will definitely have an immediate impact on the code you write. Unlike most computer books, which have a shelf measured in months, this book has lasted the test of time, and will likely be relevant for many years. (At least as long as object-oriented programming languages are used!)
This book uses C++ and Smalltalk to code the examples, but don't worry about that. There are plenty of books that are basically "rewrites" of this book using Java or other langauges, but it doesn't matter what language your programming. I recommend this book over any other patterns book because these guys invented the subject. The patters can be programmed in any language, and you don't have to be a C++ or Smalltalk expert to understand them. |
Nadahalli (MSL quote), India
<2007-01-11 00:00>
I came across this classic pretty innocuously. Some colleagues suggested a design patterns study group and from that day I was hooked. This book teaches you more about Object Oriented programming than all the other OO books combined.Each pattern opens up another facet of Object Oriented programming. Once you are done with all the patterns, and then, done with them again, and then, done with them again you feel the euphoria of having understood something so abstract, but at the same time so tangible and visible around us. Be it Java, C++ or any other OO language, your design ideas and orgranizations become incredibly elegant and simple. This, is something you learn and appreciate only if you have gone through this book. And, here, by "done with them", I mean a thorough study, sample implementations, production implementations and the ability to recognize that pattern with its subtle variations.
The GoF book ( Gang of Four ) is structured as a manual of sorts, and it requires some orderly study. Look up Design Patterns Study Group on Google. The study orders suggested there are worth mulling over. The simple patterns are easy enough to understand ( Factory method and the like ) and the complex ones ( Visitor ) can be digested with the understanding of the basic patterns.
Again, at the end of the book, ( there is so end to this book, though ) you might actually end up mastering OO coding.
Couple of possible criticisms on this book is that you begin to think in patterns for every problem. Which might not be entirely good, and this book doesnt encompass the full world of pure OO patterns ( collecting parameter, for example ). But its still THE book to start with.
It also helps that this book has become a standard of sorts and the terms and jargon presented in this book are highly visible in the OO design and programming world. Worth a Buy, Worth a dozen reads. |
Mike Buckingham (MSL quote), USA
<2007-01-11 00:00>
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 concise books that do a better job of distilling the important concepts of design patterns and books that provide better modern approaches. 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 in-depth understanding or you can skip this step and go straight the a concise book that shows you how patterns are used practically today. |
View all 11 comments |
|
|
