Extracted from:
Explore It!
Reduce Risk and Increase Confidence
with Exploratory Testing
This PDF file contains pages extracted from Explore It!, published by the Pragmatic
Bookshelf. For more information or to purchase a paperback or PDF copy, please
visit http://www.pragprog.com.
Note: This extract contains some colored text (particularly in code listing). This
is available only in online versions of the books. The printed versions are black
and white. Pagination might vary between the online and printer versions; the
content is otherwise identical.
Copyright 2013 The Pragmatic Programmers, LLC.
All rights reserved.
No part of this publication may be reproduced, stored in a retrieval system, or transmitted,
in any form, or by any means, electronic, mechanical, photocopying, recording, or otherwise,
without the prior consent of the publisher.
The Pragmatic Bookshelf
Dallas, Texas Raleigh, North Carolina
Explore It!
Reduce Risk and Increase Confidence
with Exploratory Testing
Elisabeth Hendrickson
The Pragmatic Bookshelf
Dallas, Texas Raleigh, North Carolina
Many of the designations used by manufacturers and sellers to distinguish their products
are claimed as trademarks. Where those designations appear in this book, and The Pragmatic
Programmers, LLC was aware of a trademark claim, the designations have been printed in
initial capital letters or in all capitals. The Pragmatic Starter Kit, The Pragmatic Programmer,
Pragmatic Programming, Pragmatic Bookshelf, PragProg and the linking g device are trade-
marks of The Pragmatic Programmers, LLC.
Every precaution was taken in the preparation of this book. However, the publisher assumes
no responsibility for errors or omissions, or for damages that may result from the use of
information (including program listings) contained herein.
Our Pragmatic courses, workshops, and other products can help you and your team create
better software and have more fun. For more information, as well as the latest Pragmatic
titles, please visit us at http://pragprog.com.
The team that produced this book includes:
Jackie Carter (editor)
Potomac Indexing, LLC (indexer)
Molly McBeath (copyeditor)
David J Kelly (typesetter)
Janet Furlow (producer)
Juliet Benda (rights)
Ellie Callahan (support)
Copyright 2013 The Pragmatic Programmers, LLC.
All rights reserved.
No part of this publication may be reproduced, stored in a retrieval system, or
transmitted, in any form, or by any means, electronic, mechanical, photocopying,
recording, or otherwise, without the prior consent of the publisher.
Printed in the United States of America.
ISBN-13: 978-1-937785-02-4
Encoded using the finest acid-free high-entropy binary digits.
Book version: P2.0September 2013
Real-world users are not, on the whole, an orderly lot. They do things willy-
nilly, not respecting the flow of actions that the designers intended them to
follow in any given software application.
When using a Web application, people have a distressing tendency to use the
Back and Forward buttons in the browser without regard for whether or not
a web application supports navigating through the browser history. They
dont always bother to log in before clicking on a bookmark for a page that
requires authentication. Given an Undo and Redo capability, users undo then
redo a series of edits any number of times. They copy and paste contents
from one program into another without regard for whether or not the programs
support compatible formats. They try to work around constraints that get in
the way, like entering a space in required fields if they dont want to enter
real data.
Worse, users sometimes allow their children or pets access to the computer,
resulting in even less-logical actions that involve mashing keys, deleting stuff
randomly, and turning off computers at just the wrong moment.
To discover potentially serious problems involving the use and abuse of your
software, you need to vary the way you interact with it. Instead of following
a sensible sequence of actions, take steps out of order. Instead of navigating
using the same mechanisms every time, vary the paths you take through
your system. Instead of using reasonable data, use unreasonable data.
In this chapter you will discover some ideas for shaking up sequences and
interactions.
6.1 Nouns and Verbs
Its likely that if you are accustomed to the software youre exploring, you
have fallen into some habits with respect to how you interact with it. Perhaps
you generally use the same data, like 123 Main Street for an address. Per-
haps you have habits around navigating GUIs, like using hotkeys instead of
the menu. Or perhaps you tend to run through the same sets of sequences
without varying them, like logging in, setting up the data, and then searching
on the data you just set up.
Habits are hard to break for two reasons: you might not even be aware that
you are acting out of habit, and even if you are aware of your habits, theyre
comfortable. However, to explore effectively you have to go where you havent
gone before. One way to break out of your habitual rut is to allow randomness
to guide you. The Nouns and Verbs technique provides a way to introduce
randomness into how you interact with your software.
Click HERE to purchase this book now. discuss
6
The first step in the technique is to identify the nouns and verbs of the system.
Imagine youre working on an email client. The nouns, or things, in your
system might include emails, attachments, contacts, accounts, and folders.
The corresponding verbs, or actions, might include create, send, edit, forward,
copy, delete, and move.
Although email clients are user-facing applications with a graphical interface,
this technique applies to absolutely any kind of software. If you were working
on embedded robotics software, the nouns of the system might involve sensors,
motors, parts, and targets, while the verbs might involve sensing, moving,
turning, and manipulating. All systems have nouns and verbs. Email is a
convenient example because just about everyone is at least a little familiar
with the domain, but this technique is good for far more than user-facing
GUIs.
To vary the way you interact with a system, you can generate random scenar-
ios by choosing nouns and verbs at random and then using that random
selection to guide your actions as you use the system. You start by making
a list of nouns and a list of verbs from which to pull. For the email example,
your lists might be like those in Table 1, Example nouns and verbs for an
email client, on page 7.
These two lists represent just a small subset of the possible nouns and verbs
you might identify. If you were to spend time brainstorming, you could cer-
tainly generate much longer lists. However, even these short lists offer enough
fodder to prompt a vast number of possible scenarios.
If you randomly selected an item from each of these two lists and put them
together, you would have a hundred possible unique combinations of actions
and targets for those actions. (You could use something as simple as dice,
cards, or a spinner to do the random selection.) If you then randomly chose
ten noun/verb combinations, you would have a googol (10100) possible se-
quences. With so many possibilities, your generated list of steps is almost
guaranteed to ensure that you will take actions in a very different order than
you otherwise would.
Some of the noun and verb combinations would be completely sensible, like
Delete Contact. Other combinations might be nonsense, like Archive
Header. Such nonsensical combinations might seem unusable, but theyre
even better for inspiring variations in usage than the combinations that make
sense. When you come up with a combination that does not make sense, you
have to invoke your creativity. What could archiving a header mean? Perhaps
it means archiving an empty email that is nothing but headers. Perhaps it
Click HERE to purchase this book now. discuss
Nouns and Verbs 7
Nouns Verbs
Message Send
Header Receive
Draft Edit
Attachment Save
Signature Export
Folder Move
Recipient Archive
Appointment Reply
Note Forward
Contact Delete
Table 1Example nouns and verbs for an email client
means copying the contents of an email header into some other document to
save it. Perhaps there is some action, like exporting, that the email client
allows you to take on a header. Searching around for an interpretation for
the nonsensical combinations can put you on a path to unexplored territory
in your software.
Just like nonsensical noun/verb pairings, illogical sequences push you into
creative interpretations. If you randomly drew Send Message immediately
followed by Add Recipient, you might wonder how to add a recipient given
that the message has already been sent. Perhaps you would send a message
and then fish the message out of your Sent folder and forward it to an addi-
tional recipient.
By randomly selecting noun/verb combinations in sequences, youll find
yourself tromping through new territory in your software in no time. As you
work your way through your randomly generated scenario, remember to watch
carefully for hints of unexpected behavior, and be particularly alert for any
violation of the Alwayses and Nevers for your system.
Click HERE to purchase this book now. discuss
