49 of 56 people found the following review helpful
A decent introduciton,
This review is from: Test Driven Development: By Example (Paperback)
This Kent Beck title is an introduction to the world of Test-Driven Development (TDD). The book teaches the concepts of TDD by working through two complete sample projects. Along the way, Beck gives the reader valuable insight into the thought process and techniques behind successful test-driven development. When the reader has finished working through these sample projects, he should know enough about TDD to get started working on a TDD project.
The book is divided into three sections. The first two sections are each walkthroughs of the aforementioned sample projects using TDD. The third section is a collection of notes and useful tips to try to get the most out of TDD. If you've ever read anything from Beck, then you should be familiar with his style. If you haven't, Beck is an engaging enough writer, and the text flows smoothly and is fairly pleasant to read.
It would help to be familiar with some member of the xUnit family prior to reading this book. Beck uses Java and JUnit for the first section, but never really goes into discussing the JUnit API. Readers unfamiliar with xUnit may have no idea how to proceed with writing their own tests using one of these frameworks. True the API is simple enough that its functions may be ascertained simply by reading the code, but this is no reason not to provide explanation. The second sample project is an actual implementation of xUnit, so a bit more information may be gleaned here. Beck made the curious decision to use Python as the language of implementation for the second project, although he does provide explanation of the language's fundamentals. Finally, none of the sample projects are really complicated enough to do more than get us going on the path of TDD. There will still be many hurdles to climb when working on a real-world project.
If you are seeking a basic introduction to test-driven development, then you might enjoy this title. If you are a Java developer interested in exploring TDD more in-depth, there are better books out there.
Tracked by 1 customer
Sort: Oldest first | Newest first
Showing 1-3 of 3 posts in this discussion
Initial post: Apr 23, 2010 1:09:48 PM PDT
Can you specify which books you recommend for Java developers who are interested in exploring TDD in more depth? Thanks.
Posted on Sep 1, 2010 3:11:51 PM PDT
Chad Perrin says:
Thanks for answering a question that most reviews never do: what assumptions about knowledge of specific technologies are made by a given book. It's all too common for a book that appears to take a generalist, or generic, approach to a given programming skill to actually rely heavily on a single specific language, and specific tools within that language, to the point that not having extensive experience with that language and those tools will make the book all but useless to the reader. It is almost always Java or C# that is the offending language, though I have seen some that rely on an assumption of C++ expertise as well.
That this book's usefulness is diminished for a reader that is not familiar with Java's xUnit test frameworks (and JUnit in particular) is an incredibly useful piece of information to have when deciding whether to invest the money to buy it.
Posted on Jul 4, 2012 12:53:04 AM PDT
Last edited by the author on Jul 4, 2012 12:55:07 AM PDT
A Hindmarsh says:
This book is not a practical how-to for JUnit - it describes the abstract xUnit approach applied to OO languages in general. For me the key example is how Beck reinvents the xUnit framework in a different language (Python) with little understanding of the language itself, which speaks of its strengths. You really don't need to understand Python, and it's much less verbose than Java, and hence suitable for understanding the concepts.
So the '...: By example' moniker is perhaps misleading, but it is a great explanation of the *philosophy* of TDD.
Learning about the JUnit classes alone is of very little use in actually writing useful tests and code. Of course, in practise with Java you'd probably be using a feature-heavy IDE to drive the test-refactor cycle.
Finally, the examples in the book are based on financial software which the author actually wrote, and of course JUnit itself. How much more 'real world' do you want?
‹ Previous 1 Next ›