Quality Trail

In today’s progressive landscape of software development, there’s a burgeoning enthusiasm around Quality Assurance (QA), Quality Engineering (QE), and test automation. Automating your current QA processes is unquestionably a commendable advancement and a crucial foundation. It streamlines and enhances what’s already in place, marking the start of a transformative journey towards quality. However, for organizations aiming to scale greater heights in software excellence, there’s an expansive horizon beyond just automation. Making the switch from automated QA to true QE involves more than just speeding up current procedures; it also represents an invitation to a more profound, all-encompassing evolution in how we view and integrate quality throughout the software lifecycle.

The Fundamental Differences

Traditional QA: This often acts as a checkpoint in the Software Development Life Cycle (SDLC). Once development is complete, the product is put through testing to find and fix any issues. While automation can improve the speed and accuracy of this stage, the underlying principle has not changed much from the conventionally reactive approach.

Quality engineering is a comprehensive approach that incorporates quality into every stage of the software development life cycle. In this setting, quality is “baked in” from the beginning of a project rather than being merely an added layer. It’s not about finding defects after they arise but embedding processes and practices that proactively prevent them, ensuring that every step, every decision, and every line of code inherently exudes quality.

Shifting Left: The Broad Spectrum

Proactivity is key to the “shift left” method. Shifting left emphasizes integrating quality checks considerably sooner in the SDLC process as opposed to waiting until the later phases to focus on quality. Quality is thus completely integrated into the development process, allowing for early detection and correction of possible faults.

By doing so, the development team adopts a mindset where quality is not just a checkpoint but a consistent guiding principle. Every design choice, every line of code, and every functionality introduced is viewed through the lens of quality from the very beginning.

Several “shift left” strategies have emerged as a result of applying this principle to different areas of software development. As one example, we can look to the field of performance engineering.

Performance Engineering vs. Performance Testing: Instead of relegating performance considerations to the tail-end, as done in traditional performance testing, performance engineering integrates them from the get-go. It guarantees that the program is designed from the ground up with peak performance in mind by proactively examining the potential consequences of architectural decisions and design patterns.

Catching Design Defects Early (aka Larvae Hunting!): In nature, those seemingly harmless little larvae might be overlooked. In a period of time though, they can develop into fully grown, destructive bugs. Similarly, in software development, small mistakes in the first phases may grow into major issues later on if nobody notices them. Why not become skilled larval hunters instead of bug exterminators? With a focus on early detection in QE, that’s exactly our role. We get involved in the preliminary stages of development to prevent the emergence of flying bugs. It’s a proactive strategy that improves productivity and injects excitement into the quality assurance procedure.

Design Testing and Prototype Testing: The areas of design testing and prototype testing stand out as crucial tools in the ‘larvae hunting’ toolkit. The primary goal of design testing is to verify that the preliminary design ideas satisfy the needs and expectations of the target audience. Verifying that everything is in order before writing a single line of code is essential. Prototype testing, on the other hand, entails making a basic but functional model of the software or the new feature. This prototype is then put through its paces, identifying potential usability, functionality, or integration issues. By subjecting early designs and prototypes to rigorous testing, we not only ensure that our foundation is robust but also that subsequent development phases are smoother, more predictable, and significantly more efficient. It’s similar to making sure the building’s blueprint is perfect before placing the first brick; this is an essential step in creating a masterpiece.

In Practice: The Nitty-Gritty of Early Stage Testing: When we talk about testing designs and prototypes, what does this look like in tangible terms? For instance, when designing a software interface, even before full functionality is developed, basic interfaces or empty classes and functions can be set up. As the exterior structure is being built, these crude structures offer a scaffold that can be tested right away. From a service-oriented perspective, consider an API-driven architecture: each web service can initially be introduced as a static mock, paving the way for early integration tests. As the development advances, these mocks then transform, gradually evolving into their fully-realized capabilities. This methodical procedure guarantees that the software is ready for testing at all times, allowing for continuous improvement and conformity to quality requirements.

In-Sprint Test Automation & The Advanced TDD Approach:

When we bring design and prototype testing into the mix, especially as discussed with our API example, a beautiful synchronization emerges between test automation and software development. The ideal scenario is for both processes to advance simultaneously throughout the same sprint. An our above example, as a static mock of an API evolves into a functional endpoint, its corresponding automated tests are being developed side-by-side, and evolving from prototype testing to actual component tests. This ensures that as a feature begins to arrive, its safety nets in the form of tests are already being woven (we’re talking about bugs right?! The net needs to be tight enough to keep the bugs and their larvae inside.

It’s not just about unit testing either. This approach allows for the simultaneous development of regression tests and even non-functional tests, painting a comprehensive picture of quality at every stage. This kind of coordination not only boosts productivity, but also drastically lowers the costs of production delays, helping us move closer to the utopian ideal of “bug-free software development” outlined in prior posts of this blog.

This concept isn’t new. It was developed in the aerospace industry, where the risk of human death makes a zero-bug tolerance absolutely essential. We are committed to producing software that is not only functional but also exceptional in its dependability and robustness, and we believe that adopting a similarly rigorous approach in software development is a key part of achieving this goal.

Lastly, In the dynamic world of software development, moving beyond mere automation to embrace Quality Engineering (QE) is imperative. It’s about integrating quality right from design to deployment, taking cues from precision-driven industries like aviation. As we work to create flawless software, it’s important to keep in mind that quality isn’t a destination, but rather the course we take to get there. Silkland Consulting Inc provides experienced guidance along this road for teams that are ready to take the plunge.