Head First OOA&D - for beginners or experienced developers?

[Svend Rost]

Hi,

According to headfirstlaps:

Head First Object-Oriented Analysis and Design offers a complete introduction to Object-Oriented programming for experienced programmers new to the methodology and even those new to programming.

I finished my education (Comp. Sci.) � year ago and started to work. I'd
like to "update" my OOA&D skills, but since I have both theoretical and
(some) practical expirience I dont know if this book would help me become
a better designer, i.e. make better software and know what's a good and
bad design. What I dont need is an introductory book about UML and OOA&D
that is ment for 1 year CS students.

/Svend Rost

[Ilja Preuss]

Can't comment on Head First, but you might want to take a look at "UML for Java Programmers" by Robert C. Martin and/or the slightly more advanced "Agile Software Development - Principles, Patterns and Practices" by the same author.

[Bert Bates]

Hi Svend,

Well only time will tell how good a job the Head First team did, but I will tell you a bit about our goals for the book.

There is a little basic UML scattered throughout the book, but it's not really a UML book. The intention of the book is to take OOA&D theory, and put it into practice. A big theme that runs through the book is:

"How do I use OOA&D principles to write great software, every time?"

The book explores high level topics including: requirements gathering, features, use cases, iterative development, test-driven development, programming by contract, refactoring, commonality analysis, and architecture, and it also explores topics like: encapsulation, delegation, the open-closed principle, SRP, LSP, aggregation, composition, loose coupling, and cohesion.

Like all HF books, the goal is to give the reader a solid foundation in whatever the topic is. So in this case we hope that the reader will emerge with a good solid foundation in OOA&D. From there, there are more advanced books available.

For instance, we have heard from many readers who had a lot of trouble getting through the Gang of Four book, who then read HF Design Patterns, and then were able to go back and really understand GOF.

We believe that if a person is learning something complicated, they should start by getting really, really solid on the fundamentals of that topic. We take that philosophy to the books we work on.

The point of that is that we hear from lots of readers who say that even if they already think they know a topic, our books help them fill in little gaps they might have. We get feedback from a lot of experts who say that they find our "intro" books really useful.

Again, only time will tell, but those are our goals. We look forward to everyone's feedback.

Bert

p.s. As we planned the book our thought was that the reader should have already read Head First Java, and that after this book they'd read Head First Design Patterns, although the sequence of the last two is probably less important.
[ November 30, 2006: Message edited by: Bert Bates ]

[Darya Akbari]

Hi,

good to hear that HFOOAD covers a whole process lifecycle.

Regards,
Darya

[Michael Farinha]

Then thats perfect for me Bert! I have about 5 chapters left of HF Java, HF OOAD is on its way!

We believe that if a person is learning something complicated, they should start by getting really, really solid on the fundamentals of that topic. We take that philosophy to the books we work on.

This is the main reason I'm a self-proclaimed Head First Evangelist!
I've read too many books and taken too many classes that simply teach you how to do something with a minimal foundation of the main concepts. HF Java has really taught me a lot, right from the beginning. None of my programming classes have mentioned anything about the differences between primitive and reference variables, what an important, yet basic concept for OOP!

While I'm at it I'd like to recommend one thing that should be added to HF Java in a future edition. A mention that a "String" is a reference variable/object and not a primitive. Because from the beginning of the book we are using String variables but declaring them like primitives. I was able to postulate that Strings were actually objects but couldn't figure out why they could be instantiated without calling the constructor. It wasn't until I came to javaranch and started asking questions that I found out it was simply a compiler trick.

This obviously doesn't need to be a major topic, perhaps just a sharpen your pencil question at the end of chapter 3 eg:
"So is a String a primitive or a reference variable?" or
"String is a reference variable, so why can it be instantiated like a primitive?"

Just one readers suggestion.

Thanks for a great series Bert!