At DevRelX our mission is to empower the more Developer Relations practitioners to understand developers and make educated decisions based on data to create the best experience for their developer communities. To get there, we bring you an all-around view of the developer population, who they are and what are their needs. This time, we are taking a closer look at developer happiness! ☀️
Does happiness lead to productivity? Join our community and share your thoughts with us! It might sound intuitive already, but we are obsessed with data. So, we looked into it. And by “we” I mean SlashData and Sentry joined forces to analyse the feedback taken from survey respondents who are professional developers who write software on a regular basis.
To make our filtering even more accurate, it mainly involved experienced developers with at least 10 years of software development experience, as they were required to have a live application. This intentional filtering ensures that the average developer surveyed possesses extensive knowledge and can provide valuable insights into the software development process.
Are happier developers more productive?
Firstly we wanted to identify what makes developers happy and we found:
1. Company size and colleague count don’t significantly impact happiness levels.
2. Whether you’re an experienced coder or new to the field, everyone’s happiness is similar.
3. Delving into infrastructure tasks brings more joy! Devs spending 10 extra hours a week on these issues experience a 3% happiness boost.
4. Managers or those with ‘chief’ titles tend to be 6% happier than their peers.
These insights shed light on what contributes to developer satisfaction in the workplace. Understanding these factors can help foster a more positive and productive environment for all developers.
We developed a unique productivity metric by combining three crucial measurements, focusing on how quickly developers complete programming tasks and deploy code to production.
Here’s what our productivity metric considers:
Time from code committed to code in production.
Time taken to recover from an unexpected outage.
Frequency of code deployment to production.
Interestingly, we observed that developers in larger companies tend to take slightly more time to complete tasks compared to their counterparts in smaller organizations. This information provides valuable insights into the dynamics of developer productivity across various company sizes.
What hinders and boosts productivity?
When it comes to barriers, larger companies might experience a slight dip in productivity, with every 500 additional employees contributing to a 1% drop.
Internal processes and bureaucracy can be culprits, but fear not – we’ll share tips to optimize workflow! Communication is another key player; if it’s smooth sailing, devs thrive, but if not, productivity could plummet by a whopping 48%. However, only 10% of developers face this issue.
By combining frequency and time metrics, we unveil a cool productivity score measured in hours, allowing us to understand the overall productivity landscape.
The best part? Happy developers are productive developers! Being 10% happier means completing tasks 10% faster, and each year of experience in software development boosts productivity by 6%.
Let’s take a closer look at developers’ workloads and what they wish for versus reality!
The biggest difference lies in dealing with internal messaging, processes, and infrastructure issues. Developers express the desire to allocate 19% and 17% less of their time to these time-consuming tasks. It’s clear that efficient communication and workflow tools are essential for smooth business operations.
We analyzed their productivity and found that developers spend the most time on software development, followed by project management.
They spend about 31% and 16% of their week on these tasks.
Interestingly, developers want to keep doing these tasks as they’re crucial components of their ideal week too. Oh, and here’s a nugget;
the more time they spend coding, the happier they are!
Let’s dive into how developers spend their time on software development!
Writing code is the most time-consuming activity for 29% of developers, with a whopping 69% spending a lot of their overall time on it.
The conceptual design phase also takes up significant time, but it’s an enjoyable activity for 60% of developers. However, debugging or fixing code is another time-consuming task, with 67% of devs dedicating a lot of time to it.
But here’s the catch – only 51% actually enjoy it. Debugging can be a real workflow challenge and hurt productivity.
What do they feel about their tasks?
Fixing bugs and improving software performance bring joy to 65% of developers.
They take particular pride in improving software/app performance (21%) and debugging code (12%).
Writing good code is a big source of pride for 27% of developers, and a total of 69% find pride in this task.
What about the challenges?
The top two challenges are cleaning up legacy code (33% of developers) and running into untested code (32%).
Interestingly, cleaning up legacy code was more common in larger teams, where devs work with a 12% bigger team. But don’t worry, larger teams have more resources for testing, so running into untested code isn’t as big of a challenge for them.
Now, onto the root causes of issues. A whopping 37% of devs say a rushed timeline is the biggest problem they face. Among programmers and software developers, 45% identify rushed timelines as a key challenge, 14 percentage points more than CEOs and managers (31%).
Let’s explore the challenges faced by developers in different roles.
We’ll break it down by the prominent positions, such as management/chiefs, programmers/software developers, architects, and IT workers.
Surprisingly, shifting and unclear priorities are among the top three obstacles across all roles, but they’re especially prominent for programmers/software developers and managers/chiefs. Another common challenge for everyone, but particularly for architects, is too many meetings.
Interestingly, many of the top challenges reported in all roles are process-related. This emphasizes the importance for companies to implement good policies and procedures to optimize workflow and boost developer productivity.