Object-Oriented Design Heuristics | 
| Author: Arthur J. Riel
Publisher: Addison-Wesley Professional
Category: Book
List Price: $59.99
Buy New: $35.98
You Save: $24.01 (40%)
New (24) Used (13) from $13.95
Avg. Customer Rating:  27 reviews
Sales Rank: 169901
Media: Hardcover
Number Of Items: 1
Pages: 400
Shipping Weight (lbs): 2.2
Dimensions (in): 9.3 x 7.6 x 1.3
ISBN: 020163385X
Dewey Decimal Number: 005.1
UPC: 785342633856
EAN: 9780201633856
ASIN: 020163385X
Publication Date: May 10, 1996
Availability: Usually ships in 1-2 business days
Shipping: Expedited shipping available
Shipping: International shipping available
|
| Similar Items:
|
| Customer Reviews: Read 22 more reviews...
 Very mediocre February 9, 2007
11 out of 16 found this review helpful
Regrettably, I disagree with the other reviewers here who seem to have liked this book. I didn't. Not that it's terrible: I found myself in agreement with most if not all of the rules of thumb the author talks about; the problem is more that this book is not well done.
First, this is a textbook; as such it is aimed at a student, that is someone who doesn't know the material yet and tries to learn. But for a tutorial this text overwordy and imprecise, with a generous quantity of confusing, misleading metaphors. If you happen to know what the author is trying to say, then you sorta get it -- I mean, you get it 'cause you already know it -- but a newcomer will be confused.
Sometimes the author doesn't seem to know why a particular rule is good, so he goes something like this: rule such-and-such is good because most software engineers would agree that it's good. I doubt the author conducted a statistically valid survey -- but forget that, suppose most software engineers do in fact agree: so what? All the author has now is a nice and juicy ad populum. But he, obviously, isn't even aware that something's wrong -- and that may be one of the problems with this book: the author may not be experienced enough to write books of this sort. He may be a competent practitioner, but this is not the same as teacher.
He tries to compensate via an over-abstract and smart-sounding terminology (one of the reviewers below jokingly complains that he needed to look up the word "heuristics": that is a telling comment, and it is valid. I, too, noticed that the author takes delight in using a dozen hifalutin words where one simple word would do (and result in a clearer text).
Riel also likes to belabour commonplace excessively ("data should be hidden inside objects"; "Objects should not depend on their users", blah-blah, brush teeth daily, apple a day etc.), anything to make the book thicker -- which brings me to its second defect, less important and quite a common one today: the book is blatantly padded. Out of about 400 pages only about 200 have readable text; the rest is mostly a source code printout (this code could have been supplied on an attached disk or put on the net somewhere). There's also a few pages with a concise restatement of the author's rules, which could have been printed on the cover insides (like in the Stevens network books) or supplied as a pullout; otherwise this list is hard to find and serves no purpose.
To summarize: were it better written, Heuristics could be useful for a newbie, but it's not and so it isn't. A more experienced reader, despite being annoyed, will understand it -- but only because he already knows the stuff himself and will be recognizing rather than learning. YMMV, but in my opinion this tome isn't worth reading time for any reader, new or experienced. I'm sending it back.
Perfect for experienced OO developers January 18, 2007
1 out of 1 found this review helpful
Ok, I had to look up heuristics in the dictionary before buying this. But other than that I found this to be one of only a handful I've read that tells you how to look at OOD work you've done and decide if it is good (and how to improve it). Particularly good was the discussion of cases where design goals conflict and how to resolve the conflict.
Every OO development team should have this book! December 13, 2006
OO design and analysis is so very gray. No book can cover every aspect because the possibilities are endless. Everyone's application and environment is different which causes each and every one of us to approach our design differently and value different affects of our coding practices. By far this is the best book I have read that simply lays out OO rules-of-thumb and then explains why each is beneficial and when they might contradict other rules-of-thumb. The book encourages the reader to be reasonable and practical in your application of OO best practices.
I strongly recommend that every development team read this book and discuss it amongst themselves.
Challenge what you know about OOA/D August 9, 2006
5 out of 6 found this review helpful
I have been studying the object oriented methodology for some time now. I felt that I had a good understanding of what OOP was all about. I have studied OOA/D and design patterns from numerous sources. All of my sense for OOA/D knowledge changed completely when I read this book. This book really showed me that I was stuck somewhere in the middle of the paradigm shift between action oriented programming (aka procedural programming) and object oriented programming. After reading this, I feel like my knowledge in OOA/D has truly advanced to the next level.
Are you the type of person that knows what OOP is? I mean, if you've studied up on OOP then you are probably aware of what an abstract class is. You know what interfaces, inheritance, polymorphism, information hiding (...etc) are. You may have a sense in when you should use inheritance and when you should use containment. You probably follow certain OOP practices like keeping all of your variables private, hiding secrets from other objects (information hiding). This may all make sense to you but are you also the type of person that just never feels comfortable about your designs? Do you look at your classes and just get a sense that something doesn't seem right, yet you just can't figure out what it is even if your software system is running fine? I am willing to wager that you are in the middle of a paradigm shift. You are probably taking the route that a lot of developers take when they shift from thinking in a procedural fashion (action-oriented design) into object oriented design. There is nothing wrong with this, but if you're like a lot of developers you will have a long hard journey utilizing a lot of experience before you really make that shift. This book is an essential tool that will help you make that shift a LOT faster. After reading this book you will see why you felt your designs were't quite right.
One of the first topics that really hit home for me was when the author Arthur Riel talks about God classes in chapter 3. God classes are classes that have too much implementation in them. Most of the complexity of a piece of software resides in these classes. They are the all-knowing classes that delegate messages between the much smaller, less complex classes. Signs of God classes are classes that have words in their name such as "Manager" or "System" in them. This one hit home because there are numerous classes in the software i'm working on now with the name Manager in them. For example one of our classes is called the "BiDirectional_Dataflow_Manager". This is definitely a God class through and through. While I was reading about the disadvantages of these types of classes I couldn't help but agree with everything Arthur was saying. I began to see the light already and I was just on chapter 3. There are 59 other Heuristics, all equally important in this book.
Most books that teach OOA/D seem to really only teach the definition of OOA/D and perhaps clue you in to the whole idea. You learn the terminology well and you see a few examples (I'm sure you've seen an animal hierarchy a time or two), but you don't really gain a solid understanding in how you actually think in objects. This book will bridge that gap. This is the best book i've read by far on OOA/D. This book will apply to you no matter what your skill level is in OOA/D, unless you're a complete beginner then you might find yourself a little bit lost. If you are brand new to OOA/D then you should probably read a short book on OOP, just to gain the basic concepts first. "Object Oriented Thought Process" might be a good start as it's short and sweet, then you should move on to this book. If you are advanced then you may know a lot of this information, but this book will probably help tweak your OOA/D skills; helping you become an even more solid developer. But for you guys and gals out there that know what OOP is and read a few books on it, but still don't feel quite right about your designs, this book is essential. You guys out there are the sweet spot for a book like this. That's how I was. Now I feel so much better, I feel like i've gained more knowledge in OOA/D with this book then all other books on OOA/D and OOP that i've read combined - and then some.
Arthur Riel is a very talented programmer and author. He is able to communicate ideas to you that are sure to hit home, as if he's right there with you and understands your problems in OOA/D. This book is densly packed. Not including the bibliography and index this book is a mere 367 pages. Even more, if you don't include the example code at the end of the book (all C++ code) this book is only 243 pages. The real meat of this book is in the first 9 chapters (where he talks about all of the heuristics), which totals 182 pages. After that he talks about topics such as handling memory leaks and such. Most of the dim lights will shine brightly after a mere 182 pages! This may sound too good to be true, but as I said earlier Arthur is VERY talented in communicating his ideas. You just have to read this book very carefully, don't skim! Because it's so dense, it may take a couple of passes before you really get the idea but once you understand it you will surely belt out a resounding "AH HA!". This book is 10 years old at the time of this review, but the information inside is far from being outdated.
To conclude this lengthy review (sorry about that) I would like to say that I give this book my highest recommendation. In fact, this may be the best book on software development that i've ever read! This book has influenced my software development more then any other book i've read and that's a fact. This is truly a rare gem. The only downside (not this books fault) is that it's become a bit harder to work on the software that i'm currently working with because I now see where all of the pitfalls are. My co-workers think i'm just being anal about design now, but you don't have to be like them. Step up, become the best software developer that you can be. Just read this book and you will take a giant leap forward in your OOA/D understanding, especially if you're stuck in a paradigm shift like I was. Thank you very much Arthur!
I've been searching for good books on design patterns... May 12, 2006
2 out of 2 found this review helpful
I have plenty of books on patterns, but I want to get more information on the basics of OOP and why the patterns are effective instead of "this is pattern X, and this what it does." This is a very complicated subject, which I have no doubt that most programmers on the planet have very little understanding of. We mostly write crummy code that "works", and most of the time that's good enough.
I was uncertain about getting this book because of how old it was, but after reading most of it, I'm happy I got it. Although complex, it is written in an understandable manner with useful diagrams. I wasn't as interested in the "one-liner" heuristics as I was the detailed explanations of the problems caused by particular design mistakes and the other examples and pitfalls presented.
|
|
|
