Once upon a time, there was Quality Control. The legacy of the manufacturing past in the production line. Random sampling was used to find out whether something produced did not meet the quality requirements. But in modern creative work like software development, this was too little too late. So this concept just doesn't work. So, moving on.
The second is Quality Assurance. A concept used by software development professionals today. QA for short is the ability to identify what needs to be tested and then run those tests before release of product, especially software projects. Newer approaches like unit testing have evolved where QA encompasses unit tests before it goes for functional and non-functional testing. But this has also reached a point where it is too little, too late. Especially in the 2020's. I would argue that today's software Quality assurance has become like yesterday's Quality control, a control function before releasing. This is the bane of long-cycle project management that does not usually consider QA to be a continuous activity and utilizes QA in phases. Large batches of software being tested in batches is no different from sampling in QC. And existing QA practices do not scale for today's modern software development practices.
Take unit-testing as a QA approach as an example. Often, unit tests are written after writing the code. And in this scenario, the developer who writes these tests instantiates the same errors in one's understanding that has been reflected in the code once more into the tests as well. It is a zero-sum game.
So what's the answer? Build quality in!
Built-in quality. Quality that does not be assured like QA is, but quality that is built-in using the practices that instantiates it before a code or test is written. Let's look at some of techniques and tactics:
- Involve developers, testers and stakeholders in deep conversations of scenarios - increases their understanding of what is being developed and/or tested.
- Document scenarios before writing code, triparty discussions between developers, testers and analysts/stakeholders to validate understanding.
- Whiteboard design, before coding, so improves design and code before writing it.
- Write automated functional and non-functional tests first before coding, so that developers have ability to test before they write code. Pair programming for all testing and QA work.
- Pair programming - continuous conversation while writing tests and code, improving test and code quality. Expand with techniques like Mob Programming for more complex development.
- Automated build scripts before coding and testing - to provide quick, reliable and repeatable way to test software before it is being produced.
- Continuous integration / continuous delivery / continuous deployment practices to test in small increments in every stage of the software life cycle.
- Product management practices like A/B testing to validate with users on usability and fit for purpose before deploying large scale.
- Community of practices - to spread knowledge both domain and technical across teams of teams
- Constantly improve proactive quality practices using retrospectives and constant learning, so quality is fixed at the first source of origin of a piece of code or test.
In summary, QC is dead. QA is old-school and yesterday. Build Quality-in!