Rating: 
Summary: Great work covering TDD from the ground up to adv. topics
Review: (Disclaimer: I worked with the author on one large project).
Dave Astels' book is a comprehensive work covering TDD from the ground up to advanced topics. While most of the book examples use Java and JUnit, it does cover unit testing frameworks in several other languages as well. I've read two books on the topic (the other one is Kent Beck's "TDD By Example") and I liked Dave's book better. The basics of TDD can be explained in 10 minutes however when it is applied on practice it gets complicated in at least 3 areas: 1) testing UI 2) testing with database - data setup, isolation, etc. and 3) mocks. Kent's book is more about a philosophy of TDD but it only goes through a very simple "toy" example. Dave's book really helped me to understand mocks and it does cover UI testing in great length. Mocks are an advanced topic, so it does require a good knowledge of Java and OOP. The rest of the book seems to be on intermediate technical level.The only thing this book is missing, I think, is a discussion about data setup and database-related testing, dbUnit, etc., other than an advice to avoid it altogether (p. 83). While you can indeed use mocks to avoid it, on the large real projects some kind of integration testing (including testing with the database) will be necessary. I hope the second edition will come out at some point! Overall, it's a great book for both newcomers and developers with unit testing experience. BTW, it won SD West 2004 Jolt Award.
Rating: 
Summary: Finally, not just another book about web applications!
Review: Dave's book does one thing that most other books in this field do not do: it avoids the web application. Hallelujah! This book provides a good foundation for understanding TDD: the programming cycle, refactoring, tools, mock objects... it is possible to begin applying TDD for yourself after reading the first 1/3 or so of this book. Writing effectively about programming sessions is not easy. Only a few authors can do it well, and Dave does an admirable job in this. My only beef with the case study (which makes up the bulk of the book) is that, after a while, it becomes somewhat repetitive. This isn't Dave's fault: it's the nature of programming. Sometimes we just need to add another button or another text field. We don't necessarily learn anything new doing it, but if we want a finished product, we have to do it. I understand Dave's desire to present a complete (if small) project, and so applaud his willingness to risk some duplication in the name of finishing what he started. The experience of learning from this book is similar to learning from real project experience: not every page contains something new and exciting, but if you follow along and ask questions (of yourself), then you will have learned a great deal by the end.
Rating:
Summary: Mock object frameworks explained
Review: For the first time I now understand the following mock object related frameworks,
- Mock Objects Framework
- Mock Maker
- Easy Mock
Alone, the chapter that explained these frameworks was well worth the purchase price of the book.
Rating:
Summary: Excellent Practical Resource
Review: I have read Kent Beck's book also. That book is good, but this book really provides more practical advice on doing TDD development with JUnit. If you are using JUnit, then this book will provide tips, tricks, and strategies to using JUnit and other supplemental open source and commercial programs. The book has more than paid for itself already and I'm not finished reading it yet. If you are new to JUnit or TDD don't waste your time trying to come up the learning curve alone - buy this book.
Rating: 
Summary: No revelations
Review: Maybe I'd be more enthusiastic about this book if it wasn't the third one about TDD (test driven development) in a row (K. Beck: "Test-Driven Development: By Example"; J. Link: "Unit Testing in Java - How Tests Drive the Code"). The first two parts of the book explain the basics of TDD, JUnit, a couple of add-on tools and special techniques; hardly anything there which hasn't been covered equally well - and sometimes better - before. It seems to me that a beginner will have a hard time to grasp the chapters about mocks and GUI testing without additional reading. The third part describes the test-driven development of a small Swing application from start to end. These chapters are easy to read and make sense, they come with lots of repetition though. I like chapter 20 which reviews design and quality of the final piece of software using coverage metrics and alike. There are additional chapters on xUnit for other programming languages and appendices on unrelated stuff like Extreme Programming and Agile Modeling. Those make the book somewhat too bloated for my taste (500+ pages). All in all it's an okay book but with too little focus on coherence and didactics. Moreover it misses out some important topics like databases, Web applications and EJBs. Go with the competition if you are interested in that. One last thing: the copy I have has a couple of pages with blurred or very thin print; that makes some of the figures hard to decipher.
Rating:
Summary: A practical guide to test-driven development
Review: Test-driven development (TDD) is one of the hot topics in the recent "agile revolution". Unfortunately, there aren't too many texts currently available that take an in-depth look at the subject. David Astels jumps into the fray with his new book, "Test-Driven Development: A Practical Guide", in order to help fill that void. Giving a nod to Kent Beck's "Test Driven Development By Example", Astels views his work as a complement to Beck's, focusing on the practical techniques and tools necessary to best make use of TDD. The book first touches on some topics fundamental to TDD, such as refactoring, programming by intention, and of course the basic theory behind TDD. Appendices further flesh out this material by addressing extreme programming and agile modeling. Although other members of the xUnit family are looked at, this book is squarely focused on JUnit and Java. As such, the text goes into detail about using JUnit, including the API, and how to go about the task of writing tests. Along with the JUnit coverage, the reader is presented with information on several JUnit extensions and JUnit related tools designed to aid the TDD process. Where this book really shines is in its coverage of mock objects and techniques for testing GUIs within JUnit. The meat of this book rests in a very detailed walkthrough of a project using TDD. Astels leads the reader through every test and every refactoring along the way, from inception to the finished product. This is probably the next best thing to sitting down for a pair-programming session with a TDD guru. Unfortunately, there are a couple of complaints I feel the need to point out. The project presented is a Swing application that persists its data in a flat file. There is no coverage provided for testing web based enterprise applications. While mention is made of DatabaseChecker, a test utility suitable for simple database tests, Astels chose not to have the example project use a database for persistence. As a consequence of this decision, this common task is left unaddressed. Despite these omissions, there is still much to be gained from this book. I feel a reader may obtain the most benefit by downloading the sample code and working through the example project step-by-step along with the text. If you are interested in a practical guide to TDD, this book is definitely worth a look.
Rating:
Summary: TDD with some UI examples!
Review: The single best thing that distinguishes this book from the other TDD books on the market is its effort to produce a believable application during the course of using TDD. It even showed a way of unit testing GUI applications, which is easily the hardest thing in-practice about TDD. On the bad side, some nicer abstractions around the UI and any patters he'd come up with to make UI TDD better would've been a great takeaway. Also, he said that he'd be using Smalltalk-style names because that was what it was familiar with, which is totally bogus. The book should be written for the reader, not for the writer -- if he was that attached to and unwilling to give up Smalltalk, then why write it using Java?
Rating:
Summary: Wait for second edition
Review: This book contains a lot of valuable information. Unfortunately, it is VERY much a first edition. The bulk of the book is a TDD project of realistic scope. It includes approaches to GUI TDD, which I've not seen addressed in any other book. However, users beware! I found the "annotated walk through the development" to be so poorly written that I was ready to gave up in frustration about 20% of the way through. It was often difficult to determine the targets for the code snippets presented. Particularly since method names are often duplicated amongst the various classes. The style used in Kent Beck's TDD book (bolded class name above each snippet) was infinitely superior to that of this book. Another source of frustration was omissions and sequence problems. Often it would be stated that the code compiles, when in fact it would not compile without additional variables, stubs, exception handlers, etc. This was very annoying and disrupted the flow of the sessions. Of course these things will no doubt happen during real world development, but I found it distracting and counterproductive for a tutorial. Sometimes these compilation issues were cited in subsequent tests, long after my compiler voiced disapproval of the omissions. Beck's book had a few similar problems, but they were not terribly distracting. I found myself sailing through his examples with ease. With this book, however, I often had to walk away for a while to cool down. The source code for the completed project is provided on the author's web site. And that's a good thing, because there were many points at which it would have been difficult and time-consuming to resolve the omissions and target problems without it. However, even with this resource, it was often still difficult to resolve the problems due to all of the refactoring that took place over the course of the development. Beck did not provide the source code for his book, but his examples were small enough that typing the code was not time-consuming. The project in this book is of sufficient scope that having the source code is a valuable timesaving, especially with all the refactoring that occurs. Refactoring is fundamental to good code and TDD provides the security to facilitate the process. But just having the final product to document the track of the development leaves a lot to be desired on a project of this scope. It probably would have been better if the author had provided a code repository (e.g., CVS) to document the evolution of the code, checking the code in at the end of each test. This would be standard operating procedure for XP practices. That way a snapshot of the code would available as a starting point for each test in the tutorial. This is still a useful book covering a subject for which few books exist. It provides good introductions to TDD, refactoring, and programming by intention. It discusses the use of JUnit, extensions, related tools, and various xUnit family members. The coverage of mock objects is far deeper than that of Beck's book. And its coverage of GUI TDD is unique. There are also good presentations on XP and Agile Modeling. My motivation for purchasing this book in addition to Beck's book was the realistic scope of the example project. However, my enthusiasm to complete this example has deteriorated rapidly in the face of the shortcomings of its presentation. Perhaps a reformatted, corrected second edition will allow the true potential of this book to be evident.
Rating:
Summary: Wait for second edition
Review: This book contains a lot of valuable information. Unfortunately, it is VERY much a first edition. The bulk of the book is a TDD project of realistic scope. It includes approaches to GUI TDD, which I've not seen addressed in any other book. However, users beware! I found the "annotated walk through the development" to be so poorly written that I was ready to gave up in frustration about 20% of the way through. It was often difficult to determine the targets for the code snippets presented. Particularly since method names are often duplicated amongst the various classes. The style used in Kent Beck's TDD book (bolded class name above each snippet) was infinitely superior to that of this book. Another source of frustration was omissions and sequence problems. Often it would be stated that the code compiles, when in fact it would not compile without additional variables, stubs, exception handlers, etc. This was very annoying and disrupted the flow of the sessions. Of course these things will no doubt happen during real world development, but I found it distracting and counterproductive for a tutorial. Sometimes these compilation issues were cited in subsequent tests, long after my compiler voiced disapproval of the omissions. Beck's book had a few similar problems, but they were not terribly distracting. I found myself sailing through his examples with ease. With this book, however, I often had to walk away for a while to cool down. The source code for the completed project is provided on the author's web site. And that's a good thing, because there were many points at which it would have been difficult and time-consuming to resolve the omissions and target problems without it. However, even with this resource, it was often still difficult to resolve the problems due to all of the refactoring that took place over the course of the development. Beck did not provide the source code for his book, but his examples were small enough that typing the code was not time-consuming. The project in this book is of sufficient scope that having the source code is a valuable timesaving, especially with all the refactoring that occurs. Refactoring is fundamental to good code and TDD provides the security to facilitate the process. But just having the final product to document the track of the development leaves a lot to be desired on a project of this scope. It probably would have been better if the author had provided a code repository (e.g., CVS) to document the evolution of the code, checking the code in at the end of each test. This would be standard operating procedure for XP practices. That way a snapshot of the code would available as a starting point for each test in the tutorial. This is still a useful book covering a subject for which few books exist. It provides good introductions to TDD, refactoring, and programming by intention. It discusses the use of JUnit, extensions, related tools, and various xUnit family members. The coverage of mock objects is far deeper than that of Beck's book. And its coverage of GUI TDD is unique. There are also good presentations on XP and Agile Modeling. My motivation for purchasing this book in addition to Beck's book was the realistic scope of the example project. However, my enthusiasm to complete this example has deteriorated rapidly in the face of the shortcomings of its presentation. Perhaps a reformatted, corrected second edition will allow the true potential of this book to be evident.
Rating:
Summary: Demystifies Test-Driven Development (TDD)
Review: This book has changed the way I write software. It clearly states why you should do test-driven development and what tools are available, then backs this up with 200+ pages of how to do it with real code and text that captures the experience of developing a complex Java project test first. I'm a pragmatic person, so seeing the actual code and screenshots made concepts that I thought were difficult to achieve like writing tests before writing the implementation or testing GUIs (a subject that most people avoid) look surprisingly easy. All of the code in the book can be downloaded, but I found that it was more instructive to actually type in the code into an IDE. Following along with the project shows you how to proceed with test-driven development and what to expect. For example, you'll see when you need to refactor your tests or why you should test-drive most, but not all of your GUI code. After reading this book and implementing what I have learned in it, I absolutely agree with something that Ron Jeffries (another XP guru) wrote in the preface to this book: "If you're like me, using the techniques in [this] book, you will find that your programs are more clear, that they come into being more easily, and that you'll have fewer defects than you used to."
| 
