Exploratory Software Testing and over one million other books are available for Amazon Kindle. Learn more
  • List Price: $44.99
  • Save: $9.41 (21%)
Only 8 left in stock (more on the way).
Ships from and sold by Amazon.com.
Gift-wrap available.
Exploratory Software Test... has been added to your Cart
+ $3.99 shipping
Condition: Used: Good
Comment: Connecting readers with great books since 1972. Used books may not include companion materials, some shelf wear, may contain highlighting/notes, may not include cd-om or access codes. Customer service is our top priority!
Access codes and supplements are not guaranteed with used items.
Sell yours for a Gift Card
We'll buy it for $12.20
Learn More
Trade in now
Have one to sell? Sell on Amazon
Flip to back Flip to front
Listen Playing... Paused   You're listening to a sample of the Audible audio edition.
Learn more
See all 3 images

Exploratory Software Testing: Tips, Tricks, Tours, and Techniques to Guide Test Design Paperback – September 4, 2009

10 customer reviews
ISBN-13: 978-0321636416 ISBN-10: 0321636414 Edition: 1st

Buy New
Price: $35.58
23 New from $25.61 21 Used from $23.02
Amazon Price New from Used from
"Please retry"
"Please retry"
$25.61 $23.02

Hero Quick Promo
Save up to 90% on Textbooks
Rent textbooks, buy textbooks, or get up to 80% back when you sell us your books. Shop Now
$35.58 FREE Shipping. Only 8 left in stock (more on the way). Ships from and sold by Amazon.com. Gift-wrap available.

Frequently Bought Together

Exploratory Software Testing: Tips, Tricks, Tours, and Techniques to Guide Test Design + How to Break Software: A Practical Guide to Testing W/CD + Lessons Learned in Software Testing: A Context-Driven Approach
Price for all three: $97.21

Buy the selected items together

Editorial Reviews

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.


Excerpt. © Reprinted by permission. All rights reserved.

Exploratory Software Testing

Exploratory Software Testing


“Customers buy features and tolerate bugs.”
—Scott Wadsworth

Anyone who has ever used a computer understands that software fails. From the very first program to the most recent modern application, software has never been perfect.

Nor is it ever likely to be. Not only is software development insanely complex and the humans who perform it characteristically error prone, the constant flux in hardware, operating systems, runtime environments, drivers, platforms, databases, and so forth converges to make the task of software development one of humankind’s most amazing accomplishments.

But amazing isn’t enough, as Chapter 1, “The Case for Software Quality,” points out, the world needs it to be high quality, too.

Clearly, quality is not an exclusive concern of software testers. Software needs to be built the right way, with reliability, security, performance, and so forth part of the design of the system rather than a late-cycle afterthought. However, testers are on the front lines when it comes to understanding the nature of software bugs. There is little hope of a broad-based solution to software quality without testers being at the forefront of the insights, techniques, and mitigations that will make such a possibility into a reality.

There are many ways to talk about software quality and many interested audiences. This book is written for software testers and is about a specific class of bugs that I believe are more important than any other: bugs that evade all means of detection and end up in a released product.

Any company that produces software ships bugs. Why did those bugs get written? Why weren’t they found in code reviews, unit testing, static analysis, or other developer-oriented activity? Why didn’t the test automation find them? What was it about those bugs that allowed them to avoid manual testing?

What is the best way to find bugs that ship?

It is this last question that this book addresses. In Chapter 2, “The Case for Manual Testing,” I make the point that because users find these bugs while using the software, testing must also use the software to find them. For automation, unit testing, and so forth, these bugs are simply inaccessible. Automate all you want, these bugs will defy you and resurface to plague your users.

The problem is that much of the modern practice of manual testing is aimless, ad hoc, and repetitive. Downright boring, some might add. This book seeks to add guidance, technique, and organization to the process of manual testing.

In Chapter 3, “Exploratory Testing in the Small,” guidance is given to testers for the small, tactical decisions they must make with nearly every test case. They must decide which input values to apply to a specific input field or which data to provide in a file that an application consumes. Many such small decisions must be made while testing, and without guidance such decisions often go unanalyzed and are suboptimal. Is the integer 4 better than the integer 400 when you have to enter a number into a text box? Do I apply a string of length 32 or 256? There are indeed reasons to select one over the other, depending on the context of the software that will process that input. Given that testers make hundreds of such small decisions every day, good guidance is crucial.

In Chapter 4, “Exploratory Testing in the Large,” guidance is given for broader, strategic concerns of test plan development and test design. These techniques are based on a concept of tours, generalized testing advice that guides testers through the paths of an application like a tour guide leads a tourist through the landmarks of a big city. Exploration does not have to be random or ad hoc, and this book documents what many Microsoft and Google testers now use on a daily basis. Tours such as the landmark tour and the intellectual’s tour are part of the standard vocabulary of our manual testers. Certainly, test techniques have been called “tours” before, but the treatment of the entire tourist metaphor for software testing and the large-scale application of the metaphor to test real shipping applications makes its first appearance in this book.

Testing in the large also means guidance to create entire test strategies. For example, how do we create a set of test cases that give good feature coverage? How do we decide whether to include multiple feature usage in a single test case? How do we create an entire suite of test cases that makes the software work as hard as possible and thus find as many important bugs as possible? These are overarching issues of test case design and test suite quality that have to be addressed.

In Chapter 5, “Hybrid Exploratory Testing Techniques,” the concept of tours is taken a step further by combining exploratory testing with traditional script or scenario-based testing. We discuss ways to modified end-to-end scenarios, test scripts, or user stories to inject variation and increase the bug-finding potential of traditionally static testing techniques.

In Chapter 6, “Exploratory Testing in Practice,” five guest writers from various product groups at Microsoft provide their experience reports from the touring techniques. These authors and their teams applied the tours to real software in real shipping situations and document how they used the tours, modified the tours, and even created their own. This is the first-hand account of real testers who ship important, mission-critical software.

Finally, I end the book with two chapters aimed at wrapping up the information from earlier chapters. In Chapter 7, “Touring and Testing’s Primary Pain Points,” I describe what I see as the hardest problems in testing and how purposeful exploratory testing fits into the broader solutions. In Chapter 8, “The Future of Software Testing,” I look further ahead and talk about how technologies such as virtualization, visualization, and even video games will change the face of testing over the next few years. The appendixes include my take on having a successful testing career and assemble some of my more popular past writings (with new annotations added), some of which are no longer available in any other form.

I hope you enjoy reading this book as much as I enjoyed writing it.

© Copyright Pearson Education. All rights reserved.


Shop the new tech.book(store)
New! Introducing the tech.book(store), a hub for Software Developers and Architects, Networking Administrators, TPMs, and other technology professionals to find highly-rated and highly-relevant career resources. Shop books on programming and big data, or read this week's blog posts by authors and thought-leaders in the tech industry. > Shop now

Product Details

  • 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.6 x 9.1 inches
  • Shipping Weight: 1 pounds (View shipping rates and policies)
  • Average Customer Review: 3.6 out of 5 stars  See all reviews (10 customer reviews)
  • Amazon Best Sellers Rank: #430,925 in Books (See Top 100 in Books)

More About the Author

Discover books, learn about writers, read author blogs, and more.

Customer Reviews

Most Helpful Customer Reviews

45 of 54 people found the following review helpful By Joseph S. Strazzere on October 11, 2009
Format: Paperback Verified Purchase
A few years back, I read "How to Break Software" by James Whittaker. I liked it. It wasn't wonderful, but it had a good batch of practical, useful tips. Then I read "How to Break Software Security" and "How to Break Web Software". I liked them as well, but not as much. Still, I figured I'd read James Whittaker's newest book "Exploratory Software Testing". Sadly, the downward progression of his writing continues. This book is by far the worst of the bunch.

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.
Read more ›
13 Comments Was this review helpful to you? Yes No Sending feedback...
Thank you for your feedback. If this review is inappropriate, please let us know.
Sorry, we failed to record your vote. Please try again
6 of 6 people found the following review helpful By Chris Kenst on February 2, 2012
Format: Paperback
Some of the first testing books I read were James Whittaker's How to Break Software series. Those books, like this one, are laid out in a practical manner with each chapter focused on a specific attack or approach making them easy to read, reference and apply. Perfect for learning. I picked up this book a few years ago when I started questioning the way I was testing. The material was new to me and made me ask what is exploratory testing and what does touring have to do with it?

According to Whittaker (pg. 16) exploratory testing (E.T.) is testing where scripts or rigidity have been removed (paraphrasing). Whittaker explains his terms "E.T. in the small", decisions made where the scope of the testing is small and "E.T. in the large", decisions made when the scope of testing is large (small might be a screen in an application while large is the whole application). At the end of chapter 3 he mentions E.T. can be done in a way that allows test planning and execution to be completed simultaneously which is one of E.T.s most important aspects and simplest definitions. Touring (as in a tour guide or sight-seeing) becomes a metaphor for and a way to structure E.T.

There are eight chapters in the book plus a number of appendices. In the first few chapters Whittaker discusses what he sees as the case for software quality (the context of the book), introduces E.T. and explains how he uses it, in the small and the large. The next four chapters cover tours he and others have come up with. The last chapter is about how Whittaker sees the future of testing or at least how he did at the time of publishing.

The first appendix, A, is one of the most important parts of the book: building a successful career in software testing.
Read more ›
Comment Was this review helpful to you? Yes No Sending feedback...
Thank you for your feedback. If this review is inappropriate, please let us know.
Sorry, we failed to record your vote. Please try again
1 of 1 people found the following review helpful By Todd Bradley on October 20, 2012
Format: Paperback Verified Purchase
I've read about 70% of the book and I think its usefulness is winding down for me. I disagree with the reviewer that said everything here is for entry level QA staff. I've been doing software engineering (development and test engineering) for about 24 years now (about 7 years of that as an agile tester) and a lot of this book is new to me. The real value here for me is the material on the tourist metaphor of testing, or what Whittaker and others call "touring tests" (pun intended). These are essentially "styles" of tests that any experienced test engineer has used in the past. But what's new is the focus on testing a product through these tours.

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!
Read more ›
Comment Was this review helpful to you? Yes No Sending feedback...
Thank you for your feedback. If this review is inappropriate, please let us know.
Sorry, we failed to record your vote. Please try again

Most Recent Customer Reviews

Set up an Amazon Giveaway

Amazon Giveaway allows you to run promotional giveaways in order to create buzz, reward your audience, and attract new followers and customers. Learn more
Exploratory Software Testing: Tips, Tricks, Tours, and Techniques to Guide Test Design
This item: Exploratory Software Testing: Tips, Tricks, Tours, and Techniques to Guide Test Design
Price: $35.58
Ships from and sold by Amazon.com