Customer Reviews

Object Models: Strategies, Patterns, and Applications (2nd Edition)

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

 

 

It's 5.41 a.m. I did not sleep last night I was so jazzed after reading 45 pages of 'Object Models: Strategies, Patterns, & Applications'.

This book outlines a methodology that it also *shows* working -- and working in real-world applications. Definitely something for every object-oriented programmer's reference library.

The strategies and patterns mentioned in the book are really helpful. They improve the object think. The examples explain the author's point of view clearly. This book complements other books in OOAD and patterns by Craig Larmen, GoF, Martin Fowler etc.

One interesting point is that the author shows how same strategy or pattern helps in design in various problems. Most of the books do not show this. For beginners, it is often difficult to grasp a strategy or pattern with just one example.

One drawback is it uses UML notation very less. But Coad notation is simple and we can easily grasp to understand the diagrams in the book. If you want to learn from solid examples, this is a good choice. If you are very new to OOAD, this is NOT the one you can start with.

This book is a big hit -- a very valuable asset for anybody doing object-oriented development. I really like the new strategies and notation, especially for scenarios. The work on scenarios is extremely valuable. The business and real-time applications really help developers learn how to object model. Very cool!

Published in 1995, this book suffers from the affliction of coming into being before the Unified Modeling Language (UML) was defined. Inside the front cover, there are three instances of the Object Model, one in Coad notation, the second in Booch notation and the third in Rumbaugh notation. Having worked in UML since it was developed, I found the trip back to the before time to be unnerving. I spent some time going over the diagrams and found the differences in notation so significant that it took me awhile to equate the three diagrams.
The inside of the book is easier to understand, largely because understandable applications that are represented. They are:

*) Connie's convenience store (a point-of-sale application).
*) Wally's warehouse (a warehouse application)
*) Ollie's order center (an order-entry application)
*) Dani's diverters (a soft real-time application)
*) Andi's autopilot (a hard real-time application)

Each is developed from the beginning, the first step in all cases is "Identifying system purpose and features." From this, the objects are identified and defined, followed by a section on applying patterns. Coad and his group was one of the earliest to include patterns as a fundamental component of their development strategies, so this book is secondarily a textbook on what patterns are and how they are used.
This book has worn better over the years than many of the others written about object models. Coad notation is used throughout and it is very similar to UML. This makes it much easier for people experienced in UML to read and understand what is being done. For this reason and because the applications are so well developed, I can recommend this book to all modern developers using object-oriented design strategies.

I have struggled a bit with Peter Coad. Nonetheless, I always felt that I would get to grips with his somewhat unusual style and that it would be worth the effort. Indeed it has been! This book was well ahead of its time in terms of its approach to OO design. Chapter 7 presents 148 strategies that guide you in your design effort. It also has a number of analysis patterns which are very useful. Personally, I had no problem with the notation he used, in fact, I found it more intuitive that UML. The material in this book is refined in Streamlined Object Modelling (Nicola, et al) and Java Design (Coad, et al) but this is it's starting point.

The strategies and patterns mentioned in the book are really helpful. They improve the object think. The examples explain the author's point of view clearly. This book complements other books in OOAD and patterns by Craig Larmen, GoF, Martin Fowler etc.

One interesting point is that the author shows how same strategy or pattern helps in design in various problems. Many authors do not do this. For beginners, it is often difficult to grasp a strategy or pattern with just one example.

One drawback is it uses UML notation very less. But Coad notation is simple and we can easily grasp to understand the diagrams in the book. If you want to learn from solid examples, this is a good choice. If you are very new to OOAD, this is not the one to start with.

I was surprised to see how few reviews this book had, so I felt compelled to write my own, specially since I've yet to find a good modern software design book that fails to reference this one. Even after so many years this book keeps being relevant and helps you shape your mind from that of a mere developer to that of a true OO designer.

I love Peter Coad's writing style, what he calls "learning by example". He creates these imaginary projects, with very real problems and then sets off to solve them in front of your very own eyes. Reading his books sometimes feel like a master-apprentice exercise where you get to work with one of the most experience and highly listened object modelers of his time.

The bulk of the Pattern Community gives Peter less credit than he deserves as far as being a strong force of the whole pattern movement, but as I mentioned, you'll always find this book (or Coad's earlier paper that inspired this book) on the reference pages of the greatest patterns and design books, written by the likes of Martin Fowler, Robert Martin, Frank Buschmann and it's even referenced with high anticipation on the appendix of Design Patterns: Elements of Reusable Object-Oriented Software.

Although it's a pre-UML book, you'll find Coad's notation very straight-forward and intuitive and if that weren't enough it is also helpfully explained in one of the appendixes. It's also laid out as a Duplex Book, where the first few chapters are written as narratives to learn about the design process, the patterns and strategies and how to apply them on real projects; and the second part as a reference catalog where you can easy get the details of a pattern or strategy for daily use.

In a sentence this book belongs on the shelf of every thoughtful software designer. It'll give you a new insight on the modeling process.

Shows you how to create object models (analysis models) through indepth examples and guidance by presenting strategies and patterns as you need them as you work through the examples. The strategies tell you how to approach a task such as how to select objects. Strategies are short, focused. For example, a strategy may have three or four one-sentence things to do to accomplish a goal. The patterns present template objects and their typical interactions.

The examples are relevant to business analysts.

After working through even just one example, you will be able to create object models and using the strategies and patterns.

Includes reference section containing all of the strategies and patterns.

The book uses COAD notation to present the examples, so for people familiar with UML it takes a little getting used to.

This book seems to me the notes of a college professor hoping to create a standard in modeling and chartifying object orientation. It's about 80% charts (his format, often complex and useless without study), endlessly repetitive simplistic strange outlines, and loads of tedious chatty faux-dialog with lots! of! exclamation! points!!

If they gave me this book as a textbook in college, I'd drop the course. If I spent too much time with it, I'd give up programming. BORING, TEDIOUS, and unreadable. I ended up skimming this book. Frustratingly, every 40 pages or so, there's a couple paragraphs that are relevant and useful. Fortunately, they're easy to find because there are so few spots where he bothers to write whole paragraphs.

I'm looking for a book that helps me tune my sensibilities in designing and implementing object orientation, without boring me to death. If anyone can help, please comment or email me.