Brian On Software

This is my second technical review for a book belonging to the "Head First" series from O’Reilly.  After reading and reviewing the excellent "Head First Design Patterns", it was hard not to push further my curiosity to read another Head First book.  I must say that since writing the review for "Head First Design Patterns", a friendly editor from O’Reilly offered me the opportunity to read and review any book I desire from the publisher, which I have accepted since reading about the field is one of my principles about becoming a key professional software developer.  That being said, I also need to point out that my reviews on any O’Reilly book will be purely objective, therefore I will write about my thoughts on the book, as well as what I liked and disliked about it, independently of my status as a reviewer for the publisher. All right, here we go…

Written by professional software developers Dan Pilone and Russ Miles, "Head First Software Development" brings the most important ideas and principles on software engineering today.  Instead of just dealing with one phase of the software development lifecycle (SDLC), it actually covers ALL the phases of the SDLC from gathering requirements, planning the different steps in a project, and dealing with user stories, to knowing how to manage your software process with continuous integration and test-driven development with mock objects.  The best part of it all is that it is written with the same unique, intelligent and sublime style of any other Head First book.

I was remembering my years as a software engineering undergrad, and all those classes that we had to attend weekly, while reading this book one night.  In fact, I realized that this book presents all the most important practices and principles a professional software engineer should be acquainted with in order to design, develop and deliver successful and higher quality software today.  Even though the book targets Java as the programming language for its examples, JUnit for its unit tests scenarios, Ant as its build engine tool, CruiseControl as its continuous integration server, you will find no problem at all to follow and understand the main ideas shared in this  book.  As an example, I’m more of a .NET developer that rather prefers to use other tools like NUnit, TypeMock, MSBuild and TeamCity instead.  In other words, it’s not the tool that makes the difference in your work, but rather the knowledge you have of the tool.  And since knowledge is universal, you will be very comfortable in following the main ideas behind each chapter even if you haven’t programmed with Java. 

Without stating it explicitly, Head First Software Development uses various key ideas from Scrum and XP, such as daily standup meetings, planning an iteration by playing planning poker, calculating and using a team’s velocity to better manage a project’s estimates, writing customer-focused user stories to gather requirements and manage requirements priorities, using a burn-down chart to view a project’s status within each iteration, driving the coding activity by writing tests first and applying refactoring, encourage and improve team communication with continuous integration, as well as customer communication by keeping her informed of the project’s "health status".  In a few words, the book can be summarized as a simple collection of various activities, ideas, guidance and principles to deliver software on time, on budget and on track with what the customer asked for.

Like all the other Head First series, this book also contains the popular "There are no dumb questions" sections which provide helpful answers and tips to various questions most customers and software developers ask or have being asked.  One such question/answer that forced me to get up from my seat and get a yellow highlighter was this one:

Question: What is you don’t have a next iteration? What if you’re already on the last iteration, and then a top priority feature comes in from the customer?

Answer: If a crucial feature comes in late to your project and you can’t fit it into the last iteration, then the first thing to do is explain to the customer why the feature won’t fit.  Be honest and show them you iteration plan and explain why, with the resources you have, the work threatens your ability to deliver what they need by the due date.

I was amazed by this answer, because I remembered a student once asking a similar question to a teacher at university and he couldn’t give the student a straight simple answer, but then again maybe because the professor was lacking real-world experience.  Anyhow, the answer given by the authors truly demonstrates that communication isn’t just a link between developers alone but that in fact that link must also include customer(s).  It’s their project(s) after all!  Now this is just one example of a Q&A you will find in this book…and there are a lot of them!

Another positive outcome of reading this book is that you don’t have to read all the continuous integration, test-driven development and user stories books available in the market to get up and going with these practices.  In fact, Head First Software Development successfully presents a good and thorough overview of all these practices for you to be able to understand the concepts and principles behind them, but most importantly, to be able to apply them within your own organization.  Then if you want to go more in depth about a particular practice, you can go ahead with a more specific book on the subject and not be lost in your reading.

I highly recommend this book to be part of a software engineering curriculum at both the undergraduate and graduate level.  I also think that this book will be a great plus for software development managers who want to improve their software development process by using sound, concrete, and realistic practices within their own organization.  Software consultants will no doubt also greatly benefit from this book, especially if they need to implement or recommend a proper solution in regards to a client’s software development process.  Being a software development trainer myself, I was very grateful to have had the opportunity to read Head First Software Development for the simple reason that I got to learn more than a few things in which I haven’t had much knowledge in.  Now, I can hardly wait to share what I’ve learned from this book with my students in the classroom!

The following is the Table of Contents for this book:

1. Great software development: Pleasing your customer
2. Gathering requirements: Knowing what the customer wants
3. Project planning: Planning for success
4. User stories and tasks: Getting to the real work
5. Good-enough design: Getting it done with great design
6. Version control: Defensive development
7. Building your code: Insert a tab into slot b…
8. Testing and continuous integration: Things fall apart
9. Test-driven development: Holding your code accountable
10. Ending an iteration: It’s all coming together…
11. The next iteration: If it ain’t broke…you still better fix it
12. Bugs: Squashing bugs like a pro
13. The real world: Having a process in life