Restoring Application Agility: building applications that get more agile over time

Adapting to customer demands, rapidly releasing new features to get feedback, and low defects are all things that we strive for. To do that, we spend time getting to know the customer, refining the backlog so that requirements are well understood, and ensuring we don’t overload the team. The goal is to empower the development teams to solve problems creatively and with speed. But how can we expect teams to work courageously if they are afraid to change the code?

Most teams we encounter are working on legacy software that is anything but soft. Over time, the complexity of the applications increases to the point where the majority of a developer’s time is spent trying to figure out what might break with any given change, building workarounds, and fixing bugs. The business needs developers to move boldly and with speed, but the reality is the brittle systems they work on cause them to move slowly and carefully.

What if, instead of getting larger and more brittle over time, making changes more risky, the software could get more modular and simpler, increasing the safety of the developers working on the code? The key to soft software is focusing on creating that safety first. And the key to that is going from the traditional approach of testing last to testing first.

In this talk, we will discuss how the traditional approach to building software drives up complexity, slowing developers down over time, and how testing first drives down complexity and enables developers to work faster and with higher quality as time goes on. Then, we will discuss the approach to breaking down monolithic legacy systems to make them more modular and simpler while making the move to testing first, without rewriting everything or completely starting over. Finally, we will walk through a real-life case study of how these techniques were applied to a real e-commerce application and the results that were achieved.

Understand how the approach to building software affects the complexity of the software over time.

Discover how complexity affects the development team’s ability to deliver by decreasing their safety.

How to keep code soft and development teams moving fast.

Review the process for modularizing and simplifying complex legacy applications without a massive rewrite or starting over.

Learn how to maintain and improve the simplicity of the code base over time.