Why bother minimizing feedback cycles across the software development and delivery lifecycle? One reason is the positive effects it has on engineering behaviors—and this is particularly true when it comes to software building and testing, in ways that might not be immediately apparent.
Specifically, fast feedback cycles encourage positive developer behaviors that may result in (1) increased productivity at the individual level, (2) increased team efficiency, and (3) better quality software. As you can see from the diagram below, the relationship between the effects of faster feedback cycles on behavior and the benefits of those behavioral changes is complex:
Let’s take a look at each of these benefits in a bit more detail.
1. Increased Developer Productivity
Shortening the amount of time developers have to spend waiting for builds to complete can be a boon to the creative process. When builds complete quickly, developers are less tempted to pay the context-switching cost of starting and stopping other tasks and activities.
Thus, fast feedback cycles keep developers more focused on coding and less susceptible to unproductive distractions.
2. Increased Team Efficiency
When builds and tests complete quickly, developers are more inclined to run them more often, and are less tempted to defer such quality checks to later stages of the development cycle.
This, in turn, makes debugging code and troubleshooting failures simpler and more efficient because there are fewer incidents to resolve and because change sets are not compounding at the same rate. Smaller change sets, in turn, lower the likelihood of merge conflicts and stale feature branches and pull requests.
And of course, the impact of less time spent dealing with compounding change sets, merge conflicts, and stale code, is to further increase developer productivity.
3. Higher Quality Software
Higher quality code results because there is less chance of defects passing through quality gates and ultimately being discovered in production environments after impacting the end-user experience.
This is because more bugs are found and fixed earlier since it’s convenient to run local builds more often. And bugs that make it through initial quality gates are fewer and therefore easier to isolate at later stages of the software development pipeline. This makes it even more likely that they will be addressed before being pushed to production.
Finally, with fast feedback cycles, developers are less likely to act out on their frustration with slow builds and tests by overtly engaging in damaging behaviors like cutting corners and even turning off tests and other safety measures in order to ship faster.
There are some obvious direct impacts that faster feedback cycles have in encouraging and reinforcing good habits and developer best practices. Hopefully, this article has untangled the cause and effect relationship with other indirect benefits you may have not considered.
There is one other “soft” benefit that may yet be the most important: the impact on developer happiness. Fast feedback cycles mean developers waste less time waiting for builds and tests to complete and performing tasks they enjoy less like troubleshooting problems. The more time reserved for pursuing their passion—being creative and writing great code—the happier they will be.
And, a good way to discourage developers from engaging in negative behaviors is to minimize avoidable frustrations. Conversely, the best way to encourage positive behaviors is to make it easier to always do the right thing by investing in processes and tools that support a great developer experience. A good place to start is those that speed up feedback cycles.