The Object-Oriented Thought Process

Keywords: Object-oriented, programming, Java, C#

Title: The Object-Oriented Thought Process

Author: Matt Weisfeld

Publisher: Developer's Library

ISBN: 0672326116

Media: Book

Level: Introduction to object-oriented concepts

Verdict: Not recommended!

Buy US
Buy UK

As a general rule we try to be as fair to possible to authors when we review books. Where there are weaknesses in a book we point these out but balance this by pointing out the strengths as well. We don't want to short-change authors, but neither do we forget that we're writing for the reader. However, in the case of this book there's so much wrong that there's nothing we can do but be blunt. This is not a book that we can recommend at all.

The aim of the book is laudable enough - to teach the concepts of object-orientation in a way that emphasises the core ideas without getting bogged down in any particular implementation. There are good reasons for this. Learning the syntax of Java or C#, for example, does not necessarily mean we will write object oriented software. How many of us can look back at our first Java (or C# or whatever) programs at not wince at the procedural code that we would rip out and replace with more elegant objects now.

So, in theory the intentions are sound, but in practice the results fall far short of the author's aims. Firstly the book does use a particular implementation of objects, it uses Java to illustrate the concepts that it introduces. Unfortunately the code contains numerous errors, would not compile and is poorly formatted. If you're going to have code in a book that is supposed to be fairly language-independent then it ought to be correct code at the very least. Better still would have been to use a pseudo-code or to have used a mixture of languages.

Secondly the use of metaphors and analogy are important in a book that attempts to teach concepts. However some of the examples are down-right confusing. For example the concept of an interface is explained by use of an analogy with cars and driving. So long as the controls on a car remain the same we, as drivers, don't care about what lies under the hood. The car could have a diesel, petrol, hydrogen, or hamsters on a treadwheel engine, but so long as the steering wheel, pedals and other controls conform to the same standards we can all drive it. So far so good, but then the author states that 'replacing a four-cylinder engine with an eight-cylinder engine would change the rules'. How? A change in the engine is an implementation change, the interface (how the driver controls the car), remains the same.

There are other issues. The book contains factual errors too. For example it states that C# has no operator over-loading. Not true. Java doesn't but C# does. Even a cursory web search would have shown that up.

The book also suffers from some obvious padding. The chapter on XML, for example, has very little in it that is directly relevant to object oriented principles. Instead it discussed the rationale for XML and then gives a very high-level introduction, (and we mean high-level, XML schemas, for example are not even mentioned). The obvious use of XML for object serialisation was not even mentioned in the XML chapter.

All in all there is very little that is positive about this book. To be honest there are much more useful introductions to the principles of object orientation in many of the books that are language specific. The handling of the subject in Bruce Eckel's 'Thinking In Java', Bruce Purdum's 'VB .NET Primer Plus' or even 'Head First Java' are much clearer and more immediately useful than this.

You'll notice that there are no 'buy' links with this review. This is one title that we cannot recommend to our readers.

Hit the 'back' key in your browser to return to subject index page

Return to home page