![]() Trade In this Item for up to £6.15
Get an extra £5 when you trade in books worth £10 or more until June 30, 2012. Trade in Test Driven Development: A Practical Guide (Coad) for an Amazon.co.uk gift card of up to £6.15, which you can then spend on millions of items across the site. Trade-in values may vary (terms apply). Find more products eligible for trade-in.
|
Product details
|
This book teaches programmers how to make Test Driven Development (TDD) work in their organization. TDD is unique because it forces the programmer to write tests for code before the code is actually written. This process is the reverse of how software testing has traditionally been conducted, but TDD ensures that software is produced more efficiently. A test-first mentality allows the programmer to define, specify, illustrate, limit, and drive the code, resulting in documented, tested, code that is as simple and lean as possible. The book also presents tools and techniques, and all major points are supported by numerous examples (including an entire project, end-to-end) and exercises.
Test-Driven Development: A Practical Guide
David R. Astels
Foreword by Ron Jeffries
Make Test-Driven Development work for you!
Test-Driven Development: A Practical Guide enables developers to write software that's simpler, leaner, more reliable... just plain better.
Now, there's a TDD guide focused on real projects, real developers, real implementation challenges, and real code.
Renowned agile development expert Dave Astels shows TDD at work in a start-to-finish project written in Java and using the JUnit testing framework. You'll learn how "test first" works, why it works, what obstacles you'll encounter, and how to transform TDD's promise into reality.
Read this book if you're ready to write code that's clearer, more robust, and easier to extend & maintain--in short, if you're ready to write better code!
Tags Customers Associate with This Product(What's this?)Click on a tag to find related items, discussions, and people.
|
On the other hand, you may be wondering if you can manage a book devoted entirely to TDD, which can easily devolve into walk throughs of frameworks for applications irrelevant to your needs, which is mainly: given that you're persuaded TDD is a good idea, how do you go about doing it for more than trivial examples?
This book comes up with the goods. As expected, there's an introduction to agile techniques, and an overview of JUnit, but this goes further, and gives an overview of several JUnit extensions, which is very helpful for those seeking ways to extend their testing.
The other two important introductory chapters are on Mock objects and testing GUIs. The section on mock objects is useful (and rarely touched upon in more introductory texts), although I would say that the treatment by Johannes Link in Unit Testing In Java (which has a similar scope) is better.
The really great part of this book, however, is the 200 page step-by-step tutorial in TDD with JUnit, building a simple GUI application for storing films, and their reviews and rating. The conversational tone of the writing is very effective in illustrating the decisions in how to decide what to test next, and how to do it. If you don't 'get' TDD, this section is a must-read and the most valuable part of the book.
Jeff Langr's Agile Java very successfully covers a lot of the ground in this book, but also attempts to teach Java 5.0 at the same time, so this book is more focussed. It's probably not essential reading if you've read Langr's book, but this book does cover more.
If you've also read Unit Testing in Java (or have read that book and are wondering if you should pick this one up too), then you probably don't need to read both. Either one should suit your needs admirably. There is perhaps not enough difference between them to justify getting both, but if money is no object, then they complement each other well - Link's book covers more applications (e.g. databases, networks, web servers), and is better for its treatment of mock objects, while this book has more depth on testing GUIs and JUnit extensions and unit testing frameworks in other languages.
The tutorial is the meat of the book, however, and is worth the price.
The book did answer many questions I had of how to best to use TDD, as well as showing me the wonderful extensions and tools that exist for JUnit.
I do have some quibbles with the book however. For starters, the author seems to use methods before hes written them. Leaving me to look back through the book to see if ive missed something. He tells us that there may be some bits missing and that we can go to the printed URL to download the full sorce code. However this link is broken and there are no responses to my e-mails to find out where it is. This is very frustrating but shouldn't prevent you from absorbing what needs to be absorbed.
If you can ignore these mistakes, this book will greatly benefit your understanding of this most useful of software engineering techniques.
Its also worth noting that although this book concentrates on Java its actually still worth getting if your a C# developer (as I am).
|
|
|