Object Design: Roles, Responsibilities, and Collaborations

Rating:
Summary: Effective methods for design, tunable for your agility level
Review: Generally excellent language and flow. The book manages to bob nicely at a readable level, ducking deep when necessary for some details, and popping back up for abstract concepts at appropriate times. Throughout, it's filled with reasonable examples about how to really design systems. The examples are nicely balanced between being trivial and too complex. They get a lot of richness out of the analysis without burying the reader in domain-specific details.

What they present seems to be compatible with most development processes. It's highly tunable to the level of 'agility' you're looking for, even from component to component.

One downside is that it only talks about the dangers of over-engineering when it gets to the flexibility chapter (late in the book). It would've been nice to see this earlier, particularly when talking about identifying candidates. Also, the discussion of flexibility also ignore versioning. I don't know anybody who owns something they can just change as they please, and it would've been nice to have a framework for the kinds of things you can expect to be able to change in subsequent architecture versions and the kinds of decisions that you're making and won't be able to change without major system incompatibilities.

Finally, the chapter that used UML said something like "we're not going to introduce UML" and then spewed UML at me for twenty pages, gently lulling me towards sleep. It killed the otherwise stellar pace that the book had going for it, but immediately recovered after that.

Rating:
Summary: Total Disappointment for Programmers
Review: I am a developer/programmer for a technical software company and my review contains my perception of this book from that perspective. I must also disclose that I am sceptical of any object-oriented design methodology that involves a lot of writing. We are "programmers", not story writers (read use cases).

When I ordered this book a week ago, I couldn't wait to get my hands on this book because it sounded so promising. My enthusiasm turned into total disappointment so quickly I couldn't believe myself; I had to give another shot in reading this book to make sure. But I am convinced; the authors managed the impossible task of filling its 390 pages without saying anything substantial about object-oriented design for a professional software developer.

The book might be useful for a novice programmer or a manager in terms of defining the object design jargon and process. But other than this, it provides no valuable advice for a professional. These are some of the points that I find ridiculously simplistic and almost idiotic:

- In my opinion use cases and CRC cards all boil down to writing on a piece of paper what classes one should use and what these classes should do. This is not methodology, it is common sense. Any sensible developer would write down his/her ideas about the classes involved in an application before starting to program.

- Although it is valuable advice to think about class responsibilities, the book states nothing more than the obvious in terms of finding what responsibilities should be assigned to which classes. Statements like "Responsibilities come from statements or implications of system behavior found in use cases" are tautologies. Where else would they come from!

- Or the chapter on Flexibility says things like "Find out what you don't know". I can't even begin to elaborate on philosophical implications of such advice!

Although the book looks appealing to the eye, it has no clear content. It states ideas about classes, responsibilities, etc without a clear structure; and after a while, everything said seems to be a repetition of some earlier statements.

If you are serious about object-oriented design as a "programmer" I recommend these three books:

1. Gamma E., et al., Design Patterns.
2. James R Rumbaugh, et al., Object-Oriented Modeling and Design. A bit dated, but you will get all you need to know about object oriented design from this book.
3. Bjarne Stroustrup, The C++ Programming Language (Special 3rd Edition). Never mind it is a C++ book. Chapters on OOD (I think chapters 21-25) will tell you exactly what you need to understand to start programming using OO approach.

Do yourself a favor and invest in these books; and ignore all the fab about such trendy books such as the one reviewed above.


Rating:
Summary: object design recommendation
Review: I purchased this book a week ago, and am enjoying it immensely. This
is NOT a book by authors that rapidly churn out multiple books, and it
is NOT a book to be read quickly. It's clear that a lot of thought
has gone into every page and every sentence, and that you need to
reflect and compare with your own professional programming experience.
Despite the huge amount of information, I'm finding the book very
readable. The authors make a living consulting on architecture and
design, and know how to communicate.

There are some code examples in java, but the book is really language
neutral. The java code uses features that are available in all object
oriented languages, and can really be considered to be illustrative
pseudo code. This book is written for software architects, and coders
who are looking to advance to higher levels of design responsibility.

A nice touch that I appreciated was the short summarizing side bars
sprinkled throughout the text. If you want to quickly evaluate whether
this book is for you are not, just pick up the book and read the
sidebars from beginning to end.

Rating:
Summary: object design recommendation
Review: I purchased this book a week ago, and am enjoying it immensely. This
is NOT a book by authors that rapidly churn out multiple books, and it
is NOT a book to be read quickly. It's clear that a lot of thought
has gone into every page and every sentence, and that you need to
reflect and compare with your own professional programming experience.
Despite the huge amount of information, I'm finding the book very
readable. The authors make a living consulting on architecture and
design, and know how to communicate.

There are some code examples in java, but the book is really language
neutral. The java code uses features that are available in all object
oriented languages, and can really be considered to be illustrative
pseudo code. This book is written for software architects, and coders
who are looking to advance to higher levels of design responsibility.

A nice touch that I appreciated was the short summarizing side bars
sprinkled throughout the text. If you want to quickly evaluate whether
this book is for you are not, just pick up the book and read the
sidebars from beginning to end.

Rating:
Summary: Very Good Text on Object Design
Review: I think I finally have a handle on object modeling-- 'Object Design' deserves a lot of the credit.

I have a shelf full of books on UML, uses cases, patterns, and modeling. I spent almost a year struggling through UML, trying to understand the nuances of sequence diagrams versus collaboration diagrams. Meanwhile, I felt no closer to being able to create serviceable object models for my projects.

Rebecca Wirfs-Brock and Alan McKean dispense with much of the tedious diagramming one usually associates with object modeling. Instead of charts and relationships, the book focuses on the roles, responsibilities, and behaviors that define an object. If you have ever assembled and managed employee teams, the framework will be very fmailiar. And that's where I found my breakthrough.

The book offers a good introduction to object modeling for those new to the area, and a solid reference for those looking to stremline their current methodology. The processes suggested by the authors are simple and flexible. But they are powerful enough to handle even complex designs.

One of the strongest pieces of advice in the book is to avoid rushing into UML software--stick with index cards until the design is fairly well developed. That's what got me out of a morass of charts and diagrams that looked nice, but did relatively little. I'd paraphrase the book's theme as "Forget the formalism and focus on your application's responsibilities, and how those responsibilities can be allocated among cohesive, well-organized team players.:

The book is language neutral--it's focus is design, rather than programming. The design methodology taught in the book should be easily adaptable to nearly any object-oriented programming language.

I have no hesitation recommending Object Design to novice and intermediate object modelers. I rate is as the best book I have read on the design and modeling of object-oriented systems.

Rating:
Summary: Definitive guide to Object Oriented Design
Review: I've always believed the best approach to object-oriented design is Responsibility Driven Design (RDD), and this is the best book on the subject-written by the inventor of RDD.

I recently showed Mike Rosen, of Cutter Consortium, Object Design. Before I could say it had great chapters on RDD plus work on design for reliability and flexibility plus pages of references to related books and papers, he said 'Great! This will be my next book purchase'.

So, why is Object Design: Roles, Responsibilities, and Collaborations (OD) a really great book? These folks have years of design consulting and teaching experience, know what they are talking about, and are good at telling the story.

OD is a great read from cover to cover. Their two-chapter review of object design concepts was energetic, insightful, and comprehensive. From the beginning they are mixing in CRC cards (Thanks Kent, Ward!), architecture styles, patterns, and stereotypes into the discussion. This is the place to start for novices and intermediate students, and professionals now have the definitive reference book on object oriented design.

The authors understand we all have different learning styles. Along with their conversation, the first two chapters also illustrate concepts and examples with over 20 figures, a couple of UML diagrams, three (short) Java code blocks, and eight CRC card drawings. Concrete examples are provided throughout the book, from computer speech to finance and telecommunications.

The Chapter titles are: 1 Design Concepts, 2 Responsibility Driven Design, 3 Finding Objects, 4 Responsibilities, 5 Collaborations, 6 Control Style, 7 Describing Collaborations, 8 Reliable Collaborations, 9 Flexibility, and 10 On Design. Each chapter includes a summary. The recommendations for further reading provide a guided tour of related works in software engineering, design, and general literature.

The authors share how they think about the critical areas of design for flexibility and reliability. So how do you build reliable systems? What are some experience-based guidelines for dealing with error conditions? What about all those exceptions anyway?! The chapter on flexibility is for me the heart of object technology. They show how you can apply object technology to give users control over their world. The analysis of hot spots or flex points guides the focused introduction of added flexibility. Then you can actually deliver on the promise of object oriented software.

Practitioners will find this book "spot on" for the treatment of UML and Patterns. So, yes, with three or more UML books on the shelf, I am sure you can draw all those diagrams - right? With OD you are learning to think in objects and to communicate your story. Your learning how to tell your story with UML, what to say visually and what not to say. OD is a pretty good source for UML notation guidance too, as the text and the diagrams are meticulously accurate, down to the arrow head styles. OD provides a good introduction to patterns and weaves a number of the more interesting GOF patterns into the design examples. Patterns are also emphasized in the chapter on flexibility.

Paraphrasing Ivar Jacobson's words from the forward: "this higher-level view of design, which focuses on responsibilities...helps you step away from implementation details and focus on what the appropriate software machinery should be..." In closing he writes: "Whether you are new to object technology or an experienced developer, this book is a rich source of practical advice."

These common sense lessons are essential for practitioners of design and systems architecting in all fields.

Rating:
Summary: OO-Collaborations Perspective
Review: Overall very good impression, original presentation with sidebar essential quotes. However after a while seems more of the same: how to identify collaborations in an Object Oriented Design. Special note for Chapter 8, where valuable and interesting information is provided regarding exceptions and errors.

Rating:
Summary: Review of Object Design
Review: This is an excellent book written in a style reflective of the extensive consulting and training experience of it's authors.

It offers the reader a substantial mental framework with which to think and reason about the system you are designing, how to cast that system in terms of objects and how to use some very practical tools to help you create and refine your design concept.

Instead of dogmatically stating "this is the (only) way you do x", it helps you to understand the variety of possible approaches to problems - such as deciding what is the best control style for a system and gives you tools to help decide the best approach. It also acknowledges that design is very much a team activity and gives you ways to facilitate communicating the design story effectively amongst team members.

Although the book is very compatible with the use case methods and uml, it transcends these tools to include some unique and powerful ways of thinking about your object design.

Above all, although it covers some powerful methods, it is very easy to read and apply. I attribute this to the extensive teaching experience of the authors.I highly recommend this book whether you are a system architect, a program designer or a coder of algorithms.

Rating:
Summary: Pragmatic OO Design
Review: This well-written and very readable book gives an excellent overview of object-oriented design. It takes a very pragmatic and human-centred approach that is fresh and enjoyable to read. I would be happy if this were the only introductory OO design book in my library.

One final note is that it is a pleasure to read a technical book these days that is not filled with typos, incorrect grammar, and poorly reproduced diagrams. This is a book that obviously took some care and time to produce!

Rating:
Summary: A great first text on OO design
Review: Wirfs-Brock and McKean have written an oustanding introductory book on object-oriented design. This is definitely a book for beginning OO programmers, the ones who aren't sure how to assign functions to objects and who aren't ready for design patterns yet. More experienced developers won't get much out of it, but that's OK. Every level needs its own reference books.

The book's layout and illustrations present its content well. UML diagrams, for example, use one color and typeface for the actual UML notation. The same diagrams use a different color and typeface for notes that explain the UML. Unlike other books, there's no confusion about which is the tool and which describes the tool. The text is gentle and reasonably jargon-free, but I think it over-does the friendliness in places. In discussing a program's normal and exception handling behavior, the term "happy path" described the execution in the absence of errors. The term may be evocative, but is just a bit hard to take seriously.

The sequence of topics makes good sense. It starts with the idea of a "responsibility," the basic unit of application logic. The authors develop this into strategies for defining objects, defining relationships between objects, and defining the control strategies that implement those relationships. They continue on through error handling (reliability) and extensibility - handling of future features. Throughout, the authors keep a moderate, pragmatic tone, free of name-brand methodology. That's a good thing, since the real focus is on basic skills and decision criteria.

One aspect of this book is just a little confusing. It's definitely aimed at educating a new OO designer, but it doesn't lay out its educational objectives or plan very clearly. It certainly lacks the didactic rigor of a textbook. It would make a good supplementary text, though, and it might be very helpful to a novice working with more experienced developers. Best of all, it refers to additional texts (including Strunk and White!) that will help claify the programs as well as communication with other members of the programming team.

This book is great for anyone starting OO design on their own. It's also good for classroom students who just aren't getting it from their regular instructor and text. Experienced developers won't find much new here, except very clear descriptions of how much error handling or flexibility is enough.

//wiredweird