“A stitch in time saves Nine”, after reading below article you will get to know in what context I am using this proverb.
Most organizations develop software with a mindset that QA will be testing the product and detecting all bugs present in the system. Since our childhood, we have heard that “Prevention is better than cure”, so instead of finding the bugs, one should focus more on preventing them from getting injected into the system.
Not all defects in the software development are caused by coding errors. Some examples of defects coming upstream in the software development lifecycle (SDLC) are defects due to a misunderstanding of requirements, contradicting requirements, missing requirements, wrong analysis of requirements, and more importantly unable to identify non-functional requirements such as testability, scalability, maintainability, usability, performance etc.
Now here comes a Japanese method “Poka-Yoke”, which should be included in our arsenal.
It’s a QA process introduced by Japanese engineer Shigeo Shingo. This term is used in the Japanese language as “Poka” meaning mistake and “Yoke” meaning prevent i.e. mistake preventing technique. The purpose of Poka-Yoke is to develop processes to reduce defects by avoiding or correcting (for ex: design to show alerts or warning messages to the user) mistakes in early design and development phases. Poka-Yoke technique is mostly used in manufacturing industries but now this effective technique is also being adopted in our software development processes.
One example of Poka-Yoke design – SIM card slot in our mobile phones are designed in such a way that user is allowed to insert SIM card in a correct way only. There is no chance for the user to make a mistake while putting SIM card in a cell phone. This makes the design mistake proof.
The perfect example of Poka-Yoke process in software application – Outlook email attachments feature – when you type word ‘find attached’ while composing a new email and try to send it without attaching a file Microsoft will show you a popup reminder saying that you used words “find attached” in your email but did not attach any files, You may have forgotten to attach file.
Implementation of this technique:
Below are steps to implement this process and prevent software defects:
- List all use cases or end-to-end cases for the application.
- Analyse all these use cases by asking (3 whys?) questions to understand the ways these cases 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. Make sure the technique designed to avoid the defect is working properly by giving errors or a warning message for incorrect input or handling of the user scenario.
- Once the trial is passed add this technique to the list of Poka-Yoke processes to be performed each time on new releases.
- Measure the success of this Poka-Yoke process. Check if this technique has really prevented or caught defects when happening.
Classification of Poka-Yoke:
1. Defect Prevention:
It is an activity in any software project to identify the root causes of defects and improve the processes to avoid introduction of defects, which helps in improving the quality of the product.
In Defect prevention phase QAs are involved in analyzing and reviewing requirement specification document. While studying these documents QAs run into different queries or ambiguous requirements. QAs & other team members need to come up with such type of queries and get these resolved from stakeholders. So based on queries raised by a team, stakeholder provide inputs & provide changed/updated requirement specification document.
Cost of fixing defects in defect prevention stage is significantly lower than the fixing in later stages.
2. Defect detection:
It is a most common task for QAs as they use various approaches and strategies for executing test cases effectively. Defects are detected by many other testing methods like the system, regression, performance testing, etc.
- Making mistakes is totally OK – just don’t repeat them under same circumstances. Some checks or processes should be in place to avoid making same mistakes again. The Poka-Yoke technique solves this problem.
- The team should have strong domain knowledge in order to implement Poka-Yoke well.