The Object-Oriented Thought Process Book Review (January 15, 2012)

Posted: January 15, 2012 by Mike Hubbartt in Book Reviews, Development
Tags: , ,

By Mike Hubbartt, © Copyright 2012, All Rights Reserved.

Title: The Object-Oriented Thought Process
Author: Matt Weisfeld
Edition: 1st (2000)
ISBN: 0-672-31853-9
Publisher: SAMS Publishing
Price: $29.99
Length: 226 pages (9 chapters, 2 appendices)

This book, according to the author, is ‘an introduction to fundamental O-O concepts’. It is not a book aimed at people already familiar with OO concepts, so bear in mind it is not intended for people that already understand OO development. I read the first edition of this book in 2000 and enjoyed it, but it sat on my bookshelf until last summer. I had a class in grad school at UST and the professor recommended this book before taking the class so I decided it was time to reread it. I read 3 chapters per day, so it only took 3 days to finish it, even though I took notes from each chapter. Like the 1st ed K&R, this book is not huge – 226 pages including the title page, table of contents, index, and acknowledgments – but it explains how procedural programmers can make the move to OO development. Let’s look at the book chapter-by-chapter.

Chapter 1 – Introduction to Object-Oriented Concepts

This chapter explains classes and objects and how they differ. Encapsulation, one fundamental advantage of OO programming, is covered nicely in this chapter, as is the introduction to the difference between a class interface and implementation, polymorphism, constructors, and overriding.

I liked the code samples included to demonstrate some of the concepts like overriding. I also liked the UML class diagram showing how class elements are displayed via UML – very easy to follow. I would have liked more code samples covers more concepts introduces in the chapter.

Chapter 2 – How to Think in Terms of Objects

This chapter teaches how to think in an OO manner. This chapter goes into the introduction of public interface and private implementation portions of a class. Very nice, clear, simple explanation. Not over or under covered – just enough to introduce the material that will be covered in more depth later in the book.

Chapter 3 – Advanced Object-Oriented Concepts

This chapter covers object creation and initialization, plus error handling. Very good explanation of constructors – what they must and must not have – and how there can (and often should) be more in some classes. Exception handling, which is a topic that could fill a book, is introduced here. There was a bit of source code showing how to use exception in Java code. I liked how the author covered static attributes, which can be used to allow multiple objects to share attributes.

Chapter 4 – The Anatomy of a Class

This chapter explains the differences between the implementation and interface of classes. This is the meat-and-potatoes section of the book. Where a class is broken down using Java to show the implementation and interface sections, as well as constructors. Very clear and my favorite chapter of the book.

Chapter 5 – Class Design Guidelines

This chapter explains that classes must interact and it covers the iterative nature of class design. This goes into design considerations, covering a safe constructor to initialize a class, serializing (deconstruct a object), persistence (maintaining the state of an object), and stubs (minimal implementations of an interface). More good Java code examples, although C++ concepts are also covered.

Chapter 6 – Designing with Objects: The Software Development Process

This chapter explains how to identify class responsibilities and class collaboration. This goes into the way to design an application, covering statements of work, requirements documents, and CRC cards. This was my least favorite chapter of the book – I liked the issues to take into consideration during the OO design process, but I’d rather have more OO concepts than requirements gathering information.

Chapter 7 – Mastering Inheritance and Composition

This chapter covers the differences between composition and inheritance. Very good coverage going into important means of code reuse: inheritance and composition. The author has nice UML diagrams to cover the concepts, and the text explanations are clear and accurate. I also liked how the book explains abstract classes and methods – very clear.

Chapter 8 – Frameworks and Reuse: Designing with Interfaces & Abstract Classes

This chapter covers frameworks and abstract classes vs Java Interfaces. Another good chapter, which covers APIs. I liked the code sample for an abstract class, and the author includes nice UML diagram that demonstrates a interface, inheritance and composition. A short chapter but good material and worth the time spent to read it.

Chapter 9 – Building Objects

This is where you learn how to use objects to build other objects. This goes into both types of composition: aggregations and associations. The author also goes into cardinality (a familiar concept to DB developers). I liked the material here but would gladly give up all of chapter 6 for more information in this chapter. Good, but I’d like more.

Conclusion

A very good book that is well illustrated, deep enough to explain the material without overwhelming someone new to OO development, and a good starting point for more advanced/in-depth books on OO development.I like how the author goes into UML enough, but not too deep to obfuscate the topic of OO development – the appendix is a good starter for people new to UML, but I wouldn’t recommend it as the source for programmers needing to gain more mastery of that topic.

Recommendation

I enjoyed reading it and will pass it along when I find someone that could benefit from it. The most current version of this book is the 3rd edition, which was published in September of 2008. I would recommend this book to undergrad computer science majors that learned to develop with any non-OO language, or for procedural programmers moving on to OO development. I would not recommend this book for an intro to UML

Advertisements

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s