Kundenrezensionen


91 Rezensionen
5 Sterne:
 (71)
4 Sterne:
 (13)
3 Sterne:
 (5)
2 Sterne:
 (1)
1 Sterne:
 (1)
 
 
 
 
 
Durchschnittliche Kundenbewertung
Sagen Sie Ihre Meinung zu diesem Artikel
Eigene Rezension erstellen
 
 

Die hilfreichste positive Rezension
Die hilfreichste kritische Rezension


13 von 13 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen The best way to really learn object-oriented design
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...
Am 7. März 1997 veröffentlicht

versus
24 von 28 Kunden fanden die folgende Rezension hilfreich
3.0 von 5 Sternen Excellent concept but rather disappointing mistake density
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...
Veröffentlicht am 22. Dezember 1999 von Bob Stein


‹ Zurück | 1 210 | Weiter ›
Hilfreichste Bewertungen zuerst | Neueste Bewertungen zuerst

13 von 13 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen The best way to really learn object-oriented design, 7. März 1997
Von Ein Kunde
Rezension bezieht sich auf: Design Patterns. Elements of Reusable Object-Oriented Software. (Gebundene Ausgabe)
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 [...]
Helfen Sie anderen Kunden bei der Suche nach den hilfreichsten Rezensionen 
War diese Rezension für Sie hilfreich? Ja Nein


15 von 16 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen Abstrakt, aber sehr gehaltvoll, 19. Juli 2002
Rezension bezieht sich auf: Design Patterns. Elements of Reusable Object-Oriented Software. (Gebundene Ausgabe)
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.
Helfen Sie anderen Kunden bei der Suche nach den hilfreichsten Rezensionen 
War diese Rezension für Sie hilfreich? Ja Nein


5 von 5 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen Expand your programming vocabulary...difficult but worth it, 24. Juni 2000
Von 
JavaBarista (Encinitas, CA United States) - Alle meine Rezensionen ansehen
Rezension bezieht sich auf: Design Patterns. Elements of Reusable Object-Oriented Software. (Gebundene Ausgabe)
This is a book that you need to chew on for a while and which will take a while to digest once swallowed. It will, however, turn into pure programming muscle as payback for all your effort!
This is an academic treatise (it started out as a Master's thesis) and reads like one. But as you read you'll find yourself identifying with some of the patterns that you've unknowingly used in your own code. And you'll start seeing how you could have used other patterns. And before you know it, your approach to programming has changed and you are able to focus more on the domain-specific issues rather than getting caught up in the need to continuously re-invent the proverbial wheel. And the world looks a little bit brighter.
Any book that does that for you deserves 5 stars regardless of how dry it is.
Helfen Sie anderen Kunden bei der Suche nach den hilfreichsten Rezensionen 
War diese Rezension für Sie hilfreich? Ja Nein


29 von 33 Kunden fanden die folgende Rezension hilfreich
4.0 von 5 Sternen Der Klassiker - gute Grundlage aber nicht mehr aktuell, 7. September 2003
Von 
Rubas Dominic (Fischbach-Göslikon, Aargau Schweiz) - Alle meine Rezensionen ansehen
Rezension bezieht sich auf: Design Patterns. Elements of Reusable Object-Oriented Software. (Gebundene Ausgabe)
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!
Helfen Sie anderen Kunden bei der Suche nach den hilfreichsten Rezensionen 
War diese Rezension für Sie hilfreich? Ja Nein


4 von 4 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen A core book for any OO programmer., 15. Juni 2000
Von 
Mr. V. J. O'Sullivan (London, England.) - Alle meine Rezensionen ansehen
(REAL NAME)   
Rezension bezieht sich auf: Design Patterns. Elements of Reusable Object-Oriented Software. (Gebundene Ausgabe)
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.
Helfen Sie anderen Kunden bei der Suche nach den hilfreichsten Rezensionen 
War diese Rezension für Sie hilfreich? Ja Nein


4 von 4 Kunden fanden die folgende Rezension hilfreich
4.0 von 5 Sternen Must read, but requires some sophistication, 15. Mai 2000
Von 
Russell Belfer (San Mateo, CA United States) - Alle meine Rezensionen ansehen
(REAL NAME)   
Rezension bezieht sich auf: Design Patterns. Elements of Reusable Object-Oriented Software. (Gebundene Ausgabe)
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 Amazon.com]
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.
Helfen Sie anderen Kunden bei der Suche nach den hilfreichsten Rezensionen 
War diese Rezension für Sie hilfreich? Ja Nein


4 von 4 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen Not for the faint-hearted, but a must read., 10. Februar 2000
Von Ein Kunde
Rezension bezieht sich auf: Design Patterns. Elements of Reusable Object-Oriented Software. (Gebundene Ausgabe)
Obviously, this book is *the* most recognized reference work on software-related Design Patterns, and as such cannot be ignored. If you want to know about patterns, here is where to start.
The main asset of this book is in its trustworthiness and credibility - not such an easy thing to come by in computer books these days. I went through many if not most of the C++ examples in detail, and did not find a case where it didn't hold up, at least to the extent where it clarified what the point of the pattern was. The UML diagrams are also extremely helpful.
Be forewarned, however; this is not light reading. The examples are based on heavy-duty design tasks your average programmer doesn't face, like language-parsing, toolkit creation, compiler writing, and the like. It makes one wonder how applicable many of the patterns are to less complex programming tasks.
Also, most of the examples are in C++, so you really have to understand the syntax of C++ before you can get much value out of this book. Another drawback is that many of the examples are abridged, so at times you have to kind of extrapolate on what some of the code *would* look like in order to understand the examples. The chapter on Interpreter in particular was a tough nut to crack due to this. I actually would have liked to have seen *more* explanatory text associated with the code itself.
For all that, many of the patterns are pretty staightforward. The trick is to nail down that you "get it" for each pattern. One technique I found enormously helpful in accomplishing this was to write a summary of the pattern after reading a chapter - right in the book, so it can referenced later (there's often an entire blank page opposite the beginning of each chapter you can use for this). You may find yourself delving back into the chapter to confirm your understanding.
Overall, a challenging but ultimately rewarding read for anyone who wants to understand what design patterns are all about.
Helfen Sie anderen Kunden bei der Suche nach den hilfreichsten Rezensionen 
War diese Rezension für Sie hilfreich? Ja Nein


4 von 4 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen Required Reading. Absolutely Fantastic!, 10. November 1999
Rezension bezieht sich auf: Design Patterns. Elements of Reusable Object-Oriented Software. (Gebundene Ausgabe)
Design Patterns is required reading for all object-oriented designers, developers, and architects who want to improve and streamline their design skills. This book will open your eyes and teach you how to utilize widely accepted and standardized design patterns to implement efficient solutions for frequently encountered design challenges. You'll immediately recognize multiple instances within your own projects in which design patterns would have improved efficiency and reuse within the architecture.
The authors take a very methodical approach to describe every aspect of each design pattern including applicability, structure, collaborations, and consequences to name just a few. The book is extremely well organized making it easy to refer to the catalog for a refresher on various patterns.
One of the best OO books I've read.
Helfen Sie anderen Kunden bei der Suche nach den hilfreichsten Rezensionen 
War diese Rezension für Sie hilfreich? Ja Nein


4 von 4 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen You're going to have to buy this book sometime, 15. Juli 1997
Von Ein Kunde
Rezension bezieht sich auf: Design Patterns. Elements of Reusable Object-Oriented Software. (Gebundene Ausgabe)
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
Helfen Sie anderen Kunden bei der Suche nach den hilfreichsten Rezensionen 
War diese Rezension für Sie hilfreich? Ja Nein


24 von 28 Kunden fanden die folgende Rezension hilfreich
3.0 von 5 Sternen Excellent concept but rather disappointing mistake density, 22. Dezember 1999
Von 
Bob Stein (Lyme, NH) - Alle meine Rezensionen ansehen
(REAL NAME)   
Rezension bezieht sich auf: Design Patterns. Elements of Reusable Object-Oriented Software. (Gebundene Ausgabe)
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...
Helfen Sie anderen Kunden bei der Suche nach den hilfreichsten Rezensionen 
War diese Rezension für Sie hilfreich? Ja Nein


‹ Zurück | 1 210 | Weiter ›
Hilfreichste Bewertungen zuerst | Neueste Bewertungen zuerst

Dieses Produkt

Design Patterns. Elements of Reusable Object-Oriented Software.
Design Patterns. Elements of Reusable Object-Oriented Software. von John Vlissides (Gebundene Ausgabe - 31. Oktober 1994)
EUR 41,95
Auf Lager.
In den Einkaufswagen Auf meinen Wunschzettel
Nur in den Rezensionen zu diesem Produkt suchen