Rating: 
Summary: Reil answers the question - Is this a good design?
Review: 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.
Rating: 
Summary: Focuses on ¿why¿ instead of the usual ¿how¿
Review: 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.
Rating:
Summary: Thank you Arthur J. Riel
Review: 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.
Rating:
Summary: A book that's worth 10 stars
Review: An absolutely awesome book. One of the very best books I have ever read on software engineering. If you are an OO developer and you have not read this book, you are just wasting your time. An extremenly well written book from a man who knows what he is talking about. After years of Java programming now at last I started to understand why people do certain things in certain ways. It's both surprising and unfortunate that books like these don't sell more at Amazon. At least that's what the sales rank says. Before this book, I have wasted my money on horrible OO books by internationally known authors. And those books sell like hotcakes. Unfair.
Rating:
Summary: Excellent. Takes your OO thinking to new heights.
Review: 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.
Rating:
Summary: Short and sweet, an easy, informative read
Review: 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.
Rating:
Summary: Almost great
Review: 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.
Rating:
Summary: Facinating book
Review: Great book and the auithor is witty and thorough. For a potentially dry and heay subject his book is outstanding. You can read many pages at a time because its so well written and engaging.
Rating:
Summary: Good programmer's have their feet on the ground.
Review: Here's a pattern for you. Those most excitable about C++
are those who never had to maintain there own code, jumping
from one new project to the next, leaving behind something
to mop up. Maintenance programmer's the most battle
weary in the profession, are less enthusiastic about the
merits of C++, and OOP. Design Patterns are a great tool, and are a natural extentions
of the idioms seen in programming such as the 'pattern' of
iteration which requires a for loop. Where as iterating loops are tactical, design patterns are
strategical, and measured in terms of physicalness, patterns
affect many more lines of code and many more files. But get a pattern wrong, and you are more likely to
'blow your leg off', as Stroustrup put it. And what designer
is omniscient enough to get a complex business requirement
right the first time? And what design can ever be considered right when faced
with the ever changing business requirements? To prevent blowing your leg off with a misapplied pattern,
well, I highly recommend this book. Instead of GoF book
which can be hard to understand the first read through,
and so misapplied, this book give rules of thumbs.
And backs up each rule of thumb with good examples. It is so exicting to see, that I can literally, pick a
random page, and instantly, I can grasp it, debate it,
but learn something, and that it is concrete, and I can
instantly see how I might be able to apply it to this
or that situation. It is easy, because again Riel gives us rules of thumb,
which are a bette fit for how are minds fit than a complicated
symphony of patterns which you are bound to get wrong. Riel summarizes each chapter's rules on the inside
of the front and back covers of the book. He has a very lucid
and warm style. The fonts are gorgeous and the margins
wide enough for notes. His advice covers everything from very close code-level
rules about interfaces, to more overall rules about design
for instance the relationship between objects, classes,
and rules about inheritance and multiple inheritance. All of it quite easy to read, and all of it immediately
appicable, because, as I read Riel's credentials, Riel
has been teaching, and has 10+ years programming in the
industry. He did not forget to be a programmer for the
programmers, just to be a pure academian. I really believe that this is a book all programmers should
read if they want to keep their legs!!
Rating:
Summary: Required Reading for OO Developers
Review: 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
| 
