This post is a condensed version of insights (refined using AI) shared by Sven Peters in the Software Craftspeople – India Community (SCI), a not-for-profit organization dedicated to connecting individuals with a software craftsmanship mindset. Learn more about SCI here. To connect with Sven Peters, find him on Twitter, LinkedIn, and his personal website.
Introduction
Change is constant in the tech world and as software development evolves, the focus on developer productivity has never been more crucial. In a recent talk titled “Developer Joy – How Great Teams Get S%*t Done”, Sven Peters, DevOps Advocate at Atlassian, shared insights into what truly drives developer productivity. He also explored how great teams can achieve success without sacrificing the joy in their work.
The Evolution of Developer Responsibilities
Over the past decade, the role of software developers has evolved dramatically. As Sven points out, the landscape was entirely different when he started his career in 2000. Back then, the cloud was an unfamiliar concept, and software development didn't involve the complex responsibilities it does today. Now, developers must manage everything from configuring cloud toolings to handling microservices and ensuring security and governance.
This expansion of responsibilities, while enhancing the scope of developers' roles, has also increased cognitive load. Developers are now tasked with not only creating software but also running it in production environments, dealing with observability, and maintaining high levels of security. While these changes have undoubtedly made the development process more robust, they have also introduced challenges that can impact productivity.
The Productivity Obsession
One of the key themes Sven explored was the industry's obsession with productivity metrics. This fascination can be traced back over a century to the era of Frederick Winslow Taylor and his "Taylorism," which revolutionized factory work by introducing time studies and productivity improvements. However, applying similar metrics to software development is not as straightforward.
In modern development environments, traditional metrics like lines of code or the number of issues resolved often fail to capture the true essence of productivity. Instead, these metrics can lead to misguided efforts to optimize at the cost of developer satisfaction and overall quality.
Shifting Focus to Developer Joy
Sven emphasized that rather than fixating on outdated productivity measures, the focus should be on fostering "developer joy." This concept revolves around creating an environment where developers are motivated, engaged, and passionate about their work. When developers are happy, they are naturally more productive.
To illustrate this point, Sven shared several stories from Atlassian. One example is the JIRA team’s introduction of a "review etiquette" to make code reviews more constructive and less intimidating. This initiative not only improved the quality of the code but also enhanced team collaboration and satisfaction.
Some key principles from the review etiquette include:
- Assume Competence: Trust that the author of the code is skilled—after all, they were hired for a reason. Start from the assumption that they are competent.
- Be Constructive: Avoid vague or negative comments like “This code is ugly.” Instead, provide specific, constructive feedback on how the code could be improved.
- Explain Your Reasoning: If you believe a “for” loop is better than a “while” loop, explain why. This helps the author learn and grow from the review process.
Optimizing Workflow for Joy – Better Tooling
Optimizing workflows is important for reducing friction and bottlenecks. Sven shares how the Confluence team tackled the issue of flaky tests by developing a simple yet effective "flaky test detector." This tool saved the team countless hours by automatically identifying and flagging unreliable tests, allowing developers to focus on meaningful work rather than troubleshooting.
The key takeaway from this incident is that providing developers with better tools is crucial. By reducing debugging frustrations, you can significantly enhance developer joy.
Developer Flow
Flow is that state where time disappears because you’re so deeply engaged in your work. It’s crucial for productivity, but software development isn’t just coding—it’s also building, testing, and deploying. These processes can be optimized to save time—like reducing build and test times from hours to minutes by running parallel tests or streamlining deployments. However, one stage that often drags on is the code review phase.
On average, the Confluence team took three days to merge a pull request. This delay slowed their ability to deliver value and caused inefficiencies. To solve this, they built a bot to remind team members to review open pull requests first thing in the morning. This simple nudge cut review times from 3 days to 1.2 days.
Large pull requests often get postponed, so the team started making pull requests smaller and more manageable as well.
The key takeaway is that faster reviews mean less waiting, smoother processes, and ultimately, more developer joy.
Implementing Autonomous Teams
It's important to strive to maintain flow within and between teams. By implementing autonomous, cross-functional teams, they reduce dependencies and waiting times, enabling faster delivery of customer value and, ultimately, more developer joy.
Collaboration Between Developers and Product Managers
Effective collaboration between developers and product managers is another crucial aspect of creating joy in the development process. Sven recounted a personal experience where a lack of clear communication led to repeated revisions of a feature. To prevent such frustrations, it is important to involve developers more closely in the early phases of product development, ensuring they understand the "why" behind the features they build.
Involving everyone reduces rework frustrations leading to improved developer joy.
Measuring What Matters
While traditional productivity metrics may not fully capture the complexity of modern software development, Sven acknowledged the importance of measurement. A balanced approach might include using a mix of proven metrics, like those from the DORA framework, and custom surveys to gauge developer satisfaction and identify areas for improvement.
The key is to focus on what truly matters to your team. Understand where they are struggling and concentrate on measuring and improving those specific areas, rather than trying to measure everything possible.
The goal is to measure what truly matters and use those insights to foster a more productive and joyful work environment.
Conclusion
Measure what is important, don’t make important what you can measure – Robert McNamara
The key takeaway of the session was to shed light on the evolving nature of software development and the importance of prioritizing developer joy over outdated productivity metrics. By focusing on quality, collaboration, and the right tools, teams can achieve remarkable results without sacrificing the well-being of their developers. In the end, a joyful developer is a productive developer, and that is the key to building great software.
