by: Jim Azar, Sr. Vice President
The sheer pressure of time and release cycles makes it challenging for most software development teams to ensure software is tested and corrected for any deficiencies or flaws. That is why quality assurance is an essential tenet of software development.
This process is where people work to ensure that all software engineering processes, methods, activities, and work items align with some benchmarks and well-laid out standards. Whether it is ISO 9000, CMMI model, ISO15504, or a specific user requirement – this process takes care that software is assessed well in all core areas.
- It covers all software development processes, the definition of requirements, coding, and essential elements right up to the release stage.
- It has been done through various approaches so far, like Software Quality Assurance Plan, Software Requirement Specification (SRS), Test Maturity Model Integration (TMMi), etc.
- It employs a host of techniques and tools like multi-testing, process adherence, SQA audits, code inspection, design inspection, Black Box testing, White Box testing, Path testing, stress testing, impact measurement, reviews, audits, security management, risk management, etc.
Now imagine what happens if we add the word agile to these areas! Would we not change the very approach to software quality and testing?
Agile quality – flip the model
Bring in Agile and, instead of a reactive or standby flavor, now software quality process can take a very proactive stance. Agile quality puts the expectations and focuses on quality assurance into the project as early as possible. This allows the team to foresee issues in advance, and engineer with a point of strength, write and execute test cases, and flag and correct any gaps in requirements.
The project gets sliced into iterative stages and is injected with rapid and continuous feedback. The whole paradigm gets changed drastically. The aim is not to find defects at the end of a step or a waterfall, but to watch out for them all the time – in a truly agile way.
Here is what changes when an Agile Quality Management Model takes center stage.
- Better responsiveness to changes instead of reactive quick-fixes
- Comprehensive documentation
- In-depth automation of critical functionalities and test suites
- An inclusive and cross-functional approach
- Ability to incorporate non-functional requirements
- Collaborative environments
- Closer integration of testing and development
- Feedback loops inside sprints
- No ad hoc decisions
- A customer-centric software development approach
- QA involvement at every stage of development
- Ability to easily balance both White and Black boxes of testing
An Agile Quality Management Model adds the desired flexibility and speed to the assurance parts and elevates quality at every level. As Quality Management deepens its roots in an Agile delivery world, we will see robust software from the inside, from the very onset to the core, and it’ll be strong enough to handle the unexpected setbacks that tend to attack it later on.
But companies will need to embrace the real DNA of agile models before slapping on superficial changes. Both testers and developers might need to have interchangeable roles. They would need to ensure a new level of transparency and control over user requirements. The scenario gets more exploratory and experimental here, with shorter goals and smaller targets, that fit in an overarching way when everything comes together.
The same approach of thinking about software, its testing, quality, and life cycle would undergo a massive change in an Agile methodology. This also leads to ramifications into the cultural, human, teamwork, psychological, and behavioral aspects surrounding software creation, delivery, and assurance. As great as Agile sounds, it’s not that easy to switch from a traditional mindset to an entirely new paradigm of response time, checks, and collaboration at every point.
It would be a big change in terms of resources and culture, but it will deliver more significant and longer-lasting results. After all, we ultimately need robust, reliable, and well-validated software. Not the one that somehow escaped, right?