PDF Ebook Object-Oriented Design Heuristics (paperback), by Arthur J. Riel
Do you know why you ought to review this website as well as what the relation to checking out book Object-Oriented Design Heuristics (paperback), By Arthur J. Riel In this contemporary age, there are lots of ways to get guide and they will be a lot easier to do. One of them is by obtaining guide Object-Oriented Design Heuristics (paperback), By Arthur J. Riel by on-line as exactly what we inform in the link download. Guide Object-Oriented Design Heuristics (paperback), By Arthur J. Riel can be a selection due to the fact that it is so correct to your requirement now. To get the book on-line is quite simple by just downloading them. With this opportunity, you could read guide anywhere and also whenever you are. When taking a train, waiting for listing, and also awaiting somebody or other, you can review this online publication Object-Oriented Design Heuristics (paperback), By Arthur J. Riel as a buddy once more.
Object-Oriented Design Heuristics (paperback), by Arthur J. Riel
PDF Ebook Object-Oriented Design Heuristics (paperback), by Arthur J. Riel
Make use of the innovative innovation that human creates now to find the book Object-Oriented Design Heuristics (paperback), By Arthur J. Riel quickly. Yet first, we will certainly ask you, how much do you love to check out a book Object-Oriented Design Heuristics (paperback), By Arthur J. Riel Does it constantly up until finish? For what does that book review? Well, if you actually enjoy reading, try to review the Object-Oriented Design Heuristics (paperback), By Arthur J. Riel as one of your reading compilation. If you just read the book based upon need at the time and also incomplete, you should aim to such as reading Object-Oriented Design Heuristics (paperback), By Arthur J. Riel initially.
Obtaining the publications Object-Oriented Design Heuristics (paperback), By Arthur J. Riel now is not type of difficult means. You can not just opting for e-book store or collection or borrowing from your good friends to read them. This is an extremely straightforward way to exactly get the book by on the internet. This on the internet publication Object-Oriented Design Heuristics (paperback), By Arthur J. Riel could be one of the choices to accompany you when having extra time. It will not squander your time. Believe me, the book will certainly reveal you new point to check out. Just invest little time to open this on the internet e-book Object-Oriented Design Heuristics (paperback), By Arthur J. Riel as well as read them wherever you are now.
Sooner you get the e-book Object-Oriented Design Heuristics (paperback), By Arthur J. Riel, faster you could take pleasure in reading the book. It will be your rely on keep downloading guide Object-Oriented Design Heuristics (paperback), By Arthur J. Riel in offered web link. In this way, you can truly making a decision that is served to obtain your personal e-book on-line. Below, be the first to obtain guide entitled Object-Oriented Design Heuristics (paperback), By Arthur J. Riel and also be the initial to know exactly how the author implies the message as well as understanding for you.
It will believe when you are going to select this publication. This inspiring Object-Oriented Design Heuristics (paperback), By Arthur J. Riel e-book could be read completely in specific time relying on just how usually you open and read them. One to keep in mind is that every publication has their own manufacturing to get by each visitor. So, be the good reader and be a far better person after reviewing this book Object-Oriented Design Heuristics (paperback), By Arthur J. Riel
Here is the first object-oriented development book to provide specific experience-based guidelines to help developers make the right design decisions. This book offers the next step for readers that know the basics of object-oriented development and now need to know if they are doing it right and making the right choices.
- Sales Rank: #2050325 in Books
- Published on: 1996-05-10
- Ingredients: Example Ingredients
- Original language: English
- Number of items: 1
- Dimensions: 9.00" h x .90" w x 7.30" l, 1.50 pounds
- Binding: Paperback
- 400 pages
From the Inside Flap
In the process of teaching object-oriented analysis, design, and implementation to several thousand students, it became clear to me that the industry was in serious need of guidelines to help developers make proper decisions. Since 1987 I have scoured the literature in search of productivity and complexity metrics that can be applied at different levels of development to improve an object-oriented application. I added my own "homemade" guidelines to those found in the literature and came up with approximately 60 guidelines, several of which are tongue-in-cheek yet no less important than any others. I briefly considered calling them the "Sixty Golden Rules of OOA/D," but I recalled Dykstra's legendary "Goto Considered Harmful" paper, which branded users of goto statements heretics who should be burned at the stake in the company courtyard. That paper was important in that it provided an industry rule that stopped the users of goto statements who were destroying, wittingly or unwittingly, the maintainability of their systems. Unfortunately, the side effect of such a rule was the breeding of a group of pathological authors who, for the past 25 years, have published articles stating that the judicious use of a goto statement in some picky little piece of an application is more readable than a corresponding piece of structured code. Of course, these papers were followed up by a half-dozen rebuttal papers, which were themselves rebutted ad nauseam.
In order to prevent the same pathology from occurring, I refer to these 60 guidelines as "heuristics," or rules of thumb. They are not hard and fast rules that must be followed under penalty of heresy. Instead, they should be thought of as a series of warning bells that will ring when violated. The warning should be examined, and if warranted, a change should be enacted to remove the violation of the heuristic. It is perfectly valid to state that the heuristic does not apply in a given example for one reason or another. In fact, in many cases, two heuristics will be at odds with one another in a particular area of an object-oriented design. The developer is required to decide which heuristic plays the more important role.
This book does not invent yet another object-oriented analysis or design methodology, though the idea of creating "Riel's OOA/D Methodology" was tempting. The industry already has enough methodologies offering similar or overlapping advice, using a completely different vocabulary for common concepts. The typical problem of the object-oriented developer - which has not been seriously addressed - occurs once a design has been completed, regardless of the methodology used. The developer's main question is, "Now that I have my design, is it good, bad, or somewhere in between?" In asking an object-oriented guru, the developer is often told that a design is good when "it feels right." While this is of little use to the developer, there is a kernel of truth to such an answer. The guru runs through a subconscious list of heuristics, built up through his or her design experience, over the design. If the heuristics pass, then the design feels right, and if they do not pass, then the design does not feel right.
This book attempts to capture that subconscious list of heuristics in a concrete list backed up by real-world examples. The reader will become immediately aware that some heuristics are much stronger than others. The strength of a heuristic comes from the ramifications of violating it. The reader does not get a prioritized ordering of the heuristics. It is my feeling that in many cases the sense of priority is defined by a combination of the application domain and the user's needs and cannot be quantified here. For example, a common area of design where two heuristics might request opposite directions are those that trade complexity with flexibility. Ask yourself which attribute a software designer desires most, increased flexibility or decreased complexity, and you begin to see the problem of prioritizing heuristics.
The design heuristics are defined on a backdrop of real-world examples focusing on the area of design to which each heuristic belongs. The foundation of real-world examples provides an ideal vehicle for explaining the concepts of object-oriented technology to the novice. The end result is that this book is appropriate to the newcomer who would like a fast track to understanding the concepts of object-oriented programming without having to muddle through the proliferation of buzzwords that permeates the field. Yet, at the same time, it appeals to the experienced object-oriented developer who is looking for some good analysis and design heuristics to help in his or her development efforts.
The first chapter looks at the motivation for object-oriented programming, starting with several issues which Frederick Brooks argued in his "No Silver Bullet" paper published in 1987 (see reference 1). My perspective on object-oriented programming is that it is a natural progression or evolution from action-oriented development. As software has become more complex, we are required to remove ourselves one more level away from the machine in order to maintain the same grasp we have on the software development process. Just as structured methodologies removed one level from bottom-up programming, object-oriented technology removes one level from structured methodologies. It is not that bottom-up programming or structured methodologies are wrong and object-oriented programming is right. Bottom-up programming is perfectly valid when there exists only 4K of memory to develop, just as structured methodologies are perfectly valid when only 256K of memory exists. With the advent of increasingly cheaper and more powerful hardware, the complexity of software has skyrocketed. Developers of the early 1980s did not have to consider the complexity of graphical user interfaces and multithreaded applications; simpler menu-driven, single-threaded systems were the norm. In the very near future, no one will buy a software product unless it incorporates multimedia with moving video and voice recognition. The more complex systems require a greater level of abstraction, which the object-oriented paradigm provides. This is no revolution in software development; it is simply an evolution.
Chapter 2 discusses the concepts of class and object, the basic building blocks of object-oriented technology. They are viewed as the encapsulation of data and its related behavior in a bidirectional relationship. The notion of sending messages, defining methods, and inventing protocols are explored through real-world examples. This is the first chapter to list heuristics. Given the small subset of the object paradigm with which to work, these heuristics are fairly simple but no less useful than the more complex heuristics of subsequent chapters.
The third chapter examines the difference between an action-oriented topology and an object-oriented topology. The different topologies of these methodologies contain the kernel of truth behind object-oriented development. Action-oriented development focuses largely on a centralized control mechanism controlling a functionally decomposed set of tasks, while object-oriented development focuses on a decentralized collection of cooperating entities. I am convinced that the notion of a paradigm shift is the change in thinking required to move from a centralized to a decentralized control model. The learning curve of object-oriented development is an equally large unlearning curve for those of us reared in the world of action-oriented development. The real world in which we live is more attuned to the object model than to a centralized control mechanism. The lack of a paradigm shift manifests itself in systems that consist of a central godlike object that sits in the middle of a collection of trivial classes. These systems are built by developers stuck in the mindset of an action-oriented topology. This chapter proposes numerous heuristics for developing optimal application topologies.
Chapters 4 through 7 examine each of the five main object-oriented relationships: uses (Chapter 4); containment (Chapter 4); single inheritance (Chapter 5); multiple inheritance (Chapter 6); and association (Chapter 7) through a series of real-world examples. Most of the heuristics of interest to the object-oriented designer can be found in these chapters. The chapters on inheritance include many examples of the common misuses of the inheritance relationship. This information is vital in reducing the proliferation of classes problem, such as designing too many classes for a given application. The class proliferation problem is a major cause of failure in object-oriented development.
Chapter 8 examines the role of class-specific data and behavior, as opposed to object-specific data and behavior. The invoice class is used as an example of an abstraction that requires class-specific data and behavior. Both the SmallTalk metaclass and the C++ keyword mechanisms are illustrated. In addition, the notion of C++ metaclasses (i.e., templates) is compared and contrasted to the SmallTalk notion of metac
From the Back Cover
Upon completion of an object-oriented design, you are faced with a troubling question: "Is it good, bad, or somewhere in between?" Seasoned experts often answer this question by subjecting the design to a subconscious list of guidelines based on their years of experience. Experienced developer Arthur J. Riel has captured this elusive, subconscious list, and in doing so, has provided a set of metrics that help determine the quality of object-oriented models.
Object-Oriented Design Heuristics offers insight into object-oriented design improvement. The more than sixty guidelines presented in this book are language-independent and allow you to rate the integrity of a software design. The heuristics are not written as hard and fast rules; they are meant to serve as warning mechanisms which allow the flexibility of ignoring the heuristic as necessary. This tutorial-based approach, born out of the author's extensive experience developing software, teaching thousands of students, and critiquing designs in a variety of domains, allows you to apply the guidelines in a personalized manner.
The heuristics cover important topics ranging from classes and objects (with emphasis on their relationships including association, uses, containment, and both single and multiple inheritance) to physical object-oriented design. You will gain an understanding of the synergy that exists between design heuristics and the popular concept of design patterns; heuristics can highlight a problem in one facet of a design while patterns can provide the solution.
Programmers of all levels will find value in this book. The newcomer will discover a fast track to understanding the concepts of object-oriented programming. At the same time, experienced programmers seeking to strengthen their object-oriented development efforts will appreciate the insightful analysis. In short, with Object-Oriented Design Heuristics as your guide, you have the tools to become a better software developer.
020163385XB04062001
About the Author
Arthur J. Riel has more than twelve years of experience programming in C and C++ and currently teaches more than forty courses per year in both corporate and academic environments. He has participated in the development of many large systems, working with AT&T Bell Laboratories, Draper Laboratories, IBM, and Northeastern University. He has written numerous articles for publications including the "Journal of Object-Oriented Programming," the "C++ Insider," and the "C/C++ Gazette," He is also a frequent lecturer at leading conferences including OOPSLA, Object Expo, SCOOP, and C++ World.
020163385XAB04062001
Most helpful customer reviews
36 of 37 people found the following review helpful.
Almost great
By wiredweird
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.
3 of 3 people found the following review helpful.
I've been searching for good books on design patterns...
By Hannascandles
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.
10 of 11 people found the following review helpful.
Challenge what you know about OOA/D
By Steven
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!
See all 36 customer reviews...
Object-Oriented Design Heuristics (paperback), by Arthur J. Riel PDF
Object-Oriented Design Heuristics (paperback), by Arthur J. Riel EPub
Object-Oriented Design Heuristics (paperback), by Arthur J. Riel Doc
Object-Oriented Design Heuristics (paperback), by Arthur J. Riel iBooks
Object-Oriented Design Heuristics (paperback), by Arthur J. Riel rtf
Object-Oriented Design Heuristics (paperback), by Arthur J. Riel Mobipocket
Object-Oriented Design Heuristics (paperback), by Arthur J. Riel Kindle
Object-Oriented Design Heuristics (paperback), by Arthur J. Riel PDF
Object-Oriented Design Heuristics (paperback), by Arthur J. Riel PDF
Object-Oriented Design Heuristics (paperback), by Arthur J. Riel PDF
Object-Oriented Design Heuristics (paperback), by Arthur J. Riel PDF
