Test Driven Development (The Addison-Wesley Signature Series) (Paperback)

Perhaps you will feel differently, but I like the book simply because it is short. Huge computing textbooks that cram in too much information annoy me; I rarely have the time to read through such huge tomes or absorb everything they are trying to tell you in one sitting. I was able to read the first part of this book, and attain a reasonable understand of TDD in just over 2 hours.

The book is not terribly expensive either, and sets the stage for further reading on TDD and agile methodologies in general.

I would recommend this book if you are at all interested in TDD.

The concepts will be familiar to anyone with a passing knowledge of extreme programming (XP), although it isn't necessary to use XP to use test-driven development. The concepts themselves are both simple and elegant, and therefore easy to understand. The catch is that to put the concepts into practice requires a great deal of conscious effort and self discipline. Believing in TDD is not enough, you really have to live it!

I'm at the believing stage myself. I have used it on occasions when stuck on difficult problems and it really does work, although I haven't yet cultivated the patience to use it all the time. Some of the problems that I've come across in practice are addressed here (e.g. use of mock objects instead of a database/remote server/flaky module).

The book is written in a very easy-to-read style, and a very even tempo. It's aimed at an intermediate level audience, the main problem that a beginner is likely to have is not in understanding how, but why.

There are a few little quibbles: most of the code is in Java, but in the middle of the book the author switches to Python, before mercifully switching back again to finish. I also noticed that one of the tasks that had been crossed off as done was deliberately broken to move forward, without being uncrossed. This looks accidental, but it gnawed at me as I read on. Minor flaws in a well written book.

This book is in 4 sections, each of which would be a magazine article for any other author:

1. A tiring, trivial example of TDD strung out over a staggering 80 pages in normal Kent-Beck-six-sentences-per-page style.
2. An overview of JUnit, bizarrely documented in Python. Nothing against Python but what's the point when the aim is to understand JUnit, not get a taster in a new language?
3. An brief overview of Design Patterns
4. An brief overview of Refactoring

There is very little new in this book and even less to help with doing it on a real project.

But wait! Before I'm branded an unthinking curmudgeon it's not all bad; for those who have pondered the vexing issue of how to add a parameter to a method then tucked away on page 190 I found this pearl of wisdom:

1. If the method is an interface, add the parameter to it.
2. Add the parameter to the method
3. Use the compiler to show you the calls that need changing

Well what can I say...eureka? Thanks for that Kent, I'll raise it at my next developer meeting but tell'em I thought of it, they'll think me a genius.

How Addison Wesley can put this book in the same class as Martin Fowler's stuff is a mystery, the Fowler books contain more information in the Preface.