DEVOPSdigest

In 1975, computer scientist Fred Brooks observed that during software project management, adding more developers to a project that's already behind schedule just adds to delays. This became known as Brooks' law. However, it's not people power that causes delays — delaying testing increases the chance of bugs and suboptimal code quality. Therefore, one solution must be pushing testing forward. This blog offers advice on implementing a shift left approach, and the benefits of doing so.

According to the Standish Group's Annual CHAOS 2020 report, 66% of technology projects (based on the analysis of 50,000 projects globally) end in partial or total failure. However, this isn't surprising when we think about how businesses are still managing their projects.

Many project management approaches to software engineering involve phases — each lasting months — before carrying out mostly manual testing right at the end of the project. Often, this occurs over a year since the initial project began. Even then, teams will repeat testing in cycles over several more months until all defects are eventually mitigated or accepted.

The Challenges

This conventional approach to project management is deeply flawed and often results in projects being late, over budget and not delivering the expected value. Why? The answer's simple.

Testing at the end means organizations are waiting months (sometimes years) to see if the software acts as expected. This creates a vastly delayed feedback loop, which gives software engineers little time to improve and update the product. Even if testing shows that the software is working as expected, there's no real way of knowing if it delivers on the customer's needs. This means more waiting before the engineers can even know that what they built is of any value.

Fast forward, it is now years after the customer first inquired. Not only have their needs probably changed, but so will the needs of the wider market. This means organizations risk a) missing out to a competitor that has developed a similar product, and b) delivering a software product that is no longer of use.

There are also logistical matters to consider. By the time the software reaches testing, the original developers may have left — rendering changes and maintenance even more challenging. Meanwhile, manual testing is time consuming and prone to human error, meaning bugs might be missed or incorrectly reported, and even small changes could take weeks to complete.

Why Shift Left?

Shifting left means bringing testing toward the early stages and putting it at the heart of the development process. Unlike the sequential model, testing early and often can help reduce the number of critical bugs during the deployment phase that require code patching.

This approach is best achieved by employing Test Driven Development (TDD) with CI/CD practices, where developers first write automated tests for the feature they are working on before writing the software to make the test work. Once teams have software that behaves exactly as they've defined, there are no surprises. Not only does this improve software testability, but it also means that the developer has a fully automated regression test pack developed at the same time. Therefore, the software is always fully tested and production-ready, the need for longer months-long test cycles is gone.

When developing large and complex software-reliant systems, software teams should break development down into many daily increments. With each increment, the software is automatically deployed by a pipeline to the customer, made possible by shifting testing to the left.

Getting Started

Implementing shift left testing means a huge culture change — businesses must encourage developers to take individual responsibility for their products and test what they build, meaning testing is no longer part of a separate team or role.

The biggest challenge in this process is management, because giving more time to developers to write tests is critical. Initially, it may seem that less work is being done and development is taking longer, but a holistic thinking is needed, requiring businesses to look at the software as a whole across development, operations, testing, support and so on. For instance, the test phase itself will be eliminated, meaning there is a chunk of newly created time available. Meanwhile, tests are automated and can be run repeatedly, giving even more time back. Ultimately, the result will be a software product of much higher quality than previously, so there are fewer issues and bugs to resolve, and clients will be happier with the results.

Shifting testing leftwards is an important step in mapping out a software development project. It ensures regular, early assessments that reduce the risk of critical bugs later, preventing damaging delays. Working with an experienced DevOps consultancy can help businesses implement an automated, effective testing regime, and keep their projects on track.