Customer Reviews


20 Reviews
5 star:
 (10)
4 star:
 (6)
3 star:
 (2)
2 star:
 (2)
1 star:    (0)
 
 
 
 
 
Average Customer Review
Share your thoughts with other customers
Create your own review
 
 

The most helpful favourable review
The most helpful critical review


3 of 3 people found the following review helpful
5.0 out of 5 stars From a Software Tester's Perspective
I enjoyed reading this book, however I must advise that non-coders will probably have difficulty in staying with it. I don't mean that as a put-down of any kind. It's obvious that the intended audience is the developer who is trying to understand the concept of test-driven development. A tester, however, would learn in this book that test-driven development uses tests...
Published on April 6 2004 by Randy Rice

versus
2 of 2 people found the following review helpful
3.0 out of 5 stars Stops where it gets interesting
I like the way Kent Beck writes his books. And it's sometimes thrilling to read his strange ideas. Having seen so many projects skip unit testing completely the idea of writing tests first strikes me as very good. Mr Beck presents his ideas very clearly and leads the reader through all subtleties and traps of a small example. That's exactly the point where things become...
Published on June 13 2003 by frankmpotsdam


‹ Previous | 1 2 | Next ›
Most Helpful First | Newest First

3 of 3 people found the following review helpful
5.0 out of 5 stars From a Software Tester's Perspective, April 6 2004
This review is from: Test Driven Development: By Example (Paperback)
I enjoyed reading this book, however I must advise that non-coders will probably have difficulty in staying with it. I don't mean that as a put-down of any kind. It's obvious that the intended audience is the developer who is trying to understand the concept of test-driven development. A tester, however, would learn in this book that test-driven development uses tests that are different in nature and rigor than those commonly thought of as "unit tests."
I think Beck does a good job in explaining test-driven development in a way that is easy to understand. I still have some concerns about the nature of test-driven development, such as the emphasis on function over design. But I think Beck achieved a reasonable goal of presenting by example what test-driven development is all about.
The goal of test-driven development is a reasonable way to achieve "clean code that works - now." As a tester, I think the awareness of test-driven development is a good thing. I also think that this technique must be combined with other methods, such as getting quality requirements, verification and validation, to achieve a final result that meets the users' needs.
Readability - 4
Coverage of topics - 5
Depth of coverage - 5
Credibility - 5
Accuracy - 5
Relevance to software quality - 5
Overall - 5
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


2 of 2 people found the following review helpful
3.0 out of 5 stars Stops where it gets interesting, June 13 2003
This review is from: Test Driven Development: By Example (Paperback)
I like the way Kent Beck writes his books. And it's sometimes thrilling to read his strange ideas. Having seen so many projects skip unit testing completely the idea of writing tests first strikes me as very good. Mr Beck presents his ideas very clearly and leads the reader through all subtleties and traps of a small example. That's exactly the point where things become interesting for me: How does the academic idea scale when being faced with Web apps, EJBs, XML/XSLT and so on? Hardly any hints about that which makes me wondering if the approach can be used for real projects.
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


2 of 2 people found the following review helpful
2.0 out of 5 stars Poorly written...disappointing, Jan. 5 2003
By A Customer
This review is from: Test Driven Development: By Example (Paperback)
I bought this book with high expectations. I'm a true believer in testing early and often. Basically, I think the techniques have merit, but the presentation was lacking.
I was disappointed with the writing -- all of the little asides that were attempts at humor fell flat and were distracting. The biggest disappointment was that a chapter on how to integrate these techniques into the processes of a project, especially a large project, was ommitted.
At one point, the book states rather flippantly something to the effect that "You'll have to come up with your own argument to convince your boss to let you spend the time writing all these tests." I think that since he's the one promoting these techniques, he should be able to come up with those arguments. Personally, I think the argument is something like this:
- helps produce clean, modular code by forcing the designer to think about interfaces of the objects first. Coming up with good interfaces is half the battle.
- reduces defects tremendously because automated tests are available from the beginning and are used constantly.
- combines aspects of design and testing into the construction phase. So, the argument is that the "added" time spent writing tests saves time in the design and testing phases.
I would have also liked to have seen a section on the dangers of stubbed out code. Since the technique causes you to stub out a lot of methods, as you go through the process and people are fallable, it warrants discussion. Sometimes they forget that some of the code is stubbed. I've seen situations where stubbed out code (ie, return true) provided the correct answer for a surprisingly long time. It wasn't until it got into system testing that some of the less frequently encountered data caused mysterious problems to come up in supposedly working code.
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


1 of 1 people found the following review helpful
5.0 out of 5 stars Allows you to judge TDD for yourself, April 17 2003
By 
Martin P. Cohen "Seeker" (Langhorne, PA USA) - See all my reviews
(REAL NAME)   
This review is from: Test Driven Development: By Example (Paperback)
Let me say first off that I agree with much that Kent Beck has to say: 1. Testing should be done along with the coding. 2. Use regression tests to be confident of making changes. 3. In many ways testing can be used as documentation since it is much more definitive than specification documents. 4. Testing should be used to have the client sign off on a product. In reading the book I learned the specifics of how tests are designed in TDD. It seems reasonable and I am going to make a conscious effort at designing my tests in the way suggested.
Where I disagree is in the use of the tests to drive software design. In the first part of the book, which I think is the most important part, a very good coding problem is analyzed - it is realistic, limited in scope and far from trivial. I followed along until I reached a point where things stopped making sense. I skipped ahead to see where things were headed and then things became clear.
What is being advocated is a type of bottom up design approach. This may work for some. It may even be that the book faithfully reproduced Beck's reasoning process. It does not work for me. I first have to see the larger picture, what he refers to as the "metaphor." The whole thing would have been much clearer to me if at the beginning I was told that one approach to summing money in different currencies would be to use an array to store the information but that instead the implementation would create a list similar to how things are done in LISP.
I urge the reader to judge for him/herself. Like I said this is a good example to go through. I even learned some things about more advanced uses of object oriented programming. As for software design I am going to stick with dataflow diagrams. They are still the best tool that I know of for putting together software, UML notwithstanding.
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


1 of 1 people found the following review helpful
4.0 out of 5 stars 90% is Just Showing Up, Dec 9 2002
By 
R. Williams "code slubber" (Los Angeles, CA United States) - See all my reviews
This review is from: Test Driven Development: By Example (Paperback)
Everyone who's read about XP has wanted a book like this forever, so a decent performance was bound to be a happy occasion (a hot dog is a feast to a starving man). I would disagree with the last reviewer and say that the first part of the book is the good part, when the author works through his 'money' example. At the end of it, there's a great moment when Beck acknowledges the importance of metaphor, claiming that he'd done the same exercise a number of times, though this time, he had picked a better metaphor and it subsequently went a lot faster. I have to laugh at this. This is a case of obiter dicta (giving away the key to something in passing). But the funny thing is that Beck doesn't notice how important it is. He proceeds to just meander through the rest of the book. Then, the book just goes down the rathole as we feel like we're being treated to a prof who's run through his material and is just waiting for the bell. The section on patterns is abominable, ending with a thing on Singleton that says something like 'Don't use global variables, your programs will be happier,' which is a ridiculous capsulization of an issue that a lot of people have discussed many times before. A Singleton is globally available. It's not a variable. Mail servers are globally available too. Guess we shouldn't use them either.
Let me also say that I am really kind of fed up with Kent Beck's Opi Taylor writing style. It's ok when the focus is on the KISS side of the equation and generally positive, but his snide little sideswipes throughout this book on everything from the open-closed principle to the idea of doing specifications (another searing, strong argument that boils down to the root of the word being the same as for the word speculation (!)) are really laughable. Makes me wanna say, yeah, who needs a spec if all they are doing is the 10 millionth payroll program or a currency converter. Don't look to Kent Beck for big answers, as a matter of fact, by his own half-conscious admission, he's as much in search of them as we are.
So why 4 stars? Per the subject, the Woody Allen principle. Another hysterical part of this book is at the very end he shows a list of things someone else suggested, none of which are covered in the book, as if he had to tell us, at the end, that he knew just how much was missing.
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


4.0 out of 5 stars The source for TDD, May 24 2014
Verified Purchase(What's this?)
This review is from: Test Driven Development: By Example (Paperback)
This is the source for TDD.

My only complaint is that the writing is sometimes too much a stream of thought. This can be difficult to understand and follow.

What this book emphasizes is the small steps you take when refactoring. Most other books and articles gloss over the refactor step in "Red, Green, Refactor". With this book you get a good idea of how you can take very small steps when refactoring. This is important, especially when first learning about TDD.
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


5.0 out of 5 stars Now I get it, Feb. 22 2013
Verified Purchase(What's this?)
This review is from: Test Driven Development: By Example (Paperback)
I never really understood TDD before reading this book. A clear explanation, step-by-step with concrete examples, is what I needed to truly understand TDD.

The author also have an entertaining writing style which make it easier to read.
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


2.0 out of 5 stars Quiet! Please!, Feb. 4 2013
By 
This review is from: Test Driven Development: By Example (Paperback)
The book is peppered with annoying digressions such as the following:

"When I was a young programmer- long, long ago when we had to dig our own bits out of the snow and carry heavy buckets of them barefooted back to our cubicles, leaving bloody footprints for the wolves to follow…Sorry, just reminiscing."

As one reviewer noted, the narrative is written as if the author were sitting next to you. If he were sitting next to me, I'd probably pull my teeth out in an attempt to clear my consciousness from his inane chatter.

If you are looking for a clear, focused, and complete text on TDD keep looking!
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


4 of 4 people found the following review helpful
3.0 out of 5 stars A decent introduciton, March 12 2004
By 
Jason (United States) - See all my reviews
(REAL NAME)   
This review is from: Test Driven Development: By Example (Paperback)
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.
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


4 of 4 people found the following review helpful
5.0 out of 5 stars A Great Experience, Sept. 12 2003
By 
S. Duan "wolfdancer" (Bay Area, CA United States) - See all my reviews
(REAL NAME)   
This review is from: Test Driven Development: By Example (Paperback)
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?
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


‹ Previous | 1 2 | Next ›
Most Helpful First | Newest First

This product

Test Driven Development: By Example
Test Driven Development: By Example by Kent Beck (Paperback - Nov. 8 2002)
CDN$ 51.99 CDN$ 32.75
In Stock
Add to cart Add to wishlist
Only search this product's reviews