Poetry Madness
 
 

Recently Viewed clear list


Original Essays | April 11, 2014

Paul Laudiero: IMG Shit Rough Draft



I was sitting in a British and Irish romantic drama class my last semester in college when the idea for Shit Rough Drafts hit me. I was working... Continue »
  1. $9.07 Sale Trade Paper add to wish list

spacer
Qualifying orders ship free.
$50.75
New Trade Paper
Ships in 1 to 3 days
Add to Wishlist
available for shipping or prepaid pickup only
Available for In-store Pickup
in 7 to 12 days
Qty Store Section
1 Remote Warehouse Software Engineering- General

Exploratory Software Testing: Tips, Tricks, Tours, and Techniques to Guide Test Design

by

Exploratory Software Testing: Tips, Tricks, Tours, and Techniques to Guide Test Design Cover

 

 

Excerpt

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 humankinds most amazing accomplishments.

But amazing isnt 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 werent they found in code reviews, unit testing, static analysis, or other developer-oriented activity? Why didnt 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 intellectuals 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 Testings 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

ISBN:
9780321636416
Author:
Whittaker, James A.
Publisher:
Addison-Wesley Professional
Subject:
Software Development & Engineering - General
Subject:
Computer software -- Testing.
Subject:
Programming - General
Subject:
Programming - Software Development
Subject:
Software Engineering-General
Copyright:
Edition Description:
Trade paper
Publication Date:
August 2009
Binding:
TRADE PAPER
Grade Level:
Professional and scholarly
Language:
English
Illustrations:
Y
Pages:
256
Dimensions:
9.1 x 7 x 0.525 in 415 gr

Related Subjects

Arts and Entertainment » Photography » Annuals
Computers and Internet » Software Engineering » General
Computers and Internet » Software Engineering » Programming and Languages
Computers and Internet » Software Engineering » Quality Assurance and Testing
Travel » General

Exploratory Software Testing: Tips, Tricks, Tours, and Techniques to Guide Test Design New Trade Paper
0 stars - 0 reviews
$50.75 In Stock
Product details 256 pages Addison-Wesley Professional - English 9780321636416 Reviews:
"Synopsis" by , In Exploratory Software Testing, leading software testing expert James A. Whittaker reveals the real causes of today's most serious, well-hidden software bugs - and introduces powerful new exploratory techniques for uncovering them. Drawing on nearly two decades of experience working at the cutting edge of testing with Google, Microsoft, IBM, and Florida Tech, Whittaker introduces powerful new processes for manual testing that are repeatable, prescriptive, teachable, and effective. Whittaker identifies various types of exploratory testing, then shows when to use each, how to use them all successfully, and how to integrate them with existing automated testing methods. Concise, entertaining, and actionable, this book guides software professionals on the tactical and strategic decisions that can make or break their testing processes. Whittaker shows how to make manual testing more effective and less boring; offers specific guidance on choosing test cases; and shows how to reflect feedback from the development process. Above all, Exploratory Software Testing shows how to uncover the hidden show-stopper bugs that so often evade conventional testing.
spacer
spacer
  • back to top
Follow us on...




Powell's City of Books is an independent bookstore in Portland, Oregon, that fills a whole city block with more than a million new, used, and out of print books. Shop those shelves — plus literally millions more books, DVDs, and gifts — here at Powells.com.