Poka-Yoke in Software Testing- A Mistake Proofing Method!!!

POKA-YOKE is a quality assurance process introduced by Japanese engineer Shigeo Shingo.

This term is used in Japanese language as

“Poka” meaning mistake and

“Yoke” meaning prevent i.e. mistake preventing or mistake proofing technique.

The purpose of Poka-Yoke is to develop processes to reduce defects by avoiding or correcting (design to show

alerts or warning messages to user) mistakes in early design and development phases.

This technique is mostly used in manufacturing industries but now this effective technique is also adapted in

software development processes as well.

INTRODUCTION

There are two types of POKA-YOKES:

Prevention POKA-YOKE

Detection POKA-YOKE

A Control/Prevention Poka Yoke is one where the process is designed in such a manner that one cannot make a

mistake.

A Warning/Detection Poka Yoke is one where the moment someone makes a mistake, the person is quickly

notified of the mistake, so that corrective action can be taken.

DEFECT DETECTION

Defect detection is most common task for quality assurance teams.

QA teams use various approaches and strategies for executing test cases effectively.

Defects are detected by many other testing methods like smoke and exploratory testing.

DEFECT PREVENTION

Defect prevention is most important activity in SDLC.

This method is used to identify all possible issues and actions needed to eliminate those issues.

Many software defects can be prevented in design phase itself.

Quality assurance team can help to prevent these defects by reviewing the SRS.

All issues identified in this stage are addressed in software coding phase and prevented from carrying to

later stages.

Gmail attachment feature.

Undo send

Auto Save option in MS Office.

Password Strength Indicators.

Spelling Suggestions.

Double entry boxes in banking application.

Wrong bob/Missing bob checking in Gmail.

Inserting SIM into slot.

Inserting wires & cables into Slots.

A simple Poka-Yoke system implemented in sim, won’t

allow you to insert sim in any improper way!!!

Examples of Typical POKA_YOKE Systems

In the above picture we can see the automatic indication

of PASSWORD Strength!!!

Google automatically corrects the mistake as shown above, which an end user is most likely to make!!!

Automatically, reminds the user that he has forgotten to add a “Subject” to

his message!!!

Robotically, reminds the user that he has forgotten to attach a document, which he mentioned

in the message!!!

How Poka Yoke Technique Works???...

Steps to Implement a Poka Yoke Process:

List all user scenarios or end-to-end test cases for the application.

Analyze all these user scenarios by asking 5-whys questions to understand the ways these scenarios can fail.

Once you identify the ways these user scenarios can be wrong, design and apply a Poka Yoke technique to avoid

the possible problems (e.g. this design could be a simple unit test to check if any function written is working

properly or not).

Make sure the technique designed to avoid the defect is working properly by giving errors or warning message for

incorrect input or handing of the user scenario.

Once the trial is passed add this technique in the list of Poka Yoke processes to be performed each time on new

release/build. (In above unit testing example, once the unit test is written to check the function code, check if it

is working for positive and negative values. When this test passes add it to ‘unit tests’ repository to be executed

each time any change is made in relevant modules)

Measure the success of this Poka-Yoke process. Check if this technique has really prevented or caught defects

when happening.

Poka-Yoke should be simple to create and maintain. It should be easy to handle and cost-effective. Maintaining a

complex Poka-Yoke is time consuming and often results in issues if not maintained properly.

Poka-Yoke should be designed early in SDLC so that it can detect issues quickly.

A good Poka-Yoke should be accurate enough to find the issues when they occur.

A good Poka-Yoke should be designed in such a way that it should stop most common issues occurring in the

software.

It should be part of software design and coding process.

QUALITIES OF A GOOD POKA-YOKE PROCESS?

Think simple. It is better to have several simple Poka-Yokes, each with a single purpose, than to have one large

complicated script.

Think specific. Look at your process; identify a mistake that occurs frequently, and design a Poka-yoke to prevent

or detect that particular mistake.

Think attributes. Rather than wait for the entire software application to become available, look for aspects of the

software that can be verified independently.

Think early. Try to detect and eliminate defects as early as possible so that they do not pollute processes

downstream.

Think responsive. Once a defect is detected, correct the mistake as soon as possible.

Think re-use. Successful Poka-yokes can be modified to serve new purposes.

RECOMMENDATIONS FOR CREATING GOOD SOFTWARE POKA-YOKES

Encourages individual accountability for excellence.

Without involving too much effort, the procedure performs 100% assessment.

Discovers and eradicates defects as early as possible in the process.

Presents immediate response, thus minimizing the time for remedial action.

Creates a process of consecutive verification for each procedure.

Presents self-check actions which provide quicker review than consecutive verification.

Makes sure that proper circumstances exist before the actual creation, and prevents defects from taking place.

Doesn’t just identify the causes of errors but eliminates the causes as well.

Elimination of defects ultimately increases customer satisfaction.

Gives an ultimate satisfaction in using the software.

ADVANTAGES OF GOOD SOFTWARE POKA-YOKE SYSTEMS

All that it needs is just a new way of thinking!!!!

If you can think in that way you can be there undoubtedly!!!.....

E = MT2

Exploring & Making Testing Trust worthy!!!