by Rachelle McLure –
How are you doing quality assurance software testing at your organization?
Odds are, you’re doing it wrong. No offense intended, of course. But many organizations are stuck in the rut of taking an old-fashioned, outdated approach to testing.
Many organizations deploy QA as sort of an afterthought adjunct to the software development process. They gather requirements, design, code and compile – and then test.
That approach to QA is certainly better than no testing at all. But not by much.
Blame Your Teachers
For most of us, performing testing as a finale at the end of the development process seems perfectly logical. After all, we’ve been trained to think that way for most of our lives.
Think back to your days in school.
How did that process work? You sat in class and listened to the teacher lecture. Then you did homework. Then you studied outside of class (well, maybe). And then at the end of it all, you proved (or disproved) your mastery of the material by taking a test.
You probably went through that process for 15 or 20 years, or longer.
So it’s no surprise that it seems normal for most of us to think of testing as the end-point of a linear process – the period to the sentence.
But it’s time to think differently about testing.
Shift, Don’t Drift
Instead of drifting along with the still-prevailing view of testing as an afterthought, why not take a more modern and proactive approach to QA?
At RCG Global Services, we advocate a shift-left, test-driven approach to software development. Instead of tacking testing onto the end of a linear process, we believe that QA should be integrated into all phases of the software development lifecycle. Testing, in fact, should drive the development process.
In a simplistic sense, test-driven development involves:
- Writing the requirement
- Writing the test
- Writing the code
Infusing testing throughout the development process pays some very real dividends.
The earlier in the process that defects are identified and addressed, the more dramatic the cost savings. Finding and fixing a defect in the analysis stage, for example, costs an estimated $200 (on average). Finding and fixing that same defect once the code goes into production? That’s a little more costly: $15,000! (Not to mention the intangible, brand-damaging costs of bugs that make it into production.)
But though finding defects early is of great importance, the biggest payoff of the shift-left philosophy might be the prevention of defects.
Dr. Boris Beizer, the renowned software testing pioneer, said, “More than the act of testing, the act of designing tests is one of the best bug preventers known. The thinking that must be done to create a useful test can discover and eliminate bugs before they are coded – indeed, test-design thinking can discover and eliminate bugs at every stage in the creation of software, from conception to specification, to design, coding and the rest.”
Implementing a Shift-Left Approach
So how can you implement a shift-left approach to testing at your organization? We advise our clients to adopt a three-part, holistic model consisting of:
- Governance
- Planning
- Execution
Think of governance as the equivalent of a program management office, but specifically for software testing. Governance sets the tone for how you’ll implement QA across your enterprise. And we’re really looking at strategy. We’re looking at standards and tools, ways that we can shorten our time to market, ways that we can infuse quality within the overall approach to what we’re doing.
Planning involves estimating and resourcing demand and capacity management, and all of the pieces that go with that. Planning asks and answers questions such as:
- What are the objectives of our testing?
- How do we best accomplish those objectives?
- How much test coverage do we need?
The third phase, execution, is where we implement the plan. A variety of tools and techniques may be utilized in executing the plan. Execution encompasses all the routine chores such as:
- Writing the tests
- Executing the tests
- Reporting on the tests
- Performing root cause analysis
At the end of the day, it’s these three pieces — governance, planning, execution — that work in harmony to achieve the level of success that you want from your quality assurance and software testing.
Just-In-Time is Just Too Late
Delaying testing until the end of the software development cycle is a great way to create delays and miss project deadlines. It’s a great way to find defects that could have been avoided altogether. It’s a great way to generate crushing levels of stress.
But though it may still be the prevailing industry standard, it’s not a great way to do business.
That’s why we advocate a shift-left, holistic approach to software testing for RCG Global Services’ clients. It’s an approach that has helped win our company honors and recognition as a software-testing provider. But most importantly, it’s an approach that has served our clients well (including 25 of the Fortune 100).
Additionally, as our industry continues to embrace agile development and explore DevOps for development and sustainment, we have applied this holistic approach to QA & Testing and established a model for Ubiquitous Quality™ management.
So if you’re still approaching software development the same way you went through the first grade — tacking testing onto the end — you might consider trying something new. After all, the old ways aren’t always the best ways.
To Learn More:
Check out our other blogs on QA & Testing:
- Future-Proof Software Testing for Agile, DevOps and Beyond
- QA & Testing is About Much More than Just Testing Code
- QA & Testing Survival Guide
- Validated Testing for PDMA, FDA Compliance
- Use Test Points to Eliminate Guesswork in Determining Test Coverage
#IdeasRealized
