Unhappy developers

What makes developers unhappy?

""...you spend like 2 hours investigating on Google for a similar issue and how it was resolved, you find nothing, desperation kicks in." ~[2]

At most modern software companies building positive developer experiences is imperative to their success. How developers spend their time at work has a big impact on their happiness. Here are the most frequent causes for developers to be unhappy[1]:

1. Stuck in problem-solving
2. Time pressure
3. Work with bad code

Being stuck in problem-solving and time pressure are the two most frequent causes of unhappiness[1]. How could that be since it is recognized that problem-solving under deadlines is in the nature of software development?

Let's imagine a developer finds out there is a production crush due to a defect. That needs to be fixed - immediately. The developer is familiar with that part of the system and volunteers to fix it in a couple of hours. However, the defective code happens to be a bad code written by somebody else and is not easy to comprehend. The fix was supposed to take two hours but no it looks more like two weeks! That is extremely frustrating and also puts the developer under time pressure due to the initial promise of two hours. The whole organization is under pressure because remember the defect crushed the production instance.

That leads to the third most frequent cause of unhappiness, which is to work with bad code[1]. Bad code can be a result of management decisions aiming to save time and effort in the short term. Developers suffer when they encounter bad code that could have been avoided in the first place[1]. Bad code is usually called technical debt.

All three causes are the result of the software developer passing through the states of perplexity., to worry and finally to anxiety. We can measure the level of happiness by quantifying the perplexity a developer faced.

Consequences for productivity

""...you spend like 2 hours investigating on Google for a similar issue and how it was resolved, you find nothing, desperation kicks in." ~[12]

Researches found the following consequences of happiness and unhappiness while developing software[1]:

• Delays
• Low code quality
• Throwing away code
• Low motivation
• Low cognitive performance i.e. inefficient processing of information in the brain.
• Mental unease
• Work withdrawal i.e. a family of behaviors that is defined as employees’ attempts to remove themselves, either temporarily or permanently, from daily work tasks.

The external consequences, such as delays and throwing away code, have direct impacts on productivity. Internal consequences, such as low motivation and reduced cognitive performance, indirectly affect productivity as well.

If developers are unhappy then the human potential is underutilized which leads to low productivity.

How to make developers happy?

The key to developer happiness is enjoyment of everyday work. That is achieved by making sure the developers are in the state of Flow as much time as possible.

We can achieve that if we keep the challenges always a bit ahead of individual capability. Below is a diagram showing how to improve developer capability and keeping the developer in the state of flow all the time.

Let's assume the diagram represents the career of a junior developer through an expert. At the beginning there is no capability. We give the developer a simple task that is yet more challenging than their capability. After the task is completed the developer has acquired knowledge and improved capability abit. We give another task that is simple yet more challenging than the capability. After finishing it the developer is a bit more capable. We continue this way through time and eventually the developer is very much an expert. The most important thing is that this improvement journey was strictly inside the flow zone.

Nex it to manage the nature of the tasks a developer works on. Even though a developer's primary tasks *should* be coding and software design, many still feel they aren't getting enough time for deep work:. Developers spend most of their time designing, coding, and debugging, and would like to spend even more of their time on these tasks, instead of in meetings and on administrative tasks[3]. Thaus, we need to make sure developers don't spend time in meetings and on administrative tasks.

Making developers happy takes the discipline to let them focus on coding and software design.

Software developers start each task with a particular perplexity i.e. amount of missing information. Perplexity decreases in a disjoint fashion — with each learning episode, until at the end it is at another, lower level. In reality much of this learning is a function of the organization, and largely not managed and out of control.

To make developers happy and improve productivity an organization needs to reduce the level of perplexity software developers gace.

It is management's job to reduce their perplexity and the detrimental effects of time pressure and getting stuck. to a task that matches their level of knowledge. How to deliberately reduce the degree of perplexity is presented in Managed knowledge discovery