Head First Object-Oriented Analysis and Design: A Brain Friendly Guide to Ooa&d, by Brett McLaughlin, Gary Pollice & David West

[t:Object Oriented Analysis] and Object Oriented Design are two phrases which are intimidating to people new to programming. Fortunately for me, I cut my teeth in these things when industry leaders were still questioning whether Object Oriented manners of dealing with software were more than a novelty. That was in the late 1980s, but even then Object Oriented as a methodology had been around since the 1960s - much like the graphic user interface and the mouse. All told, the novelty of object oriented technology has lasted about 40 years, so there might be something to it. If you're learning to program today, understanding the theory of object oriented programming is a necessity. This means Object Oriented Analysis and Design are a part of any modern programmer's toolkit, though procedural programming code still is being maintained by people who may be in caves.

When I saw Head First Object-Oriented Analysis and Design: A Brain Friendly Guide to Ooa&d (Head First), I decided to take a look at it for many reasons - the first being that it can be a somewhat dull topic when delivered in monotone, and the second being that
Head First Labs doesn't do monotone. Object Oriented Analysis and Design are often brick walls to would-be software architects. Head First Labs books have a tendency toward immersion, with fun pictures and code running your brain through a confidence course toward specific objectives. A 'brain friendly way of writing great software' is welcome to me; the brick wall approach sucks.

This book isn't for everyone. It requires knowledge of Java/C# languages, though a C++ background may be enough (I'm familiar with all, but I lean more toward C++ myself), but this mainly has to do with the ability to navigate the code examples (which are in Java). Familiarity with Unified Modeling Language ([t:UML]) isn't necessary, Appendix II of the book is an excellent primer.

The book walks designers through ten main areas beyond the 'Head First Introduction':

• Great Software Begins Here: Guidelines for writing great software (of course), with a heavy focus on OO principles.
• Gathering Requirements: Easily the place where software projects fail the most, software requirements are as much about talking to the person or group of people that the software is being written for. Getting the requirements, creating a list (checking it twice...), planning for when things go wrong, use cases and much more. Great chapter.
• Requirements Change: I call it requirements creep - and as the book says, either you're a hero or a goat (and never, it seems, a hero goat). Flexibility is key because requirements do change. Staying on top of requirements change is important, and this chapter is focused on doing just that.
• Analysis: Making sure that your software works in a real world context - analysis of use case scenarios, making sure object classes are well designed, and other things that will bite your code and the anatomy of the designer (you). Tools, tips and tricks to keep you and your code bite-free when it enters the real world.
• Flexibility: Stuff changes, and designing it right the first time helps assure that the life cycle of your software doesn't suffer the agony of being 'The Little Engine that Used-To-Be-Able-To'. This chapter helps you design things which can instead of did - utilization of abstract classes, and some tipoffs of design problems that others went through a lot of trouble to find.
• Keeping Your Application Loose: Constantly reassessing the project and allowing it to evolve as needed are very important aspects of a software life cycle. This is explained using OO principles to assure that your software is flexible enough. There's a really great section in ere about 'turning bad design decisions into good ones' - a must read for anyone under the gun for a project.
• Building Big Things: Ways to look at problems, and making complex problems into smaller ones with the OO toolkit - and the introduction of the design pattern.
• Architecture: Creating a solid architecture through OO principles, starting with functionality and working your way through risk management and use case scenarios. It also reintroduces the customer in a manner which is similar to the spiral model.
• Design Principles: Designing smarter and faster can mean imitation - and this chapter introduces solid design principles (rules) to avoid problems.
• Iterating and Testing: The OO approach to solid prototyping through a test-driven approach, as well as real world issues (contract programming is about trust, as an example).
• The OOA&D LifeCycle: One evolution has ended, but on a solidly designed application - you've just begun

Head First Labs has a nice track record with book reviews here at KnowProSE.com, and because of that I expect a lot from any of their books. They did not let me down with this book. Each chapter maps directly to solid OOA&D project habits to pick up and which work in the real world. What I likes most about the book was the mixing of real OOA&D with customer interaction - because writing software is all about the client and whatever the client wants (no matter how much the client changes requirements). OOA&D provides tools for dealing with this flexibility, and Head First Object-Oriented Analysis and Design: A Brain Friendly Guide to Ooa&d (Head First) is a tribute to (1) Designing software to evolve from the start, (2) Being flexible throughout the software life cycle while remaining true to OOA&D Principles.

As short as this review is, it doesn't do justice to the book - it is impossible to explain all that the book covers without rewriting the book itself. There are solid guidelines within the book which portray OOA as flexible in the real world - in a way which is much more readable than many OOA&D texts out there. For those unfamiliar with Head First Labs, this would be a novelty - for those familiar with Head First Labs, this is expected.

If you're interested in flexible OOA&D and aren't too tied down to the brick wall approach which you may have practical knowledge in, Head First Object-Oriented Analysis and Design: A Brain Friendly Guide to Ooa&d (Head First) is a worthwhile reference and an even better read. On the KnowProSE.com scale, it gets a 9 out of 10 because of readability, practical approaches to OOA&D which tie flexibility into every aspect of the software life cycle.