Rating: 
Summary: Excellent Introductory OOAD Book
Review: As the title would indicate, this introductory book on Object Oriented Analysis and Design (OOAD) does an excellent job of combining theory and implementation in C++. Design techniques from CRC cards to transition state diagrams are presented, with an excellent chapter on classes and design ramifications of association, aggregation, and inheritance. Memorizing simple examples from the book, such as '64 VWBUG or 747, or perhaps Gryffindor could easily help beginning designers avoid implementation errors actual projects. I like the author's sense of humor and writing style, and I especially recommend this book as a valuable reference for OOAD.
Rating: 
Summary: Dense
Review: For those of us new to the Object-Oriented paradigm, the first four chapters of this book are an exquisite introduction. The author takes a practical approach to the subject, introducing material at a rapid, but comprehensible pace. You'll be able to begin applying the underlying concepts immediately. Chapters 5 and 6 (Concurrency and Persistance respectively) are fascinating, but are very complex and vast subjects unto themselves; especially the one on Concurrency. These two subjects do fit into the overall process of Object-Oriented development, but something about the way the material is presented breaks with the style of the previous chapters. I think there could have been more integration. It's almost as though each of these chapters came from a diferrent book. However, it's still very informative and useful information that raises relevent issues. The essential criticism is that it can be a little confusing when a book takes what apears to be such a sudden left turn. Perhaps it makes more sense and fits in better after multiple readings. Chapter 7 covers specific C++ implementation issues and Chapter 8 recaps the overal process of Analysis and Design. Other Misc. Observations: Fundamental elements of UML (Unified Modeling Language)are covered as they are needed. The book is written in a tutorial (i.e., non-reference) manner. Two theoretical projects are covered; one in some detail, another more briefly. There are many concise and useful definitions. Brief comparison/contrast of COM and CORBA. Brief introduction to the idea of Design Patterns. Conclusion: I would certainly recommend this book to anyone who is interested in exploring what OOA&D is about and how to begin implementing it. I'd just give a heads-up on chapters 5 and 6.
Rating: 
Summary: A good overview
Review: I agree with the reader from Wisconsin. The first four chapters started out strong. They gave a good overview of Object-Oriented Design and Analysis. Since the material was just an overview, I got the impression (and hoped) that the latter part of the book would cover some of the topics in the first four chapters in some more depth. However, that was not the case. Instead, Liberty discusses topics that are only superficially related to Object-Oriented Design and Analysis: concurrency, persistence, etc. Here again, Liberty gives an overview of these topics. This is a good book if you've never done any OO, concurrency, or database work.
Rating:
Summary: Good balance between theory and practice
Review: I have found Jesse's book to be a good book for those of us who wish to make the transition from data and process modelling to object oriented analysis and design. His book provides a good balance between theory and practice. It provides a bridge from the theory of object oriented analysis and design to its actual implementation. As an example, I have read several books on the UML notation, but this book was the best on showing how the different diagrams fit together. In chapter 2, for example, Jesse effectively uses a video store to explain why and how to capture Use Cases. I especially found useful Chapter 3 where he discusses class design. I feel that this book was written by a practitioner for other practitioners who need guidelines on how to do the nuts and bolts of Object-oriented analysis and design. I have recommended it to several of my associates who like me are making the transition from an action-oriented or data-driven perspective to an object-orienter perspective.
Rating:
Summary: A very helpful book
Review: I read this book to help me prepare for teaching a project course in software engineering, and believe it makes for a very good starting point in understanding the object-oriented-design process, from requirements elicitation, to actual implementation. Moreover, it is written at a level that can be understood by most beginning programmers. The text works very well for an introduction to the requirements, design, and implementation issues, however I felt the chapters on concurrency and data persistance may have been tackling more than he could possibly explain well enough in such limited space. Fortunately, however, these chapters can be skipped without losing much understanding of the later material. His later chapter on implementation issues should not be missed!
Rating:
Summary: A good overview
Review: I've read it, and have recommended this text for some time, to persons I mentor. Jesse Liberty offers an excellent beginning for those seeking OOA and D information. His style is straightforward and noncomplex, with informative examples and simple illustrations using UML. Follow this book with his equally-good Clouds to Code, and you have a good base understanding of OOA and D. Then move on to Riel's Object-Oriented Design Heuristics, and start using what you've learned.
Rating:
Summary: Great design strategies and an enjoyable read
Review: If I were developing in C++ I'd give the book 5 stars, but in any case the OOD insights are right on.
Rating: 
Summary: Object-oriented yapping
Review: Object oriented yapping would have been a more apropriate title for this book, which is by all means a waste of money and -- worse yet-- of time. The material is incoherent and always presented in the most akward of contexts. No signifigant code examples are found, and what little code it contains is no more than snippets that don't represent any concrete ideas. One may argue that actual code is not required in a book that claims to be about analysis and design, and that might be a valid argument. But the book still fails to present a solid method of OO design. For example, the author spends a chapter articulating the design documents that should be the outcome of the design phase. Just to find out at the end of the chapter that he's been kind enough to provide a summary of the design documents which is very different from the ones discussed before. The biggest joke about this book is that the author keeps on citing a real world example of a project for a certain banking institution that he worked on, just to find out a few chapters later that he never actually participated in that project, but rather that he and those who worked on it were apparently good chums. The only consolation I have is that this book is finally out of print. With so many good books out there, and so little reading time, one has no need for time-wasters like this.
Rating:
Summary: Excellent treatment of OOA&D itself. Poor on other topics.
Review: The author's chatty style makes the book an easy read, at least for the first four chapters covering object-oriented analysis, class design, architectural design, and documentation. Jesse Liberty makes an excellent case as to why iterative development has become imperative in the industry. Clients or end-users never really understand their needs in a vacuum and can only articulate them in the context of an existing system --- a prototype. Thus, the prototype not only becomes an end product of an iteration but is essential in soliciting feedback from the customer. That feedback is feed back into the requirements for the next cycle of design and coding. Of course, how successful this process is largely depends on the team's ability to prioritize requirements and put together a prototype in a timely manner. As Liberty insightfully points out, conventional approaches (the linear waterfall model) often result in systems that conform to formal specifications signed off by the customer yet fail to meet the customer's expectations. Upon completing this books, you can expect to learn some helpful pointers on gathering system requirements and how to elucidate these requirements in terms of use cases and test case scenarios as well as extracting candidate classes from the use cases. Also covered are suggestions regarding analysis and design documentation. The entire book is a bit ambitious and begins to fall apart after chapter 4 when the author tries to encompass complex but relevent topics such as concurrency, transaction processing and object persistance to databases within a 360 page book. The classic dilemma between brevity and depth is apparant and readers would be better off to merely skim the remaining chapters and read other books on these topics. Also missing from the book is fully worked and practical example from requirements gathering to coding. Naturally, a realistic example from business would be beyond the scope of this book but a watered down extensible example would go a long way toward illustrating what issues developers are likely to encounter. A very simplified iteration of the video store database example would have sufficed but the Phish game presented in chapter 8 just doesn't cut it. That said, the book is still well worth recommending if only for the first 4 chapters.
Rating:
Summary: Excellent treatment of OOA&D itself. Poor on other topics.
Review: The author's chatty style makes the book an easy read, at least for the first four chapters covering object-oriented analysis, class design, architectural design, and documentation. Jesse Liberty makes an excellent case as to why iterative development has become imperative in the industry. Clients or end-users never really understand their needs in a vacuum and can only articulate them in the context of an existing system --- a prototype. Thus, the prototype not only becomes an end product of an iteration but is essential in soliciting feedback from the customer. That feedback is feed back into the requirements for the next cycle of design and coding. Of course, how successful this process is largely depends on the team's ability to prioritize requirements and put together a prototype in a timely manner. As Liberty insightfully points out, conventional approaches (the linear waterfall model) often result in systems that conform to formal specifications signed off by the customer yet fail to meet the customer's expectations. Upon completing this books, you can expect to learn some helpful pointers on gathering system requirements and how to elucidate these requirements in terms of use cases and test case scenarios as well as extracting candidate classes from the use cases. Also covered are suggestions regarding analysis and design documentation. The entire book is a bit ambitious and begins to fall apart after chapter 4 when the author tries to encompass complex but relevent topics such as concurrency, transaction processing and object persistance to databases within a 360 page book. The classic dilemma between brevity and depth is apparant and readers would be better off to merely skim the remaining chapters and read other books on these topics. Also missing from the book is fully worked and practical example from requirements gathering to coding. Naturally, a realistic example from business would be beyond the scope of this book but a watered down extensible example would go a long way toward illustrating what issues developers are likely to encounter. A very simplified iteration of the video store database example would have sufficed but the Phish game presented in chapter 8 just doesn't cut it. That said, the book is still well worth recommending if only for the first 4 chapters.
| 
