29-09-2016, 04:22 PM
1456904453-HowPokaYokeTechniqueWorks.docx (Size: 197.62 KB / Downloads: 4)
How Poka Yoke Technique Works?
Steps to Implement a Poka Yoke Process:
Below are few steps to design and implement a process to prevent software defects:
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.
Categories of Poka-Yoke
Defect Prevention
Defect Detection
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
software requirement specification documents. All issues identified in this stage are addressed in
software coding phase and prevented from carrying to later stages. The manufacturing and software
industry examples provided above are the good examples of defect prevention technique.
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.
What are the Qualities of a Good Poka-Yoke Process?
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.
Need of Poka-Yoke in Software Design Phase
To develop quality software, it is important to design it according to user’s expectations. User should
be able to use/handle the software with ease without making any costly mistake.
Poka-Yoke examples in design and quality
1) The example of missing attachment file while composing email using Gmail.
2) Some websites show password strength indicator to show password strength. It also guides users
to use strong password with combinations of characters and numbers.
3) Google search engine feature to auto-suggest spelling corrections for user search query. This
helps uses to avoid making inadvertent mistakes.
4) Banking websites use double text field feature to accept sensitive information like passwords or
account numbers. The second text field is usually encrypted to avoid making any mistake while
providing the input value and to check if both the text field values match.
Need of Poka-Yoke in Software Development
From countless industry examples it’s now well known that cost of fixing a defect after product
release is many times greater than fixing it in development cycle. Best solution to avoid post-release
issues is introducing the Poka-Yoke techniques which could catch defects in early development
phases making it cheaper to fix. Poka-Yoke process implementation largely depends on tester’s
ability to capture and eliminate the issues.
Poka-Yoke examples in Software Development
Unit testing is one of the most effective means of mistake proofing software development.
Having validation Poka-Yoke in kit is always a good suggestion for developers. Validation
mistakes should be handled in your code. These validation issues should be revisited and updated
periodically.
A common and most effective Poka-Yoke is to hire right candidates to mistake proof your
software.
Conclusion:
Making mistakes is OK; just don’t make the same mistake again and again. And to avoid making
same mistakes again there should be some checks or processes in place. The Poka-Yoke techniques
are developed to solve this problem.
Article References:
Shigeo Shingo, Zero Quality Control
Wikipedia reference
Boris Beizer, Software Testing Techniques, 2nd ed. Van Nostrand Reinhold