Clean code that works--now. This is the seeming contradiction that lies behind much of the pain of programming. Test-driven development replies to this contradiction with a paradox--test the program before you write it.

A new idea? Not at all. Since the dawn of computing, programmers have been specifying the inputs and outputs before programming precisely. Test-driven development takes this age-old idea, mixes it with modern languages and programming environments, and cooks up a tasty stew guaranteed to satisfy your appetite for clean code that works--now.

Developers face complex programming challenges every day, yet they are not always readily prepared to determine the best solution. More often than not, such difficult projects generate a great deal of stress and bad code. To garner the strength and courage needed to surmount seemingly Herculean tasks, programmers should look to test-driven development (TDD), a proven set of techniques that encourage simple designs and test suites that inspire confidence.

By driving development with automated tests and then eliminating duplication, any developer can write reliable, bug-free code no matter what its level of complexity. Moreover, TDD encourages programmers to learn quickly, communicate more clearly, and seek out constructive feedback.

Readers will learn to:

• Solve complicated tasks, beginning with the simple and proceeding to the more complex.

• Write automated tests before coding.

• Grow a design organically by refactoring to add design decisions one at a time.

• Create tests for more complicated logic, including reflection and exceptions.

• Use patterns to decide what tests to write.

• Create tests using xUnit, the architecture at the heart of many programmer-oriented testing tools.

This book follows two TDD projects from start to finish, illustrating techniques programmers can use to easily and dramatically increase the quality of their work. The examples are followed by references to the featured TDD patterns and refactorings. With its emphasis on agile methods and fast development strategies, Test-Driven Development is sure to inspire readers to embrace these under-utilized but powerful techniques.

0321146530B10172002

Amazon.com® Reader Reviews (Ranked by Helpfulness)

Average Amazon.com® Rating:  Based on 33 Ratings

Another silly development fad... - 2008-10-26
Reviewer Rating:
TDD "By Example" is a book that tries to persuade you to write tests before writing the code the tests test. In the first six chapters, the author takes you through an example of generating code through this method. Along the way, he makes several pertinent points:

1. His method has never been empirically studied to see if it helps or severely hurts the efficiency of the software development process (though the author is very interested to hear from anyone who finally DOES study his method, since he didn't have the time to do so himself, being too busy dreaming up new development processes to inflict on us).

2. His tedious, non-linear, haphazard, time-wasting (ed: my words) method is not meant to be followed precisely, but only meant to allow you to say you CAN do it that way. He makes this point numerous times. Fantastic dude, thanks. :/

I predict that this book will be purchased by software project managers both actual and wanna-be all throughout the software industry, and inflicted as a requirement on otherwise productive and smart engineers for several years to come. The final result will be projects woefully behind schedule, leading to inevitable 24-hour/7 day crunches, thereby twice punishing the engineers, and resulting in the whole silly process being dropped in the end.

Having said all this, I give the book two full stars: the english grammar is correct, and the punctuation well placed. The book is easy to understand, making it quite simple to dislike the content thereof.

2 pages drawn out to 200 pages of bs - 2009-02-26
Reviewer Rating:
Remember back in college when you would come up with 2 pages of good material then bs it into 5 to meet the length requirement? This guy does it to make a 200 page book.
Test-Driven Development is not very complicated. You can fully understand it just reading the wikipedia article on it. This book doesn't explain much more than that. There are a ton of examples for just about any situation you can think of inside this book, but any decent programmer could just look at an example or two online and be just as well off.
This book would be most helpful to someone who has just started learning programming on their own (no degree or job experience), but this book is mostly just a waste of time.

Really not that good. - 2008-12-16
Reviewer Rating:
I was expecting quite a lot from this book, because it has been recommended so many people and organizations. However this was a disappointment. I feel TDD is important topic and way to go, but this book is not the one I would recommend to anyone. It's kind of reference book, but quite poor one.

Extremely important software development practices - 2008-10-12
Reviewer Rating:
Excellent book, well paced and informative. You should really go through the examples as you read those sections (part 2), even if they feel a little obvious, because if you are new to TDD you will pick up some insights. I particularly liked the Patterns section (Part 3), as it introduced some new patterns as well as talked about familiar patterns in the light of TDD.

If you are a software developer, you must put this powerful tool (TDD) in your toolbox.

An excellent introduction to TDD - 2010-02-03
Reviewer Rating:
Before this book, I was doing unit testing - test-after - and had not done any TDD. As a result of reading this book, I am now writing new code in a test-driven fashion - writing my tests first, as a sort of spec, then writing code to pass the tests. It's a great feeling, writing code and knowing that it is correct.

Test-Driven Development by Example is an introduction to the practice of test-driven design. The book explains the what, when, where, how, and why of TDD. Through some running examples, Kent Beck steps through the thought process of adding code and changing functionality after writing tests. The steps are explained clearly along the way.

Now for some minor nitpicking. Kent regularly shifts into mentioning things that aren't related to the subject matter; this gets a little annoying, since you're reading about TDD, not personal antics. Also, this book is very slim, and reads quickly. This is in some ways a good thing, but from another viewpoint it ends too soon. I was left wishing for more chapters. That makes this book an introduction to TDD, not an in-depth exploration of the subject.

The nitpicks aside, the book is a great read, an easy one, and it is a success in my view. I recommend it for anyone looking to start with TDD.

Browse Similar Topics

Top Level Categories:
Software Engineering

Sub-Categories:
Software Engineering > Testing and Debugging