Test Driven Development (The Addison-Wesley Signature Series)

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.


Denied 1 star only because it's an interesting idea   September 27, 2004
39 out of 44 found this review helpful

I'm going to list my 3 day old copy in the Used section after I've finished writing this review.

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.


beginners guide   August 20, 2004
grewy (UK)
4 out of 7 found this review helpful

a good intro to testing from an XP sense. It lacks depth and therefore invites you to make you own leap to applying it to concepts not covered in the book.


worthwhile investment   February 4, 2004
4 out of 6 found this review helpful

The overall tone of this review may seem a little negative. Don't be put off. I think that this book is awesome.

I would have to agree with the previous reviewer about mistakes in proof-reading and documented progress vs actual progress in the task list. I would be surprised if the reviewers wrote any code whilst reading the book. That said, this gave me a much better understanding of how TDD should be an essential part of any development. In fact, the discrepancies encountered between the text and trying to follow it with my own code probably gave me more knowledge than if I had just copied what was in the book.

I was happy to see Python in there as I love this language and feel that it is still undervalued by a lot of people. This book almost serves as a very basic introduction to Python (if you bother to write the code) and indeed recommends this approach when learning any new language - it admittedly does help if you know the xUnit (JUnit) design and the use of the Java introspection facilities in the JUnit implementation before looking at how Python handles the same issues. I have used the same approach with a couple of other languages and it certainly makes a refreshing change from the usual Hello World route to getting to some proper applications running.

Some friends that have read the book feel that the style grates a little. I can understand this, but this book has too much to offer to let something like that get in the way of the message. They should try reading Bruce McKinney's HardCore Visual Basic for a book that really has the potential to annoy readers with the author's personality! (Again, I quite like that book)

I found this book a useful intermediate step from not using unit tests as well as I might, to comparing how they are used in some of the Eclipse plug-ins and various other open-source projects. You may not require the additional information that this book provides, but it is usually helpful to have a map when you go somewhere new. I suppose it depends on whether you are happy to stop and ask for directions!


Test driven development by example   September 8, 2003
Mr. R. J. Jepps (Cambridge UK)
9 out of 10 found this review helpful

This book starts as means to go on - first write a test! OK I'm exaggerating, the first test is on page 4. The point is that this is a very practical book, and it gives very clear insights into one man's method of development. This is the most interesting part of the book - otherwise you could stop once you'd read the title!

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.