Rating:  - Great pump-primer for ASP.NET developers
For .NET developers new to test-driven-development who want a recipe for the process, an invaluable book. This is not a concept book, but rather a concrete example that gets a little loose towards the end. Those who have also adopted Model-View-Controller for their ASP.NET applications will be able to logically extend the first half of the book to test their web interfaces, something that is admittedly difficult using the "stock" ASP.NET design philosophy.
I would supplement this book with Pragmatic Unit Testing with nUnit and C#, which gives you a much higher-level view of how to utilize TDD on a daily basis.
Rating:  - First exposure to test driven development
I attended a workshop on test driven development presented by James Newkirk. I was so intrigued with the concept that I had to go out and get his book to find out more. As a result our project now uses NUnit, TestDriven.net for test driven development and find that this has really boosted confidence in the developers and their code. The concept of test-driven development is a very useful agile method of writing code to the requirements based on tests (Red/Green/Refactor). This has certainly changed my perspective towards development and want to thank James Newkirk for purveying this concept.
Rating: - You need this book in your Agile Library!!!
Test-Driven Development in Microsoft.NET rises head and shoulders above the other books on the subject. While I know that is a very strong statement to make, the authors have made the focus of the book a very practical one. Don't get me wrong, there are several other great books on this subject, but they all seem to fall down when it comes to real-world situations.
The book is split into two parts; Part I is an overview of Test-Driven Development, and Part II covers using TDD to develop an example application.
Chapter 1 frames the entire discussion with an overview of Test-Driven Development concepts, including some straightforward guidelines for design. I thought it was laid out in very logical fashion.
Chapter 2 throws you right into the process it's a classic stack example, found in many other TDD books. What I liked most about it though, was that the chapter began with discussing HOW you start figuring out WHAT tests to write as you develop an application.
Chapter 3 covers another critical concept of TDD Refactoring. (What's Refactoring? You askread chapter 3 ;) ). Again, the authors walk you through a short yet concise primer using the Sieve of Eratosthenes implemented in C#. They introduce the algorithm and then discuss it in light of code refactoring techniques as implemented originally in Martin Fowler's Refactoring: Improving the Design of Existing Code.
Chapter 4 is the introduction of the example application that will be the focus of the remainder of the book. It lays out the scenario, project features and constraints of the fictitious project.
Chapter 5 covers an area that I've found generates a ton of interest when developers start thinking about TDD, namely data access. I really appreciated the practical approach that the authors took when writing the implementation chapters for the example application. I found the tests surrounding entities and relationships and the resulting explanations to be very good.
Chapter 6 covers how you create tests when implementing Web Services. In the process, the service interface pattern is discussed along with refactoring Web Services. The authors attempt to lead you through a "thought framework" for creating tests through each of the implementation chapters.
Chapters 7, 8, and 9 make a shift from programmer testing to customer testing and cover differing aspects of customer or acceptance testing. This group of chapters starts with an overview of acceptance testing and techniques. The middle chapter deals with driving development up through the implemented layers from a user or customer perspective. Chapter 9 rounds out the discussion by focusing on handling faults and how acceptance testing allows you to tighten things up.
Chapter 10 leads us back to the programmer testing side by dealing with transactions. Following this, Chapter 11 introduces the reader to Service-level refactoring, leading you through the thought process behind different techniques. The story winds down in Chapter 12 with applying the process of TDD to implementing a web client.
All in all, while I'd have like to have seen a both a simpler example and always more "real world" tips and tricks, I can tell you from my own experience that finding that balance is extremely difficult. I believe the authors have made a significant attempt at striking the "real world" / simplicity balance and that the resulting outcome is an excellent resource for learning TDD. When that is combined with the level of effort the authors are putting in to maintaining the code and forums at their GotDotNet workspace, this makes Test-Driven Development in Microsoft .NET an excellent choice for your library.
Rating: - Great Book for Experienced Developers
This is a great book for experienced developers. It covers a wide range of realistic uses in .NET and has plenty of detailed examples. It gets you into the mindset of Test-Driven Development (TDD) in good increments. The NUnit discussed is a free download and is very easy to start using with your own software quickly, so you can come up to speed right away and begin using it on your projects. One of the better TDD books that I have read, possibly the best. It will certainly remain on my bookshelf for some time.
Rating: - Changes Your View
Many people think that Test-Driven Development (TDD) is all about testing software. In fact, test-driven development's main goal is not testing software, but aiding the programmer and customer during the development process with unambiguous requirements. The requirements are in the form of tests that the software must pass along the development process.
This procedure helps to insure that problems are found early and corrected while they are still small.
This book first discusses TDD from a conceptual point of view then gives a TDD example using a realistic application.
|
