Sale Sale Hier klicken Jetzt informieren Xmas Shop 2017 Cloud Drive Photos UHD TVs Learn More TDZ Hier klicken Mehr dazu Mehr dazu Shop Kindle Rammstein BundesligaLive wint17

am 25. September 2017
It's been more than 20 years since first published and the most of the content of the book is up to date. That's what I call a classic.
0Kommentar|War diese Rezension für Sie hilfreich? Missbrauch melden
am 15. Juni 2000
In modern computer languages such as Java, creating Objects is a trivial task and almost as easy is making small numbers of Objects work together. However, there is a world of a difference between coding simple programs and developing commercial grade applications. Complexity increases exponentially. Something more is required in order to keep a handle on things. Design Patterns largely provide that answer.
Initially, this book is daunting. At first I couldn't make head nor tail of what they were talking about. This revealed serious shortcomings in my own knowledge that I had to put right but once done and starting with simple patterns (such as the Singleton) things began to make sense. Persevere and there is an awful lot of knowledge to be gained here. The intelligent application of Design Patterns into complex systems pays off hansomely in the long run.
My only critisisms of the book? Fairly minor really. The diagrams are all pre-UML. In fact they are they're own version of OMT diagrams. And an over reliance on Smalltalk for providing examples.
In the five years this book has been published much new work has been done on Design Patterns and it's time for a new edition of the book. Nevertheless, there aren't many computing books that are five years old and still of prime relevance. This is one.
0Kommentar| 5 Personen fanden diese Informationen hilfreich. War diese Rezension für Sie hilfreich? Missbrauch melden
am 15. Mai 2000
As you probably already realize from the large number of reviews, this book is one of the seminal books on patterns in software development. If you are a professional software developer, you must read this. If you are learning to write good software, this is a book that you will need to take on at some point, but I urge some caution.
In particular, many of the patterns in this book represent highly distilled wisdom about effective solutions -- distilled so far that, unless you have implemented code that realizes the pattern in question already, you may have trouble absorbing the material. I find that programmers-to-be who dive into this book, often end up talking annoyingly about "applying patterns" without having a real grasp of how these things translate (with some distortion and compromise) into real projects.
That being said, an excellent way to bridge the gap is to read this book along with "Pattern Hatching : Design Patterns Applied" by John Vlissides. That book is a chatty companion piece for this one -- I found myself understanding how to incorporate patterns into my day-to-day design work much more after reading both books.
See: Pattern Hatching : Design Patterns Applied [also at]
Overall, while this book is an extremely important contribution to software developers, it is structured in a way that makes the material difficult to absorb if you aren't approaching it with substantial previous knowledge about developing software. You can start with some of the simpler patterns (Singleton, for example) and work through the harder ones, but only by implementing projects and stumbling upon these yourself will you really feel a flash of recognition as you read them in the book.
0Kommentar| 6 Personen fanden diese Informationen hilfreich. War diese Rezension für Sie hilfreich? Missbrauch melden
am 7. März 1997
This book really changed my way of thinking about object-oriented design. The idea is that when designing a new class hierarchy, though implementation details may differ, you often find yourself using the same kinds of solutions over and over again. Rather than approaching each design task out of context as an individual, isolated problem, the strategy is to study the task and identify the underlying design pattern most likely to be applicable, and follow the class structure outlined by that pattern. It's a "cookbook" school of design that works amazingly well.
There are other advantages to this book. It isolates 23 of the most common patterns and presents them in detail. You wouldn't think that 23 patterns would be enough, but once you become adept at recognizing patterns, you'll find that a large fraction of the patterns you use in practice are among these 23. For each pattern, the book carefully presents the intent of the pattern, a motivating example, consequences of using that pattern, implementation considerations and pitfalls, sample code (C++ or Smalltalk), known uses of that pattern in real-world applications, and a list of related patterns.
Upon first reading, you will start to recognize these patterns in the frameworks you see. Upon second reading, you'll begin to see how these patterns can help you in your own designs, and may also start to see new patterns not listed in the book. Once you become familiar with the pattern concept, you will be able to originate your own patterns, which will serve you well in the future. One of the most valuable contributions of this book is that it is designed not merely to help you identify patterns, but to give you a sense of which patterns are appropriate in which contexts.
I think this book is particularly valuable to many C++ and Java programmers, because of the dynamic and flexible design philosophy it follows. (Its two fundamental principles of reusable OO design are: "Program to an interface, not an implementation" and "Favor object composition over class inheritance".) I've found that many C++ books unfortunately tend to emphasize a rather static and inflexible design philosophy. Many C++ programmers do not realize how the language and the books they've studied from have been limiting their thinking until they have been exposed to ideas from other lanugages. The authors of this book have obviously been influenced by other languages as well, especially Smalltalk, and have brought many of its best lessons to C++ design. Most Java books seem to take after the C++ books, even though Java is a more dynamic language. This book may help Java programmers take full advantage of the extra power offered by their language, if they look deeply enough into some of the lesser-known features its runtime system affords.
Last, but not least, this book is valuable because it names the patterns it uses, and so gives programmers a common vocabulary to describe design concepts, rather than particular implementations. You'll find yourself saying things like, "That would be a good use for a Decorator", or "Should we use a Facade or a Mediator in this case?" I encourage readers of this book to use this vocabulary with other programmers.
In summary, this is one of the few books that I think belongs on every programmer's "must-have" list. Not to overuse a cliche, but like object-oriented design itself, the pattern concept is one of those rare paradigm-shifts in computer programming. It is equally valuable to expert professional and novice student alike. The book has a home page at [...]
0Kommentar| 18 Personen fanden diese Informationen hilfreich. War diese Rezension für Sie hilfreich? Missbrauch melden
am 15. Juli 1997
The book commonly referred to as just "Design Patterns" begins with an introduction to Object Oriented Programming and continues with a catalog of design patterns. I wouldn't recommend this book as your first OOP book, but I believe that once you have a basic understanding of OOP, you can try to cope with some of the basic Design Patterns in this book. If you are an advanced OO programmer, it's helpful to just quickly review any pattern you're about to implement and examine possible implementation issues
0Kommentar| 4 Personen fanden diese Informationen hilfreich. War diese Rezension für Sie hilfreich? Missbrauch melden
am 7. September 2003
Dieses Buch war der Anfang einer fast unzählbaren Anzahl weiteren Bücher über Design Pattern und es ist noch heute der Klassiker schlecht hin.
[Gang of Four], wie dieses Buch vielfach auch genannt wird, muss in allen mir bekannten Büchern über Pattern immer wieder als Referenz herhalten.
Aus diesem Standpunkt her ist es zu empfehlen beim Studium von Design Pattern mit diesem Klassiker zu beginnen, da er viele Begriffe prägte und spätere Autoren sich darauf stützen.
Es ist jedoch zu sagen einige Ansichten/Lösungsvorschläge sind etwas verstaubt und es empfiehlt sich noch aktuellere Literarur zu besorgen.
Trotzdem sollte man sich nicht um das Studium dieses Buch drücken, als Einstieg ist in die Materie ist es wirklich gut geeignet aber auch als Nachschlagewerke zu einem späteren Zeitpunkt immer wieder praktisch.
Wobei man nicht herum kommt entsprechende Pattern mit aktuelleren evt. mehr problemspezifischen Literatur abzugleichen!
11 Kommentar| 31 Personen fanden diese Informationen hilfreich. War diese Rezension für Sie hilfreich? Missbrauch melden
am 19. Juli 2002
Der Klassiker über Entwurfsmuster, den jeder ernsthafte Softwareentwickler gelesen haben sollte. Entwurfsmuster erlauben nicht nur das Tradieren von Erfahrung, sondern ermöglichen vor allen Dingen durch Prägung von Namen für Entwurfsmuster die effektivere Kommunikation in einem Entwicklerteam. Dieses Buch bietet einen Katalog von Mustern der in drei Gruppen aufgeteilt ist:
(1) Muster für die Erzeugung von Objekt-Instanzen
(2) Muster zur Strukturierung von Klassen und Objekten
(3) Muster zur Aufteilung von Verantwortlichkeiten zwischen Objekten.
Sie werden anhand von Beschreibungen, Diagrammen und Beispielen erklärt, Implementierungsalternativen werden vorgeführt und Vor- und Nachteile diskutiert.
Es liegt in der Natur der Sache, dass dieses Buch etwas schwer zu lesen ist, da die beschriebenen Muster die Essenz von Erfahrung darstellen, die in sehr unterschiedlichen Situationen
verwendet werden können. Der Abstraktionsgrad erfordert eine aktive Auseinandersetzung des Lesers mit diesen Mustern. Dafür ist der Lerneffekt umso grösser.
0Kommentar| 16 Personen fanden diese Informationen hilfreich. War diese Rezension für Sie hilfreich? Missbrauch melden
am 2. Juli 1998
The authors define design patterns as: descriptions of communicating objects and classes that are customised to solve a general design problem in a particular context. A design pattern names, abstracts, and identifies the key aspects of a common design structure that make it useful for creating a reusable object-oriented design. The design pattern identifies the participating classes and instances, their roles and collaborations, and the distribution of responsibilities. Easy to wrap your mind around, eh? Design Pattern people are in love with the power of abstraction and generality. You might even say they prefer to impress rather than inform. However, somehow you are going to have to learn this stuff, even if only to get into the heads of the guys who designed the AWT. Try starting with the code samples in the Design Patterns book. You have to read this book at least twice before it begins to make any sense. However, if you want to call yourself a programmer you MUST understand this book. I hope somebody writes a version of this book for Java programmers. It is written from the perspective of C++ and Smalltalk. This is a book where the you want the hardcover version. You go back to it again and again.
0Kommentar| 2 Personen fanden diese Informationen hilfreich. War diese Rezension für Sie hilfreich? Missbrauch melden
am 22. Dezember 1999
I rate this book 5 stars for the idea and -2 stars for all the confounding little mistakes. Apologize, I don't have too many details because it was one of the few books I borrowed that I actually returned (and to the original owner).
I went through two of the patterns with full concentration, found mistakes in both and found they really did get in the way. Things were named or referenced in ways that just couldn't be right. I wrote to the authors about a few issues (e.g. on pg 275, Widget should reference DialogDirector, not aggregate it) and the response (Johnson, Vlissedes) was very kind and constructive. But I believe there is significant work remaining. You may think I'm being overly picky here (at issue on pg 275 is an itsy bitsy little shape), but try understanding something completely new when there is one mistake in it. You wonder if you're comprehending wrong.
I have a hunch that most folks here, pardon my presumption, who are rating high without reservation are really in love with the idea of finding patterns to design (as am I). But I wonder if they've ever really really tried to go through any of the examples at a finer resolution than a bird's eye view. The book does a lot to crystalize the dream of reusable design patterns but not as much as it could to wake us up to realizing it.
Still it's on my list of things to buy because it's darn thought-provoking. Maybe that's it's highest purpose: to announce, if only by the title, the shocking idea that there could be patterns to design, that programmers might not always have to reinvent the universe with each project. (The idea that they don't is not new, but the *fact* that they don't is making woefully slow progress.)
The big question I still have is did they pick really good patterns and objectify them with compassion and vision? Are these the very paradigms and clumps of computational power that will be in the toolbox of programmers yet unborn? Dunno. I suspect from the tactical gaffs that strategic corrections are in order.
Maybe 3 stars isn't harsh enough but it's certainly a pioneering book. I believe one significantly better will come out in the next decade. It would be nice (somehow in my rosy view of the world) if it were by some of the same guys...
0Kommentar| 26 Personen fanden diese Informationen hilfreich. War diese Rezension für Sie hilfreich? Missbrauch melden
am 8. Juni 2000
Everyone who claims to write object oriented code must read this book. You will benefit greatly from it, if for no other reason than that no one will take you seriously if you don't understand its terminology. Its ideas are not revolutionary, but its method of organizing them and studying them -- patterns -- is. Patterns give common names to common design practices, making it possible to discuss them with others.
If you can, borrow the book from a friend or library and read it at least once. Then decide whether you need your own copy. It should be reread every so often, as it is valuable not only for the patterns it presents, but for the systematic way in which it approaches problems. However, you do not need it on your desk to code. Indeed, it is too weighty and academic to serve as a reference. If you maintain a library of books on object oriented design, it is incomplete without this single book.
0Kommentar| 2 Personen fanden diese Informationen hilfreich. War diese Rezension für Sie hilfreich? Missbrauch melden

Gesponserte Links

  (Was ist das?)