Customer Reviews

Object-Oriented Design Heuristics

5 star:		(23)
4 star:		(3)
3 star:		(3)
2 star:		(1)
1 star:		(0)

 

 

First, the greatness. These heuristics, rules of thumb, are true gems. The are short, memorable, and widely applicable. They are practical advice - Riel consciously avoids creating yet another methodology. Sooner or later, though, every methodology comes down to the tactical exercise of implementation. That's when you'll find Riel's advice useful, irrespective of how you started.

Riel certainly does not list the only heursitics possible. I might have added "Create classes when behavior differs; create objects when data differs", and I'm sure an experienced reader could add lots more. Some of these heuristics don't apply in all cases. "All base classes should be abstract," for example, might be tempered with concrete default bodies for some or all methods. Also, "All data should be hidden" is too dogmatic for me. It disregards 'const' or 'final' data elements including control constants, and deserves more discussion in the case of a subclass/superclass relationship. Still, the suggestions are generally good. Even better, they are phrased so as to invite thought and thoughtful critique by the reader.

I'm afraid that I did not find this book to be the ideal setting for these gems. Although the aphorisms are clear and concise, the prose around them is not. I know that publishers often prefer books of some minimum length, but padding does not serve the content well at all. Most of the book's second half is code listings. They certainly add bulk, but the book and the code both would have been better served by putting the code at the publisher's web site or on an included disk.

The discussion of each rule of thumb would have benefitted from a more disciplined style, too. For example, each heuristic could have been described methodically according to its applicability, the symptoms indicating that it should be used, and the code transformations needed to apply it. That's not the only format Riel could have used, and probably not the best. Almost anything would have given the book a more regular rhythm, however.

I like this book and I'll recommend it. It has aged a little since its 1996 printing, and wants desperately to be a more concise book. Still, it's a good complement to more recent discussions of patterns, antipatterns, and refactorings. I suggest it to anyone who develops or maintains OO code, and especially to anyone who teaches OO programming.

Wow. I wasn't expecting such an easy yet informative read. About 50 pages through this book, I wanted to hunt down the author's e-mail address and send him a personal thank-you letter. If you're experienced with language-specifics, and ready to get a grasp on the better ways to implement your designs so that they are more maintainable and logical, then grab this text. Riel explains things in a clear way, but the best thing about this book is that it follows the thought patterns of a typical reader. It's not pretentiously high-minded and verbose. Riel explains problems in common language, offers the common solutions, and then tells you in many ways how they can be improved. He covers "god-classes", encapsulation vs. inheritence, message passing, and much more.

Overall, this book is a very mind-opening experience, and I'd recommend it to anyone.

An outstanding book. You could spend years reading OO articles and books and still only find half the information this book contains. Riel has done the hard work for you. He presents the results as loads of practical guidelines on what to do/what not to do in OO development. Writing is clear and understandable, yet every sentence is packed full of information. This book will make you THINK about what you are doing.

Excellent. A must read for all serious OO developers.

Arthur Riel provides a concise treatment of the myriad design issues surrounding object-oriented software. His book is organized into sections, each treating one or more of his 68 heuristics, and each one short and informative. The level of experience needed to understand the book is minimal, but those with exposure to the more classical OOA&D authors are sure to get a few chuckles as Mr. Riel takes on design patterns and other tools of the trade, clearly making the point that there are no magic solutions to every problem. I concur with prior reviewers, who compare this book to the famous "Effective C++" books of Scott Meyer. A must-own.

The author doesnt waste words. He explains all his points well, with good examples, and is always to the point. You have to read the book carefully, and not just skim it, because while its short, its compact with a lot of great information conveyed in just a few paragraphs. He covered almost every OO subject I could think of, and in depth.

The book is outstanding and I couldn't put it down. (How many heavy tech books can you say that about?)

If you are new to OO programming and starting with Java I'd start with Beginning Java Objects. Then after a little experience I read this one. Don't read it too early in your career because a lot of it will just wash over you. It will be more beneficial if you have some experience before reading. You will learn and retain more. But its not a hard book to read, its very accessaible. The author is talented.

Allow me to add one more point to the excellent 5-star reviews that precede this one. As a long-time senior software developer, many of my peers and more junior engineers have asked me for a book recommendation so they can learn how to do object-oriented design. This is the book.

This is the book for UNDERSTANDING object-oriented software development. Whether you're learning OOD or improving your skills, this book makes OOD feel like common sense. As you read, the light clicks on and you think, "Oh. I get it," or, "Exactly!"

You won't need any other book on object-oriented design. This one is comprehensive and fun to read. And, it is perfect for a study group.

Don't learn OOD by making mistakes. Buy this book and design with confidence.

A typical design book tells you everything about encapsulation, inheritance etc. A novice programmer is then left in the vacuum of all that theory with the task to apply it. Some have luck and find good mentors, some learn the hard way by making the mistakes and correcting them (I hope).
As an alternative is this book that explains the common design problems and gives advice in the form of heuristics to solve them. Patterns are another and more popular approach to tackle this task. But you can use them both.
The novices will benefit the most. But this is not the book just for them. Experienced designers and programmers will nod most of the time and will find explanations for some design decisions they make without thinking. Which is good if you have to explain it to someone new.
This book is a valuable addition to your professional library.

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!

If you do OO development, please read this book! This book, along with the GoF Design Patterns book are in my OO development hall of fame. Riel does a great job of presenting good design approaches and rules of thumb that help to improve object-oriented designs. Each heuristic is backed up with examples rather than just being presented for you to accept verbatim. Riel also does a great job of pointing out some of the problem areas in OO -- areas that cause consternation for all OO developers. Being a perfectionist is tough in this industry, and Riel's coverage of sticky topics helped me to accept that sometimes there just isn't a "right" answer. A helpful touch: In a fashion similar to GoF, Riel lists his heuristics in the front and back covers of the book, with page references to the supporting material.

Buy this book NOW

Into the second chapter I was weary if this book was going to live up to its reviews. I was disappointed with the coverage of the explanations given. So why 5 stars?

As I continued I began to understand what the author was trying to give the reader. Reil describes guidlines for creating OO software, around 60 to be specific. This is so what makes the book so fantastic. Riel has, through much experience, collected a list of specific 'rules' or 'heuristics' that should be applied to your OO designs. These rules set out to answer the million dollar question, 'is this a good design?'. The rules are one or two sentences each, and therefore easy to remember, and are all listed in the front and back cover for quick reference. Each rule is backed by a clear example, as well as sample C++ code in the appendix.

Any reader should be able to apply the simple rules easily as they go through the design process. This will not only give you confidance in your designs, but something to actually back them up. For example, if asked "Why did you make a uses relationship between these two classes instead of inheriting B from A?" you can reply, either to yourself or a co-worker, "Heuristic 5.15 - Do not turn objects of a class into derived classes of the class. Be very suspicious of any derived class for which there is only one instance."

Of course, as Reil makes note, some rules will contradict each other, and he justifies what to do in such cases.

Finally, it should be noted that the book is highly centered on the C++ language, but is easily applied to the other languages of today - Java, C#, etc. He does make several comparisons with SmallTalk.

If I was working on a design with someone, I would want to know that they have read and understood this book. I hope it will live on, and will reccomend it to all my co-workers.