- Paperback: 256 pages
- Publisher: Addison-Wesley Professional; 1 edition (September 4, 2009)
- Language: English
- ISBN-10: 0321636414
- ISBN-13: 978-0321636416
- Product Dimensions: 7 x 0.7 x 9.1 inches
- Shipping Weight: 1 pounds (View shipping rates and policies)
- Average Customer Review: 10 customer reviews
- Amazon Best Sellers Rank: #820,382 in Books (See Top 100 in Books)
Enter your mobile number or email address below and we'll send you a link to download the free Kindle App. Then you can start reading Kindle books on your smartphone, tablet, or computer - no Kindle device required.
To get the free app, enter your mobile phone number.
Exploratory Software Testing: Tips, Tricks, Tours, and Techniques to Guide Test Design 1st Edition
Use the Amazon App to scan ISBNs and compare prices.
The Amazon Book Review
Author interviews, book reviews, editors picks, and more. Read it now
Frequently bought together
What other items do customers buy after viewing this item?
From the Back Cover
How to Find and Fix the Killer Software Bugs that Evade Conventional Testing In "Exploratory Software Testing," renowned software testing expert James Whittaker reveals the real causes of today's most serious, well-hidden software bugs--and introduces powerful new "exploratory" techniques for finding and correcting them. Drawing on nearly two decades of experience working at the cutting edge of testing with Google, Microsoft, and other top software organizations, Whittaker introduces innovative new processes for manual testing that are repeatable, prescriptive, teachable, and extremely effective. Whittaker defines both in-the-small techniques for individual testers and in-the-large techniques to supercharge test teams. He also introduces a hybrid strategy for injecting exploratory concepts into traditional scripted testing. You'll learn when to use each, and how to use them all successfully. Concise, entertaining, and actionable, this book introduces robust techniques that have been used extensively by real testers on shipping software, illuminating their actual experiences with these techniques, and the results they've achieved. Writing for testers, QA specialists, developers, program managers, and architects alike, Whittaker answers crucial questions such as: - Why do some bugs remain invisible to automated testing--and how can I uncover them? - What techniques will help me consistently discover and eliminate "show stopper" bugs? - How do I make manual testing more effective--and less boring and unpleasant? - What's the most effective high-level test strategy for each project? - Which inputs should I test when I can't test them all? - Which test cases will provide the best feature coverage? - How can I get better results by combining exploratory testing with traditional script or scenario-based testing? - How do I reflect feedback from the development process, such as code changes?
About the Author
James Whittaker has spent his career in software testing and has left his mark on many aspects of the discipline. He was a pioneer in the field of model-based testing, where his Ph.D. dissertation from the University of Tennessee stands as a standard reference on the subject. His work in fault injection produced the highly acclaimed runtime fault injection tool Holodeck, and he was an early thought leader in security and penetration testing. He is also well regarded as a teacher and presenter, and has won numerous best paper and best presentation awards at international conferences. While a professor at Florida Tech, his teaching of software testing attracted dozens of sponsors from both industry and world governments, and his students were highly sought after for their depth of technical knowledge in testing.
Dr. Whittaker is the author of How to Break Software and its series follow- ups How to Break Software Security (with Hugh Thompson) and How to Break Web Software (with Mike Andrews). After ten years as a professor, he joined Microsoft in 2006 and left in 2009 to join Google as the Director of Test Engineering for the Kirkland and Seattle offices. He lives in Woodinville, Washington, and is working toward a day when software just works.
Top customer reviews
There was a problem filtering reviews right now. Please try again later.
Most software organizations split up testing responsibilities in a way where one test engineer is assigned a feature, and then he tests that feature from a lot of different angles - acceptance tests, error tests, stress tests, etc. Whittaker's approach, as espoused in this book, is to turn things 90 degrees around. Instead of the classic way, give a test engineer one angle and then have him test all features from that angle. This exercises connections between features, which is where more bugs (supposedly) live.
That's the thesis, and most of rest of the good part of the book is material to help explain that and flesh it out. Unfortunately, there's also a lot of material that's just filler, like poorly-written blog articles from Whittaker's coworkers. A lot of the rest of it sounds like his own blog posts, too, and one whole appendix is literally that! As an aside, I've gotta say that's a great job if you can get it - reuse material you wrote at your day job, and get paid a second time to publish it in a book. Awesome!
Unfortunately, for such a detail-oriented guy in a detail-oriented field like software testing, there are a lot of mistakes in Whittaker's text. The editor, assuming they actually paid one, did a distractingly poor job, at least on the Kindle version of the book. And the sections written by Whittaker's non-writer coworkers read just like emails - typos, grammar errors, inconsistencies, and all (the guy who uses backslashes when he means forward slashes is adorable when you consider he's paid by Microsoft). The writing feels very authentic for a blog, but not up to professional-grade standards for a book.
Inside this tiny book is a focused 60-page monograph struggling to meet an editor who can dig it out and reveal its genius to the world. There's some good stuff in here, but you'll have to work for it.
EDIT: Apparently I put this review on the paperback version of the book. I actually read the Kindle version of the book. I assume the text is the same, and since I didn't comment on the binding or page material, this review should be just as relevant.
Chapter 1 - "The Case for Software Quality" is nothing more than "software is terrific, but it has bugs". That's it, nothing more here.
Chapter 2 - "The Case for Manual Testing" talks a bit about testing, and tries to define exploratory testing. Whittaker's definition has apparently caused some controversy among some well-known practitioners of exploratory testing, so here is his perhaps unique definition:
"When the scripts are removed entirely (or as we shall see in later chapters, their rigidness relaxed), the process is called exploratory testing."
Whittaker then divides exploratory testing into two sections. Exploratory testing in the small is that which guides the tester to make small, distinct decisions while testing. Exploratory testing in the large guides the tester in how an application is explored more than how a specific feature is tested.
Chapter 3 - "Exploratory Testing in the Small" was, to me, the only useful chapter in the whole book. Here Whittaker offers practical advice with examples for thinking about constructing test data, software state, and test environment.
Chapter 4 - "Exploratory Testing in the Large" is where Whittaker dives into what appears to be the point of the whole book - his Tourist Metaphor. Apparently this is a big hit at Microsoft, but I found it pointless. Think about every type of testing you have ever performed. Now try to torture it into a phrase that ends with the word Tour. There you go - that's the chapter.
Just to give you a flavor, here's a list of all these Tours, and their variations:
The Guidebook Tour
The Money Tour
Skeptical Customer Tour
The Landmark Tour
The Intellectual Tour
Arrogant American Tour
The FedEx Tour
The After-Hours Tour
The Garbage Collector's Tour
The Bad-Neighborhood Tour
The Museum Tour
The Prior Version Tour
The Supporting Actor Tour
The Back Alley Tour
The All-Nighter Tour
The Collector's Tour
The Lonely Businessman's Tour
The Supermodel Tour
The TOGOF Tour
The Scottish Pub Tour
The Rained-Out Tour
The Couch Potato Tour
The Saboteur Tour
The Antisocial Tour
Crime Spree Tour
Wrong Turn Tour
The Obsessive-Compulsive Tour
Perhaps the idea of calling UI Testing a Supermodel Tour appeals to you, and will make for a richer, more productive set of tests. I don't get it. I just don't see any value here. Doesn't testing have enough variation in language and definitions already, without adding this silliness?
Chapter 5 - "Hybrid Exploratory Testing Techniques" tells us that it's acceptable to combine scenario testing with exploratory testing. Then it spends time rehashing each of the tours from Chapter 4 and tries to suggest a side trip for each.
Chapter 6 - "Exploratory Testing in Practice" presents essays written by several Microsoft testers describing how they each used one or more of the tours in a testing situation. It appears as if Whittaker instructed his charges to write a "What I did this summer"-style essay, in the form of "How I used Tours to do my testing".
Chapter 7 - "Touring and Testing's Primary Pain Points" tries to tell us (in a few paragraphs) how to avoid five pain points - Aimlessness, Repetiveness, Transiency, Monontony, and Memorylesness. There's little real instruction here. For example, we are told that in order to avoid repetitiveness, we must know what testing has already occurred, and understand when to inject variation. Uhm, ok.
Chapter 8 - "The Future of Software Testing" has nothing at all to do with the other chapters, or exploratory testing. It's basically Whittaker's gee-whiz vision of what might be possible (some day) in the future. Perhaps. Whittaker has given this talk in several webinars - it's simply rehashed here.
Since these chapters take up only 136 pages, and obviously aren't enough to fill out a real book, three unrelated appendices are bolted on. A few pages about Testing as a career, and a bunch of pages lifted directly from Whittaker's blogs fill out the book to over 200 pages.
If you really want to learn about Exploratory Testing, this is probably not the place. "Exploratory Software Testing" is fluff - stretched and tortured out barely to book-length. There's not much in the way of learning here.
And if Microsoft testers are really instructed to "Tell me what kind of testing you did today, and make sure it ends with the word Tour", then I feel very sorry for them.