This book is very much like the others in the Head First series. It's makes it easy to learn, and fun to work with. Thumbs up!

In the tradition of Japanese Manga, which although cartoonish and comic-like, often cover deep subjects like economic theory, government policy, or cultural themes, H1st OOA&D is a great resource. I've been teaching O/O programming for a decade, but I found several ideas to incorporate into my class material. It gave me some insights into Use Cases, for example, that hadn't occurred to me.

I like the way they show their projects evolve, warts and all. In several cases they go down the wrong path, make some bad decisions, and have to recover (e.g., p. 247). You don't often see such a realistic scenario: the all-wise author always makes the right decisions--but the real world doesn't work that way.

***
Profound concepts are expressed clearly and simply. A few examples:
"The customer decides when a system works correctly. So if you leave out a requirement or even if they forget to mention something to you, the system isn't working correctly." (p. 62)

Listen to the Customer: "When it comes to requirements, the best thing you can do is let the customer talk. And pay attention to what the system needs to do; you can figure out how the system will do those things later." (p. 63)

"You've figured out one of the hardest parts about getting a customer's requirements--sometimes even the customer doesn't know what they really want! " (p. 65)

In an example they went down a bad path to make the point: "One of the hardest things you will ever do is let go of mistakes you made in your own design." Pride kills good design: "Design is iterative... and you have to be willing to change your own designs, as well as those you inherit from other programmers." (p. 246)

"Most good designs come from bad designs. Never be afraid to make mistakes and then change things around." (p. 255)

"Sometimes the way to write great code is to hold off on writing code as long as you can." (p. 364)

"Customers don't pay you for great code, they pay you for great software." (p. 370)

***
Our authors are willing to risk the wrath of the UML-is-a-sacred-whole crowd: "There are a lot more symbols and notations in UML, but it's up to you how many of them you use, let alone memorize. Many people just use the basics [Class Diagrams & Use Cases], and are perfectly happy (as are their customers and managers). But other folks like to really get into UML, and use every trick in the UML toolbox. It's really up to you; as long as you can communicate your design, you've used UML the way it's intended." (p. 207) It's "easy to spend a lot of time arguing over whether a use case extends this use case, or includes that one...but it's really not that big of a deal, and those keywords should never distract from the overall design process." (p. 299)

One criticism/caveat. I think one of their solution techniques isn't really workable. For instruments and weapons they have this scheme in which they have properties which will have a description and a value. The philosophical problem with this is it could be used on any odd conglomeration. Consider the group [Chocolate pudding; the planet Mars; Abraham Lincoln]. These items could have been called DPP: Desert-Planet-President and use the same scheme. But as with weapons, the practical problem is in the behavior. There is no commonality: Tanks fire shells and crush people; swords are held and cut people; etc. The property solution works only if all you are going to do is display arbitrary information strings, which was possibly the case with instruments (although you have to keep changing code to update the enums), but with weapons we need to have a broad range of attributes and behaviors so the scheme is awkward at best. This having been said, I sympathize with the dilemma when explaining a concept: you need to make the example simple enough that it doesn't obfuscate the principle, so I still rate the book a solid 5.

The style of all the Head First books is great. They take any subject and make them quite readable and enjoyable. This title is no different.

I'm teaching myself the various aspects of software engineering, so perhaps I've read too much already. My point, it that quite a bit of the information seemed like common sense. I was expecting some magic formula's, but I guess I shouldn't be surprised. The parts that were tied more closely to Java, and OO programming were pretty good and gave you good tips.

One other downer, is the volume of typos. You'd think they could hire a better proof reader or do a better job themselves. Oh well, I still recommend this book.

I have already read quite a lot of Head First Series books. I have to admit that I have already been a little bit tired by almost the same pictures in all the Head First books. So after long pause I have decided to open the book. I was positively surprised I have found very good stories explaining main aspects of OOAD in real world. You can read the book even on sundays afternoon instead of some novels. It teaches you OOAD basics (and even a lot more) by nonintrusive method. Before reading the book I recommmend to think about Head First Design Patterns too.

I already know the family Head First and this one specially is very important in every Object Oriented developer. Very easy to study and learn with this book.

I was quite disappointed with this one. Way, way too much fluff. I kind of liked the "fluff" on the Head First Design Patterns - because design patterns is a hard topic and it helped. But for this one? Gosh, that doggy door use-case example got _really_ boring after 50 pages, I was withering in pain. This book is for the absolute beginner. Professionals and CS grads might want to stay away from this.

Fine enough book, but in case you were hoping for a book on Business Systems Analysis and Design using Object Oriented Techniques... this is not it. Should be Re-named to "Head First Object-Oriented SOFTWARE Analysis and Design in Java". Did this book really need to be so programming language dependant??

I was little bit disappointed since my expectation was too high for this book. I thought there would many UML explanation etc. The book is fulfilled with SDLC (Software Dev. Life Cycle), really useful for beginner in Computer Science.

I decided to buy this book based on the reputation of the 'head first' series regarding ease of 'consumption'. The main goal was to find new ideas about how to transmit object oriented analysis to newcomers.

Overall this book is very easy to read from cover to cover. The jokes, examples and exercises do force you to think and assimilate the concepts shown.

In the end I had just one 'complaint': I wish the authors could have extended the coverage with more complex scenarios and more day-to-day situations.

I love the Head First (HF) Series, and as I am neither a programmer or a software person the HF books have proved a great entry into the discipline.

The HF idea works for my learning style, and I think the suitability is independent of age as I am a middle-age male.

It also difficult to know how good the HF books are because the information they present is new, and effectiveness is judged by how much you learn. I have found that after completing the HF OOAD I have been able to go from novice to following with ease the more formal books of Grady Booch (OOAD 2nd Ed) and Graig Larman (applying UML and patterns). I am serious about learning this stuff.

HF OOAD gently takes you through the full OOAD journey in which you are an active participant.

While the HF books seem 'informal and funky' they have a high level of design, are well thought out, are serious, and are produced by TEAMS of gifted and talented people. The quality control is generally good. But, these kind of books need to be well thought out as the style only works when everything fits together (so beware of imitations). Like good teachers, they take your hand, give you clues that are later amplified, and take you to places you never imagined. You miss the characters after you finish each book.

The requirement for talented writers and the demand for more lines of HF style books I think is becoming problem. As I write this review, the HF OOAD book is not fully supported by its website as promised in the book with half the chapters not supported by code. While I got by successfully without this support (and wrote the code myself as you are meant to but I used eclipse which you are not meant to according to HF authors - so I cheated), the later chapters did cover some pretty demanding work from my point of view.

It is because the supporting code is not on the web that I have given this HF OOAD book three stars. I am writing this review so that I can rate it with three stars, and hopefully add pressure for the HF series to get its act together.

I didn't recieve it!! It's an absurd. Can you give me any explanation????

If you are a C# programmer there is a link to the equivalent C# sample code for each chapter in the user forums of the book's web site.

As usual the head first series rocks!!. The book is a must read.

This is a good introduction to object oriented analysis and design (OOA&D), as well as use cases and class modeling. The authors lead the reader through several different scenarios (some of them progressively tied together and some of them standalone). The "build-it-up and then tear-it-apart and analyze it" methods seem to fit well for whom I suspect are the target audience for the book: developers who know how to program, but maybe don't have the best skills in needs analysis up-front.

Head First Object-Oriented Analysis and Design is the first (and currently only) book that I've read in the Head First series. The concepts are easily understood and there is a minimum of prior knowledge of Object Oriented Design required as a pre-requisite for reading the book. There's a good bit of humor and lightening up of the subject matter. The ideas are comprehensible, but I do understand other reviewers' comments about the layout and design of these books. It is rather all-over-the-place, with wacky fonts and "fridge magnet" pages (as I understand the Head First series is generally), but the concepts do come across pretty clearly. It's still pretty obvious what the different, wacky fonts are doing to engage the reader, and they do follow a graphic design scheme for the book.

There are some very heady topics discussed in the book, but the scenarios and various methods of describing the problems and solutions provide an accessible, understandable introduction to OOA&D.

The examples are all Java-based, but if you program in another language, you should be able to follow along without much difficulty.

The table of contents could benefit from some better tie-in to the industry-standard terms that are the topics in the chapters/sections (at least add in and bold the terms, such as Delegation, Encapsulation, Polymorphism, etc.). A glossary might be a handy addition, too.

Generally, I'd say this is a good introduction to Object Orient Analysis and Design, and it is certainly not a reference book.

If you're a software developer or engineer - or a library catering to such patrons - you have to keep Head First Object-Oriented Analysis & Design in your reference section. It appeals to newcomers to the field, offering all the basics on how to analyze, design and write serious object-oriented software, and explains the principles in language that assumes no prior familiarity with such analysis. Plenty of real-world examples and applications makes for a top recommendation.

Diane C. Donovan
California Bookwatch

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.

Although I liked this book and learned from it, I feel the title
may mislead some potential readers and leave them a bit frustrated.
The book is about Object Oriented Design sure enough, but the
language of choice is Java. Other people not familiar with Java, and
expecting a generic treatment of OOP design theory, could be a little
disappointed.

BUT using one language may also be the strength of this book. Using Java,
the authors demonstrate how UML, along with design principles, come
together to help you write solid code. More than just reading about theory,
the excercises reinforce those principles (Lots and lots of practical
exercises as in all Head First books).

Get this book if you are into Java, and want to learn about OOP design
and analysis. If you don't have any exposure to Java, get a copy of Head
First for Java to get some background prior to attempting this one.

Easy to read and it provides the details in step by step so I can follow them and understand easily. There are a lot of examples that help me figure it out what I can do in real life.

I found it hard to write a review about this book. Why? Because apart from a few, very minor typos it is simply superb! In my opinion, it is one of the best and sure to be one of the most influential books in this subject area. The O'Reilly Head First series of books are fast becoming the de facto standard, and I recommend that anyone who wants to get a deep understanding of how you should approach designing and developing software, read this book, no matter what your background or current skill set is. To date, I've read this book twice, cover to cover. It is not a particularly thin book, but it is very easy to read.

A colleague once told me that he picked up "Head First: Design Patterns" in a bookshop and flicked through it. He didn't buy it because he wasn't sure about the format, which if you've never seen a Head First book before, might at first seem a little different and perhaps off putting. As one reviewer put it:

"Hidden behind the funny pictures and crazy fonts is a serious,
intelligent,extremely well-crafted presentation of OO Analysis and
Design. As I read the book, I felt like I was looking over the
shoulder of an expert designer who was explaining to me what issues
were important at each step and why." -- Edward Sciore

The book's primary focus is "How to write great software"; this is summarised in 3 steps:
1. Make sure your software does what the customer wants
2. Apply basic OO principles to add flexibility
3. Strive for a maintainable, reusable design.

It is a practical, readable and refreshing step-by-step walkthrough of the development process. It covers how to incorporate flexibility into all aspects of the software development life cycle. This book leads you through simple and then more advanced concepts by allowing you, the reader, to make the connections. In addition, it gives an easy to understand introduction to UML class diagrams.

Kathy Sierra talks about "Creating passionate users" over at the blog of the same name (highly recommended reading, as it is a gold mine of ideas and advice on creating great software). One of the beliefs espoused there is that it is better to get passionate responses from users at either end of the spectrum (i.e. love or hate it), rather than a mediocre "Yeah, it's OK". Judging by the polarised reviews, this book certainly creates passionate users/readers.

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.

The world is still waiting for a good book that explains object-oriented analysis and design. This isn't even close to being that book.

I knew I wasn't going to like the book as soon as I looked through the table of contents and noticed that appendix one is a kitchen sink full of topics, some of which belong in the body of the text and some of which have no business being in an OOAD book (why would you include sections about unit testing and refactoring in an introductory OOAD book?).

Unfortunately, appendix two is even worse as it attempts (in less than 10 pages) to define the basic building block terminology of OO (inheritance, polymorphism, encapsulation). Why would this be in an appendix - this is the meat and potatoes of OO!!!!!

Finally, the book must get rid of the programming examples - this is far and away the greatest weakness of the text. This is an OOAD book - not a Java programming book. O'Reilly made the same mistake with it's Head First Design Patterns book.

Head First OOAD is a great book that introduces the reader to object oriented design in a fun and interesting way. The book focuses on learning the material and it does it by repetition - but not in the boring, "memorize this" sort of way. The book follows the other Head First books by including pictures and graphics and voice balloons all over. It becomes less of a reference book and more of a book you would read from front to back. The code examples are written in Java, but that shouldn't stop anybody from picking up this book. The code is pretty easy to read and only the smallest amount of code is included so the reader gets the idea of what they are trying to show. All in all, a great book!

This book is poorly written compared to the other books from the head first series. The content is unorganized, spending too much pages with trivial explanations about listening to your customer and using enumerations instead of strings (using enumerations instead of strings has nothing to do with OO, but these trivial explanation costs 20 out of 500 pages !). Then it packs dozends of OO topics into a couple of sentences without any explanation. In my opinion, this book should not have passed the quality check of the publisher.

It's entirely possible that as a Notes/Domino developer, you've never had occasion to work with object-oriented design. But as you work with other development areas in your organization, the subject will become a requirement. Or, you might even sit in on an object-oriented LotusScript session or two at Lotusphere. To get a better idea as to what object-oriented analysis and design means, I would strongly recommend this book... Head First Object-Oriented Analysis & Design by Brett D. McLaughlin, Gary Pollice, and David West. I wish I had this book about 10 years ago...

Contents: Great Software Begins Here - Well-designed apps rock; Give Them What They Want - Gathering requirements; I Love You, You're Perfect... Now Change - Requirements change; Taking Your Software Into the Real World - Analysis; Part 1 - Nothing Ever Stays the Same - Good design; Interlude - OO CATASTROPHE; Part 2 - Give Your Software a 30-minute Workout - Flexible software; "My Name is Art Vandelay" - Solving really big problems; Bringing Order to Chaos - Architecture; Originality is Overrated - Design principles; The Software is Still for the Customer - Iteration and testing; Putting It All Together - The ooa&d lifecycle; Appendix I - Leftovers; Appendix II - Welcome to objectville

Since I originally started programming in the world of "big iron" mainframes (yes, I am old!), I learned to program in the procedure style. Start at the top, execute the code sequentially, and finish at the end. When object-oriented programming became the next "big thing", I had a horrible time wrapping my mind around it. Having someone tell me "an object is a dog" is useless, as I want to know how you code a dog! Over the years, I've slowly started to understand what it's all about, but it's still not natural. This Head First book is one of the first that bridges the gap between concept and code for me, as well as engaging the entire mind in understanding objects both from the design and analysis perspective.

The book starts off with a fictitious guitar shop that wants a better application for matching guitars to customers. Using a combination of code and narrative (and graphics and unusual drawings and puzzles and...), the authors walk you through the design process using objects. Once you see how the process fits from the software side, you start to cover the analysis and design process in the following chapters. You'll be building the next killer dog door product, and along the way you'll pick up UML concepts such as use cases and class diagrams. What makes all this different from your standard UML book is that the concepts are an outgrowth of the process. Normally, you're presented with the "this is a use case diagram" writing first, followed by the "how is this used in the real world" (if you're lucky). Head First reverses the order, and as such it's a whole lot easier to understand why you'd want to use something like a class diagram. It also tends to "de-jargonify" the concepts so that you're not struggling with unfamiliar terms at the same time you're fighting the new concepts.

All the books in the Head First series are far different than anything else on the market. By using unusual images, fonts, and diagrams, the mind is forced to view the pages in a new light - far different from other books. The puzzles and exercises scattered throughout are also different from the normal question/answer format, so again you use different brain cells. The goal of the book concept, as conceived by Kathy Sierra and Bert Bates, is to involve as many senses as possible. In all cases, that goal is exceeded without fail. Oh, and did I mention that they are just plain fun to read?

I'll be the first to admit that learning object-oriented design and analysis isn't a "must do right now" learning task for the typical Notes/Domino developer. But with Hannover bringing composite applications into the Notes realm, there's a much greater chance that you'll be asked to participate in projects where OO design techniques are expected. A few hours spent with this book ahead of time will give you the tools and concepts you need in order to succeed in that world.

HFOOA&D is designed to introduce the reader to the process of designing software. It doesn't push a formal methodology, but covers the basic building blocks that are common to most approaches, including requirements gathering, use cases and iterative design. Additionally, there is heavy emphasis on design principles such as the Open-Closed Principle, and the Single Responsibility Principle and more general concepts such as encapsulation and cohesion. UML class diagrams are used, but no more than the basics. Design patterns are mentioned in places, but you don't need any knowledge of them to understand what's going on. This book is more about the principles that underlie design patterns. Indeed, for those wondering where this book fits in with Head First Java and Head First Design Patterns, you should read HFJ first, then this one, and then HFDP.

Java is used as the language throughout - while Java 5.0 features are avoided (apart from enums), you still need to know the syntax and be comfortable with the mechanisms by which Java implements objects, such as interfaces. You can't jump into this book with just knowledge of VB, for example.

The material is treated in the usual Head First style: off-the-wall scenarios, conversational writing, lots of dialogue delivered in a pseudo-comic book style by using photos of real people, anthropomorphism of computer terms. A lot of effort is put into making the experience seem as much like social interaction as possible. It's a winning formula, and it works again here.

But Head First Java and Head First Design Patterns were two really stellar books. So, by comparison with those two, I must admit to being a little disappointed with this one. Maybe it's because this book was rewritten from scratch over a short time period, after an initial treatment by Dave Wood (google hfoobook to find the old webpage), but while there are some nice touches here and there, overall, this lacks the pizzazz of HFJ and HFDP. There are noticeably fewer pop culture references and the use of characters and scenarios are less memorable. Also, there are a couple of rhetorical devices lifted from HFDP. These are less fresh the second time around.

And in parts, the explanations are a little fuzzy. Partly this is due to the inherent fuzziness of design, partly due to the approach this book takes of showing the different aspects of analysis and design in an iterative fashion, with a series of long examples, which work very well in other ways. But Head First Design Patterns demonstrated that you can tackle this sort of material with clarity. Here, I suspect many will be left feeling confused about the difference between association, aggregation and composition in UML - some Java examples would have been illuminating.

However, HFDP was always going to be a very tough act to follow. If HFOOA&D isn't quite as good as that, it's still far preferable to slogging through the sort of heavyweight process books it competes with.

I purchased Head First Java (Second Edition) and it succeeded where "Thinking in Java" and a score of other books failed me. I am at least slightly above average in intelligence. However, I've had real difficulties learning Java. I'd buy a well-reviewed (Amazon) Java text and follow along carefully until about 100 pages in. I'd "get it" until the book started including unexplained parameters in example code that it promised to explain in subsequent chapters. Head First doesn't do that - it explains EVERYTHING you see in it's code snippets. Head First authors have a real knack for anticipating the parts of the puzzle that you'd most like explained next - and doing so with clarity and humor and interesting examples. If you're like me and all JAVA textbooks lose you after only 100 pages - try Head First and enjoy yourself.

Having said that, THIS book is very poorly organized. In Head First Java - I simply read front to back and the result was an intuitive incremental learning experience. THIS text was supposed to teach me OO analysis & design (which I've done professionally since 1998). I wanted (expected) this text to begin with OO Theory (encapsulation & refactoring & inheritance & polymorphism) and then organically progress to USE CASES & Story Board Analysis techniques then progress to pseudo code and finally end with some code samples. However, this book is a mish mash of Java code samples.

I cannot see how this can possibly help beginners or intermeditate users. The overall feel is COLD and BORING which defeats the Head First purpose.

I suggest purchasing the Head First Design Patterns (arguably the best Head First thus far) with arguably their hottest cover girl.

Object Oriented Programming has been around for years and years in some form or another, but it seems until recently (past 5 years or so) that it really has become a requirement for any type of developer. Whether you a windows or client-server based developer or a client-side scripter (JavaScript) or a web-based developer (JSP, ASP, ASP.NET, etc.). You can't escape not knowing the basics of creating and using objects no matter what technology or computer programming language you use. Knowing how to use and create objects are only the first step in being a successful OOP developer, and this book goes through each step assuming no knowledge whatsoever. And since it's not specific on any programming language or technology anybody can pick up this book and starting using OOP in their specific area.

The Head First series if you do not know is a unique publishing series in that it makes it fun to learn a new and maybe somewhat confusing topic (like OOP). It takes the material and uses exercises, illustrations, and simple games to help the reader understand the information the author is trying to get across. It is not for everyone, but it's a great way in my opinion to teach the reader the material that helps them from not getting too bored. If you quickly glance at the book and see the many images that do not seem to relate to the material at all you will miss the really great material that is hidden within it. You really need to read the first 10 pages to know if this is the book for you or not. But if you do, then I am really sure you will want to continue to read the rest of the book.

The topic of OOP and Design Analysis is broken down into 10 easy to follow chapters. The first chapter goes through the basics of what a class is and how and why you would want to create classes and objects in the first place. It also shows code snippets of what classes would look like and the interface it would look like and how it would interact with the rest of your software requirements. A lot of good information is in this chapter to get you started thinking of designing in OOP.

The next three chapters show lots of examples of how you would get requirements for your applications in trying to divide your applications into small components. It requires a different way of thinking instead of just writing code logic and this chapter helps you re-think things before you start writing any programming logic.

Chapter 5 part 1 and part 2 takes all those requirements and applies the OOP techniques: encapsulation, abstract classes, polymorphism, and UML design and put it to an example application in showing the reader how all this `theory' can be put into practice. Even though there are so many types of application and functionality that are possible, some basics remain the same for most like displaying and updating data, giving choices to the user, manipulating data, going through conditional statements, etc.

The next couple chapters discuss the somewhat new topic of Design Patterns. Design Patterns are reusable solutions to common problems. It sounds like it is very simple and it some ways it is but it can get complex very fast. A common design pattern is MVC which is (Model View Controller) used a lot in software engineering. In complex computer applications that present lots of data to the user, one often wishes to separate data (Model) and the user interface (View) concerns, so that changes to the user interface do not impact the data handling, and that the data can be re-organized without changing the user interface. The MVC design pattern solves this problem by decoupling data access and business logic from data presentation and user interaction, by introducing an intermediate component: The Controller. Basically, it takes the 3-tiered model (user layer, business layer, data layer) and provides a easier data flow to help each layer interact with each other. It sounds complicated but the book explains it wonderfully.

The rest of the book explains how OO is used within the software lifecycle and how it can help speed up each step when done correctly. There are lots of great examples to help the newbie (like me) in understanding some important topics in software development.

A great book that I highly recommend.

This book uses O'Reilly's successful "Head First" approach to teach the reader object-oriented analysis and design. The "Head First" books look somewhat like comic books at first, but the approach really works well at getting you to remember important concepts. The books tend to have lots of graphics, conversations between imaginary characters that are personified versions of important concepts, and photos that look like they were taken in the 40's and 50's with caption bubbles on them. This may seem cheesy, but I've found it to work well. The book assumes you know Java, but it does not use Java 5 because that version introduces lots of new features to the Java language that might hang the reader up on the syntax. The book has many programming exercises in it, and it is important to do them all if you really want to get the most from this book. There is also lots of example code, usually with handwritten captions and arrows pointing to parts of the code that the authors are trying to point out as good or bad examples of particular concepts.

The book covers such old staples of OOA&D as properly gathering requirements, dealing with changing requirements, writing flexible code and also a mini-tutorial on UML, domain analysis, use cases, the four design principles, object-orientation concepts, and iteration and testing. The final chapter is just a review of the OOA&D lifecycle. There are two appendices. The first appendix is dedicated to the "top ten topics we didn't cover". That appendix briefly introduces anti-patterns, CRC cards, metrics, unit testing, and refactoring, among a few other topics. The second appendix clearly reviews concepts specific to object-orientation, since it is very important that the reader completely understand these terms and their meanings as well as their functions.

I've taken a graduate course on object-oriented analysis and design, and I've also read several books on the subject. The class and the books made it seem like a dull dry but necessary subject, and I'm sure that these other resources probably covered the concepts presented in this book and then some. However, I actually remember what I read in this book, and I found it interesting to boot. I would therefore highly recommend this book to newbies as well as those that think they know something about OOA&D. I'm sure you'll learn something. Just don't buy this as a reference book. It is strictly about getting concepts into your head and then having you practice those concepts via exercises.

I was extremely impressed with the way the information was presented. The authors did not go too fast and I felt like I really got the concepts. The last chapter was extremely helpful in that it took a new project and went from beginning to end.

One of the best concepts I saw in the book is that they kept the process as simple as possible without going into full blown RUP.

There is a lot of material in the book but it really did not take that long to read. Do not be intimidated by the 550 pages.

This title is far from a "OOAD for Dummies" book. Very very well written.

Loved it!

First off, I'm already a fan of the Head First series - especially the Head First Design Patterns book. This book follows the same entertaining style and keeps your attention page after page. To me, there are two kinds of Head First books, ones relating to technologies like Java, Servlets & JSPs, EJB, etc and ones that cover a more traditionally academic topics like Design Patterns and this book, OO Analysis and Design. Personally, I like the Head First treatment on the academic topics better than the others. So, if you weren't a fan of Head First Java (for example) you might want to give this book (or the Design Patterns one) a try.

Specifically for this book - I really liked the chapter layout and the progression as each chapter builds upon the next. The chapters explain the basics of OO principles, ease you into Use Cases and how to write good ones, and continues building upon OO Design principles. When the Head First Design Patterns book came out, we purchased a bunch for the office and held a few "lunch and learn" classes on design patterns for the team at work. I can easily see doing the same thing with this book, as the Head First books make it easy to use as instructional manuals as well.

If you have found other books (lectures, articles, etc) on OO Analysis and Design a bit intimidating or conceptually difficult to grasp, this is the book for you.

Am I really the first to write a review on this new installment? Well, let me start with a huge five stars for this new addition to the Head First series!

I had been waiting for this book to hit the shelves a while, since I absolutely loved the innovative approach of the Head First Design patterns book. This one was no different in the way it clearly and creatively presented key principles to good object-oriented design and educated the reader on how to approach designing software for the real world from requirements gathering all the way to anticipating and designing for change.

A few things about this book - in my opinion, there is probably no better way to present the world of software design to a beginner. Instead of talking about abstract concepts, the writers present the material using concrete scenarios, and through-out the book, the reader is encouraged heavily to think through the pitfalls and problems and come up with solutions - there is no better way to learn. There are lots of exercises and even specific places to write ones ideas down.

Some topics covered are of course good object oriented principles like encapsulation and delegation, requirements gathering, use cases, anticipating changes, class diagrams, UML and more. The book only briefly touches (but does not go into too much detail) on state diagrams, sequence diagrams, unit testing and other concepts which are a huge part of software design, in the last chapter. While it does not go into these subjects deeply, it does not leave the reader completely without any knowledge on these topics either.

It does cover more than enough to enable a reader to become very well versed in architectural principles. Best of all, the information is presented in a way where it will stick forever. The whole point is not to cover everything there is to know, but for you to really GET IT, on what is truly crucial to know.

This book is not for seasoned architects or for those who do not appreciate comical diagrams and pictures on every page (Even though, anyone with a sense of humor would appreciate the fun way the information was presented). If however, someone is confused about object oriented design and has only heard the buzz worlds but doesn't know how it all comes together - this book will ensure that they are never confused again. Not only that, but after reading this book, they will be armed with tried and tested principles of experience of what kind of design works for long term solutions vs what is a nightmare.

Another thing to mention is that all the code examples in this book are in Java (as all Head First books are). This is certainly not a problem, even if you do not code in Java, because the principles are the same no matter the language, and C# .NET users in particular will not have any problems following the code examples.
The book does assume prior programming knowledge of an object oriented language in order to follow the code. This is not a book to learn how to write code in a programming language. It teaches how to design and architect your project, with the whole software life-cycle in mind.

There are a few useful appendixes in the back to quickly define and explain the basics of software design elements used in the book (like UML for instance).

Overall, it is a great book for anyone interested in software design principles! Best of all, you will get through this book QUICKLY, because with the creative and fun way that you will be learning, it will be hard to put down.