Head First Object-Oriented Analysis and Design

on excellent conditions to used book though

This is an amazing book! Great for beginners

I do LabVIEW programming and trying to find a good reference on this subject has been a struggle. This book, although written for JAVA programmers, contains the information on how to decompose your programming project and lay it out to be coded. I just had to ignore the JAVA examples and focus on the how-to. Be aware though, that this book assumes you know Object-oriented terms and fundamentals. This is not the book to use if you want to pick up this programming style from scratch. However, if you have the basic idea under your belt, this is one great book to work through. I plan to have this book really dog-eared when I'm done.

Overall this is another winner in the Head First series but it's not quite as thought provoking as some of the other Head First books. If you've read a Head First book then you already know what to expect. If not then you will quickly learn that Head First books take a completely different approach then your typical text book style. Head First books take an odd-ball approach using lots of whacky drawings, humor and tons of exercises that really force you to think.Head First OOA&D is a good first step for those of us that have OOP knowledge but are just beginning to learn how to architect OO software correctly. The book does sort of sit in an akward position for the target audience. On one hand this book assumes that you have OOP knowledge so it's not really for the OO beginner (the appendix covering OOP is quite shallow). On the other hand the examples in the book are extremely simplistic so those of us that do have OOP knowledge may desire a bit more out of the book. Don't let this shy you away though because like most Head First books - you will learn a good deal if your experience in OOA&D is very minimal.I understand where this book is trying to aim. People looking into OOA&D should already have basic OOP concepts mastered. Some people tend to blur the line between OOA&D and OOP. OOA&D is Object Oriented Analysis and Design. This means you take the concepts you know from OOP and learn how to architect software by using certain techniques such as UML modeling, patterns, requirements gathering and what-not. OOP should already be understood if you are trying to create an OO architecture. In other words - You have to learn how buildings work before you learn how to draw the blue-prints and design your own building.For what it is this is a very good book. If you are brand new to OOP then I would hold off on this one for a bit until OOP is understood. If you understand how OOP works but you don't feel confident architecting software then this is a great start even though the book may seem a bit overly simplistic at times.

I read this book at the very start of my career as a software engineer.One of the most fundamental things in software development is to learn how to collect requirements from clients (or your employer) and transform these into small, re-usable chunks of code.Learning design principles presented in this book, like DRY (Don't Repeat Your Self), SRU (Single Responsibility Unit) or KISS (Keep it Simple Stupid) can help any developer program faster and more efficient.A must read for all new developers!

The book is "easy to read" compared to the ones' on the same topic. It becomes a bit more complex in the end after the basis concepts are already passed.

It is a great book for everyone who wants to understand how to build great software. It explains all the process since the initial specs until the delivery of the system with the best quality for the customer and for the developers that will have to change the code, too. Every step in this process is well explained and helped a lot in my daily routine as a programmer. This book really teaches practical concepts about Object Oriented Analysys And Design.

I like the Head First series, and even Head Rush, for its innovative and fun approach for introductory software topics. I've had small concerns on all of them but I have never been as ambivalent as I have for this book. I know a big part of this problem was that it was rewritten expeditious (I am still not sure of the reason why) and it shows throughout the book with spelling, logic and code errors.You can tell that the first chapter was rushed. There are several spelling and programming mistakes. The most egregious is where they ask you to look through some code to find what "FIRST" you change and then they answer that question with a much smaller problem (the main problem was they forgot to add a return statement (pg.5) and they write about the inconsistency of using String based searching). It has also been mentioned by several reviewers of the use of the method name "matches" which only makes sense for regex not for an equals operation. I also did not like the search example (how can you not think of price in a search?). The best part of this chapter is the mantra that should be practiced by many engineers: "Make sure your software does what the customer wants it to do."The next few chapters are definitely better (though still some spelling mistakes). They are a good read for beginners and intermediate programmers on gathering requirements, change of these requirements and analysis. The ideas are a bit simplistic though it is good to get many programmers used to the idea of UML and use cases and using them to drive requirement gathering and textual analysis. Intermediate and advanced readers familiar with use cases will gain more from reading Alistair Cockburn's "Writing Effective Use Cases" (or will already have read it) and for further UML reading should go with "UML Distilled" by Martin Fowler.When the book gets back to design I see some problems with the coding. The designer has this bizarre idea of abstracting all properties (under the guise of "encapsulate what varies") into a Map attribute to lessen the amount of subclasses for instruments. While initially this may seem a good idea it gets rid of all type-safe coding (you can now safely assign an instrument type to a backwood for the instrument), you cannot have behavior from the instruments (this is mentioned in the book) and if you put a property with one letter misspelled or capitalized out-of-place you now have a bug, one that you might have trouble finding thereby increasing maintenance costs. Too much flexibility makes the code ambiguous.After design, the studies get to solving really big problems, architecture, design principles, and iterating and testing. These chapters I enjoyed much more especially the chapter on design principles with the beginning mantra that "Originality is Overrated." This chapter goes over basic principles such as OCP (open-closed principle), DRY (don't repeat yourself), SRP (single responsibility principle) and LSP (Liskov Substitution Principle).Then the book last chapter (the ooa&d lifecycle) sums the lessons in the book in one large (somewhat contrived but these type of examples always are) program for the Objectville Subway. Then two terse appendixes dealing with ten additional OOA&D topics and OO concepts should make the reader realize that this book is just an introductory sliver of what needs to be learned for a sagacious software acumen.This book is useful for programmers with a bit of Java (or C#) knowledge who want to get a good overview of OOA&D. This book is useful because it teaches important OO vernacular and a simple holistic approach to iterative development. If the book did not have a "quickly done" feeling, better design and fewer mistakes I would have liked this book more. This book is a good candidate for a second edition. If you want a more thorough explanation of these topics I recommend "The Object Primer" by Scott Ambler as one of my favorite books for a good introduction to OOA&D.