Exploratory Software Testing: Tips, Tricks, Tours, and Techniques to Guide Test Design 1st Edition, Kindle Edition

3.9 out of 5 stars 18 ratings
Flip to back Flip to front
Audible Sample Playing... Paused   You are listening to a sample of the Audible narration for this Kindle book.
Learn more
ISBN-13: 978-0321636416
ISBN-10: 0321636414
Why is ISBN important?
ISBN
This bar-code number lets you verify that you're getting exactly the right version or edition of a book. The 13-digit and 10-digit formats both work.
Scan an ISBN with your phone
Use the Amazon App to scan ISBNs and compare prices.
Kindle App Ad
Buy
$19.79
Digital List Price: $35.99 Save $16.20 (45%)‎

Deliver to your Kindle or other device


Buy for others

Give as a gift or purchase for a team or group.Learn more

Buying and sending eBooks to others


Select quantity
Buy and send eBooks
Recipients can read on any device

Additional gift options are available when buying one eBook at a time.  Learn more


These ebooks can only be redeemed by recipients in the US. Redemption links and eBooks cannot be resold.

Quantity: 
This item has a maximum order quantity limit.
See all 4 formats and editions Hide other formats and editions
Price
New from Used from
Kindle
$19.79

Limited-time deal : Top Cookbooks pantry

click to open popover

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.

  • Apple
    Apple
  • Android
    Android
  • Windows Phone
    Windows Phone
  • Click here to download from Amazon appstore
    Android

To get the free app, enter your mobile phone number.

kcpAppSendButton
Amazon Business : For business-only pricing, quantity discounts and FREE Shipping. Register a free business account

Editorial Reviews

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?

Excerpt. © Reprinted by permission. All rights reserved.

Exploratory Software Testing

Exploratory Software Testing

Preface

“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.


Product details

Customer reviews

3.9 out of 5 stars
3.9 out of 5
18 customer ratings
How does Amazon calculate star ratings?
Reviewed in the United States on October 20, 2012
Verified Purchase
6 people found this helpful
Comment Report abuse
Reviewed in the United States on January 28, 2014
Verified Purchase
2 people found this helpful
Comment Report abuse
Reviewed in the United States on September 11, 2012
Verified Purchase
Reviewed in the United States on December 31, 2012
Verified Purchase
Reviewed in the United States on May 23, 2013
Verified Purchase
Reviewed in the United States on October 11, 2009
Verified Purchase
53 people found this helpful
Comment Report abuse
Reviewed in the United States on August 27, 2015
Verified Purchase

Top international reviews

Paul Vear
4.0 out of 5 stars Interesting.
Reviewed in the United Kingdom on October 6, 2014
Verified Purchase
Sending feedback...
Thank you for your feedback.
Report abuse
WILLIAM
4.0 out of 5 stars Newbies start here
Reviewed in the United Kingdom on August 15, 2011
Verified Purchase
Sending feedback...
Thank you for your feedback.
Report abuse
John New
5.0 out of 5 stars A short but seminal work
Reviewed in the United Kingdom on February 3, 2012
Verified Purchase
Sending feedback...
Thank you for your feedback.
Report abuse
Sheli
5.0 out of 5 stars I love. Delivered late though
Reviewed in Canada on January 9, 2017
Verified Purchase
Sending feedback...
Thank you for your feedback.
Report abuse
Lulz
5.0 out of 5 stars Five Stars
Reviewed in the United Kingdom on August 11, 2014
Verified Purchase
Sending feedback...
Thank you for your feedback.
Report abuse