 | | |
| Test Driven Development: By Example (Addison-Wesley Signature Series) | 
| Author: Kent Beck
Publisher: Addison-Wesley Professional
Category: Book
List Price: $44.99
Buy New: $26.00
You Save: $18.99 (42%)
Buy New/Used from $25.99
Avg. Customer Rating:  (31 reviews)
Sales Rank: 18940
Languages: English (Original Language), English (Unknown), English (Published)
Media: Paperback
Number Of Items: 1
Pages: 240
Shipping Weight (lbs): 1.1
Dimensions (in): 9.1 x 7.3 x 0.6
ISBN: 0321146530
Dewey Decimal Number: 005.14
UPC: 785342146530
EAN: 9780321146533
ASIN: 0321146530
Publication Date: November 18, 2002
Availability: Usually ships in 1-2 business days
|
| Similar Items:
|
| Editorial Reviews:
Product Description
Quite simply, test-driven development is meant to eliminate fear in application development. While some fear is healthy (often viewed as a conscience that tells programmers to "be careful!"), the author believes that byproducts of fear include tentative, grumpy, and uncommunicative programmers who are unable to absorb constructive criticism. When programming teams buy into TDD, they immediately see positive results. They eliminate the fear involved in their jobs, and are better equipped to tackle the difficult challenges that face them. TDD eliminates tentative traits, it teaches programmers to communicate, and it encourages team members to seek out criticism However, even the author admits that grumpiness must be worked out individually! In short, the premise behind TDD is that code should be continually tested and refactored. Kent Beck teaches programmers by example, so they can painlessly and dramatically increase the quality of their work.
|
| Customer Reviews: Read 26 more reviews...
 Really not that good. December 16, 2008
I was expecting quite a lot from this book, because it has been recommended so many people and organizations. However this was a disappointment. I feel TDD is important topic and way to go, but this book is not the one I would recommend to anyone. It's kind of reference book, but quite poor one.
Another silly development fad... October 26, 2008
1 out of 2 found this review helpful
TDD "By Example" is a book that tries to persuade you to write tests before writing the code the tests test. In the first six chapters, the author takes you through an example of generating code through this method. Along the way, he makes several pertinent points:
1. His method has never been empirically studied to see if it helps or severely hurts the efficiency of the software development process (though the author is very interested to hear from anyone who finally DOES study his method, since he didn't have the time to do so himself, being too busy dreaming up new development processes to inflict on us).
2. His tedious, non-linear, haphazard, time-wasting (ed: my words) method is not meant to be followed precisely, but only meant to allow you to say you CAN do it that way. He makes this point numerous times. Fantastic dude, thanks. :/
I predict that this book will be purchased by software project managers both actual and wanna-be all throughout the software industry, and inflicted as a requirement on otherwise productive and smart engineers for several years to come. The final result will be projects woefully behind schedule, leading to inevitable 24-hour/7 day crunches, thereby twice punishing the engineers, and resulting in the whole silly process being dropped in the end.
Having said all this, I give the book two full stars: the english grammar is correct, and the punctuation well placed. The book is easy to understand, making it quite simple to dislike the content thereof.
 Extremely important software development practices October 12, 2008
0 out of 1 found this review helpful
Excellent book, well paced and informative. You should really go through the examples as you read those sections (part 2), even if they feel a little obvious, because if you are new to TDD you will pick up some insights. I particularly liked the Patterns section (Part 3), as it introduced some new patterns as well as talked about familiar patterns in the light of TDD.
If you are a software developer, you must put this powerful tool (TDD) in your toolbox.
 intriguing ideas, irritatingly presented June 29, 2008
1 out of 1 found this review helpful
The book's scope is well-defined and its methodology (including a running "task list" that is updated at the end of each chapter with strikeouts and new items) is innovative. But it falls sadly short in execution.
The text is overloaded with cutesy digressions that only serve to obscure the topic at hand and irritate the reader. No "Head First" title, this. To read this book is to wish over and over that its author had had the humility to submit it to another editor's series rather than launching it under his own.
Still, there is no other book quite like it on this subject, and I can certainly recommend it for extended bookstore browsing. You may find you are less sensitive than me to Beck's assaults on clarity, in which case by all means go forth and buy.
Good Theory -- But Odd Decisions In Writing May 1, 2008
1 out of 1 found this review helpful
Overall, this was a great read. I love books with tiny chapters, giving you good stopping points where you can meditate on what you just read while you're busy with life's other challenges. Beck goes into TDD as well as design concepts such as you might find in Scott Bain's Emergent Design book. Patterns are also lightly discussed.
I also love Kent Beck's casual writing style. For those of us who don't have 16 hours a day to devote to our computer, it's nice to have some humor and casual speaking happening in a book which only a hardcore reader will read -- like myself.
I give the book 4 stars, but there are a few *glaring* question marks.
First, there is no introductory chapter on using JUnit or any other *Unit.
Kent wouldn't have even had to write such a chapter himself - maybe one of the tech reviewers! You have to give the reader something to go on, even if you just merely assume the reader will use JUnit in a CLI dev environment. Or discuss all the assert calls. I dunno. Weird. But not a huge deal, and I knew how it worked already, anyway.
Second, and this is a biggie, why on Earth Kent would choose as an example writing xUnit for the second section is so beyond me I have no words. He hints later that he likes to write a *Unit library for each new language he learns, as an exercise. But, good lord, it's so hard to wrap your brain around incestuous "writing yourself" concept -- couldn't he just written something else? We're trying to learn TDD here. Geez. I mostly skimmed the whole section as it was too hard to follow.
Third, in that same section, Kent decides he will move away from Java, a language most of us already know and, if not, looks like a whole host of other languages so it's easy to follow and fairly verbose. Right, he decides to use -- ready? -- PYTHON! A language very few people know and has some strange idioms. This would be akin to writing the chapter using arcane Ruby or Perl structures. The whole second section has you trying to catch up on the language and the recursive xUnit example so much that it completely distracts from the TDD lessons.
OK, here's a fourth. Two very good examples for TDD are practically side notes. I used his late-book example of a Triangle class to do TDD for real for the first time and it was an excellent example! I did it all and only when I completed it did I read his tests. It was great, and I look forward to trying out the Fibonacci Sequence which is an *appendix*.
Why not put these in the book and explain them?
But it's still a good read. Try to avoid buying it for $40 - $50 though. I read it in 2 days without much effort, so not sure it's worth the price. But it's still very good despite all this.
|
|
|
Powered by: Dknc, inc. and Amazon.com | | 
For your safety and security, orders are processed through amazon.com
|
|
|
|
