Rating: 
Summary: Great Introduction to Test Driven Development
Review: On multiple projects I've spent a lot of time encouraging, cajoling and sometimes forcing developers on the team to write unit tests for their code. Test Driven Development is an important skill that a lot of developers need to master. It is great to see a book devoted to the topic that provides some good examples on how to do it. In addition to the examples, the test patterns are also very useful. Most of the examples in the book use Java, with the rest in Python. Personally, I would have preferred that the book used Java exclusively. This is a minor complaint however. Overall this is a good book.
Rating: 
Summary: Fail, Run, Run Clean
Review: The are a small number of writers who can teach programming skills effectively. Kent Beck is one of them. There are a small set of practices that you can adopt on your own that will have an clearly observable impact on the quality of your results and the quality of your work day. Test Driven Develoment (TDD) is one of them. If you are a software developer, you want to buy, read and study this book.TDD fits development into a three micro-phase cycle: create a test that embodies your requirement, write code that passes the test, make the code run clean. Each phase has different goals, patterns and pitfalls. Like any good coach, Beck walks you through these in detail. He uses multiple examples: most notably a business model in Java and a unit testing framework in Phython. He follows up with a question and answer section that reviews common patterns in test driven development cycle. The level of learning involved in doing TDD is profound. The best way to read the book is to do the book. Skills come from doing not reading. I did the examples (in another language) and it made all the difference in what I learned. A footnote for managers: TDD is the opening wedge for a set of practices known as extreme programming (XP) or agile development. Test driven development is powerful enough to work on its own for the single delevoper. If you want to realize its full value, however, you need to embrace the full set of XP practices for the whole organization.
Rating:
Summary: Should you buy it? Yes!
Review: This book does a remarkable job of covering the philosophy behind good unit tests and frequent automated builds. The author is very forward thinking in the ideas presented. If you want to get up to speed quickly then buy this book.
Rating:
Summary: So simple to do-- write better code
Review: This book has nothing in it that you don't know you should be doing. You know you should test your code. You know that you should make sure changes don't break things. I'll bet that you haven't actually taken the steps to make sure that you do this though. Kent walks you through a good way to develop code: write the test code as you write the actual code. I've actually put this into practice and it's surprisingly easy to follow the recommendations. As you write a new function, write some code that calls it in a few different ways. When it comes time to give your code to someone else (check in to source control, deliver to customer, use on a bigger project), you have a fair sense that things will work. Again, you already know that you should test things. This book presents one really great way to do that. It's worth taking a few hours and reading this one. Buy it so that you can re-read it once every year.
Rating:
Summary: Enjoyable book about an approach that's more than worthwhile
Review: This is a short and fast read. You regret it that the book is already finished.
This is one of the few books where you read about the authors' misconceptions and mistakes - not about the glorious final elegant solution at the end. Usually this is pretty annoying, not with this author (and also not with Martin Fowler). It is pure enjoyment to be taken along the intellectual journeys of writing a program with Kent Beck.
So read it and have fun.
Rating:
Summary: A Great Experience
Review: This is the most interesting book that I have read. During the first 20 pages, I dispise it. After 20 pages, I get it. After part I, I love it. At part III, I worship it! The book start with example that involves teeny, weeny steps of test driven development that made me think this is really for people who don't know how to write test. And I consider myself to be a fully test-infected developer -- well, until I finally understand the idea that Kent is trying to convey here. It shows not only how to create a test case for a class, but also how to use test as the driving tool to assist refactoring for a better cleaner code. Becaus the way of development process is so much different from the normally way (well, depends on what you think is normally, isn't it), Kent carefully makes sure that the user doesn't get ahead of himself or herself. With little jokes here and little comments there, it really feels like being pair-programming with an XP mentor (it does, because I have been pair-programming with an XP mentor), who paitiently explains everything that is going on in his or her mind. The second part of the book is also very unique. It goes through a process of using TDD to write a unit test framework. It shows, nicely, how to do TDD before the testing framework is in place, thus really tells what is the heart of TDD, and teaches a great lesson that TDD is not just writing test cases, but also a revolutionary development process. The third part summrized patterns used in TDD, need I say more?
Rating:
Summary: A Great Experience
Review: This is the most interesting book that I have read. During the first 20 pages, I dispise it. After 20 pages, I get it. After part I, I love it. At part III, I worship it! The book start with example that involves teeny, weeny steps of test driven development that made me think this is really for people who don't know how to write test. And I consider myself to be a fully test-infected developer -- well, until I finally understand the idea that Kent is trying to convey here. It shows not only how to create a test case for a class, but also how to use test as the driving tool to assist refactoring for a better cleaner code. Becaus the way of development process is so much different from the normally way (well, depends on what you think is normally, isn't it), Kent carefully makes sure that the user doesn't get ahead of himself or herself. With little jokes here and little comments there, it really feels like being pair-programming with an XP mentor (it does, because I have been pair-programming with an XP mentor), who paitiently explains everything that is going on in his or her mind. The second part of the book is also very unique. It goes through a process of using TDD to write a unit test framework. It shows, nicely, how to do TDD before the testing framework is in place, thus really tells what is the heart of TDD, and teaches a great lesson that TDD is not just writing test cases, but also a revolutionary development process. The third part summrized patterns used in TDD, need I say more?
Rating: 
Summary: A decent introduciton
Review: 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.
Rating:
Summary: A decent introduciton
Review: 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.
Rating:
Summary: Valuable testing patterns and gainful techniques
Review: While the first two parts of the book: "The Money Example" and "The xUnit Example" may seem discontenting for an experienced XP'er, the third part: "Patterns for Test-Driven Development" is amazingly impressive. It brings lot of valuable patterns: Test-Driven Development Patterns, Red Bar Patterns, Testing Patterns, Green Bar Patterns, xUnit Patterns and Design Patterns. Despite the book "Design Patterns" seems to be provisioning, design in test-driven-development requires a slightly different look at design patterns, and Kent Beck has done his best in providing not only the common vocabulary, but a gainful technique not known to be described anywhere else before. Before the publication of this book, there was a lack of a good manual for xUnit testing framework. The title "Testing Extreme Programming" by Lisa Crispin and Tip House, released a couple of month before this book, didn't fill the gap. This book is the first significant guidebook for xUnit ever released. While the work "Extreme Programming Installed" exposes most valuable testing experience among other XP titles, it didn't focus on xUnit as well. I would recommend "Design Pattern" and "Refactoring" in addition to this book, assuming that you are aware of the XP manifesto: "Extreme Programming Explained".
| 
