FREE Delivery in the UK.
In stock.
Dispatched from and sold by Amazon.
Gift-wrap available.
Condition: Used: Like New
Comment: Used Good condition book may have signs of cover wear and/or marks on corners and page edges. Inside pages may have highlighting, writing and underlining. All purchases eligible for Amazon customer service and a 30-day return policy.
Trade in your item
Get a £8.50
Gift Card.
Have one to sell?
Flip to back Flip to front
Listen Playing... Paused   You're listening to a sample of the Audible audio edition.
Learn more
See this image

Test Driven Development (The Addison-Wesley Signature Series) Paperback – 8 Nov 2002

See all 2 formats and editions Hide other formats and editions
Amazon Price New from Used from
"Please retry"
£16.33 £14.87

Trade In Promotion

Frequently Bought Together

Test Driven Development (The Addison-Wesley Signature Series) + Clean Code: A Handbook of Agile Software Craftsmanship (Robert C. Martin)
Price For Both: £46.68

Buy the selected items together

Trade In this Item for up to £8.50
Trade in Test Driven Development (The Addison-Wesley Signature Series) for an Amazon Gift Card of up to £8.50, which you can then spend on millions of items across the site. Trade-in values may vary (terms apply). Learn more

Product details

  • Paperback: 240 pages
  • Publisher: Addison Wesley; 1 edition (8 Nov 2002)
  • Language: English
  • ISBN-10: 0321146530
  • ISBN-13: 978-0321146533
  • Product Dimensions: 18.5 x 2 x 23.1 cm
  • Average Customer Review: 3.6 out of 5 stars  See all reviews (19 customer reviews)
  • Amazon Bestsellers Rank: 145,862 in Books (See Top 100 in Books)
  • See Complete Table of Contents

More About the Author

Discover books, learn about writers, and more.

Product Description

From the Back Cover

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.

  • About the Author

    Kent Beck consistently challenges software engineering dogma, promoting ideas like patterns, test-driven development, and Extreme Programming. Currently affiliated with Three Rivers Institute and Agitar Software, he is the author of many Addison-Wesley titles.

    Inside This Book (Learn More)
    Browse Sample Pages
    Front Cover | Copyright | Table of Contents | Excerpt | Index
    Search inside this book:

    Customer Reviews

    3.6 out of 5 stars

    Most Helpful Customer Reviews

    23 of 23 people found the following review helpful By Iain Mcginniss on 26 Nov 2004
    Format: Paperback
    Many of the other reviews for this book have criticised it for it's length and "lack of content". However, I found the book very enjoyable for what it is: an introduction to test driven development. TDD can be (and was for me) quite an alien concept for many programmers trained in a traditional way, where testing is often an afterthought. Kent's first example of TDD, while fairly trivial, outlines all the key points in how to practice TDD properly. It also fills you with confidence and makes you think "yeah, I could probably do that".
    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.
    Comment Was this review helpful to you? Yes No Sending feedback...
    Thank you for your feedback. If this review is inappropriate, please let us know.
    Sorry, we failed to record your vote. Please try again
    8 of 8 people found the following review helpful By Mr. R. Dalton on 17 Feb 2012
    Format: Paperback
    This book has a problem.

    It is (in my opinion) the best introduction to TDD that you can get if you are starting from little or no knowledge, but if you are starting from that position you're unlikely to appreciate just how good a book it is. This I think accounts for the range of reviews that the book attracts.

    When I first read this book I was very new to TDD, but I found the book very easy to read and understand (it's very clearly written). The danger in reading a book that you find easy to understand is that you can be lulled into thinking it's all stuff you already knew.

    When you fall into that trap you can read paragraphs or whole chapters less attentively than you should, and you come away knowing little more than you did at the beginning, but you can get a false sense of security in your ability.

    Having returned to this book recently following chats with a colleague, and armed with a few more years of experience with TDD, I really see that many of the problems I've faced with TDD were addressed in this book that I had read, but didn't appreciate, years ago.

    If this book didn't do it for you on a first read, then come back to it. Even if you loved it the first time, come back to it again with some more TDD experience and you may find it's actually an even better book than you thought.

    The very slow methodical approach to TDD that Beck uses in the book is deliberate, and he warns the reader that they may not like it. He also points out that he goes at that pace, not because it's the correct pace, but because at times you will need to be able to go at that pace.
    Comment Was this review helpful to you? Yes No Sending feedback...
    Thank you for your feedback. If this review is inappropriate, please let us know.
    Sorry, we failed to record your vote. Please try again
    59 of 71 people found the following review helpful By bob on 27 Sep 2004
    Format: Paperback
    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.
    Comment Was this review helpful to you? Yes No Sending feedback...
    Thank you for your feedback. If this review is inappropriate, please let us know.
    Sorry, we failed to record your vote. Please try again
    13 of 16 people found the following review helpful By Mr. R. J. Jepps on 7 Sep 2003
    Format: Paperback Verified Purchase
    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.
    Comment Was this review helpful to you? Yes No Sending feedback...
    Thank you for your feedback. If this review is inappropriate, please let us know.
    Sorry, we failed to record your vote. Please try again

    Most Recent Customer Reviews