Gerald Weinberg, a legendary computer scientist and author, released the 1971 book The Psychology of Computer Programming. Here, he urged organizations to look at programming as a human activity instead of a technical one.
Over the past few years, various publications have created a yearly "developer happiness index." These reports show why this matters and the factors contributing to the satisfaction. Here, we'll examine how to ensure a happy and productive developer team.
Prioritize with conversation
Time is of the essence. Every decent team of developers is usually super busy. Yet, you still need to get a word in --- the trick lies in the right conversation strategy. Sometimes, the learning curve isn't with the programming side but with the communication.
To ensure you get the best return on investment for your developers, you must evaluate with them what to do in collaboration. Why? Task A might take 42 hours and be valuable, but another task could take 2 hours and be even more valuable for the number of hours.
Developers are highly technical individuals. Thus, you should figure out how to communicate with them. An excellent method is to evaluate what you can do with them during collaboration. In this process, you want to maximize the value of each task, even if completed in a few hours.
Wonder how we set small and big goals? Learn more about how we adopted the military command intent tactics to our software development process.
Another point worth mentioning is respect. Developers are often more accommodating if you appreciate the work and time involved. Sometimes the simplest thing is not actually that simple, while something that seems complicated may take a few minutes. The point is everything requires time and effort.
Lastly, if your software developers are remotely based, there are plenty of team collaboration or team-based apps like Slack and Microsoft Teams you should consider.
Report bugs well
An ineffective report on bugs reduces the chances of getting it fixed. The American software engineering professor Cem Kaner once said, "The point of writing a problem report is to get bugs fixed."
You always need to be specific with your developers. For example, your bug report should have all the key points or relevant information about the particular struggle. It allows the developer to visualize the problem in the best way possible.
Visual proof through screenshots and video clips can also help here. Also, at this stage, tell them what you expected to happen and what ended up happening.
Another aspect of good bug reporting is using the right tone. It's easy to sound commanding using harsh words or abusive language, assuming the developer made an error. Instead, it's better to use a suggesting tone to maintain morale.
Here is a guide on how to report bugs.
Never confuse bugs and features
Most developers want to build features, solve problems and have fun. If you don't want to keep software developers happy, let them spend days on bugs. Yet, the line can sometimes be blurred between bugs and features.
You can ship a product only to find something doesn't work as it should. But somehow, your customers don't mind and don't know it's a bug.
Also, developers can create something they believe is perfect, only for their leaders to find something broken with it.
A feature is intentional, while a bug is accidental. Understanding the distinctions is crucial.
Differentiate between urgent vs. important
The human mind is reactive by nature; it's mentally stimulating. We often react quickly without thinking whether what we did was the best thing to do. And so comes the urgency-important quadrants, as explained in the Eisenhower Matrix.
It boils down to priority. When looking at the responsibilities of software developers, understanding the difference between urgent and important is beneficial for all those involved.
An urgent task has clear deadlines and consequences if acted on after some time. This is because it involves visible and unavoidable issues which demand your attention now. On the other hand, essential activities have a limited time limit, meaning you can delay them.
There is a caveat, though. If everything is urgent, nothing is urgent. Putting out too many fires doesn't result in the desired software developer happiness. Instead, it results in burnout and lowers throughput. So, you should use urgency scarcely and only when it makes sense.
Summarize conversations with bulleted lists
In keeping with prioritizing stuff, it helps to use bullet points when speaking to your devs team. Some people think they are unprofessional. But even on a CV, the bulleted lists help recruiters look at the most critical elements and browse your resume faster.
Similarly, with developers, bullet-pointed lists help get your intent across in the most concise way possible.
Here is an example:
- Most important is to make it possible for the admins to upload pictures
- After this, the focus can be on showing the pictures
- If there are problems with admin rights, contact Monica for access
Respect their individuality
As people, we are unique. Part of maintaining happiness for your projects is recognizing the different personality types of software developers. So, expect your developers to have a wide range of character traits.
The best way of measuring these is using the personality guidelines from the Myers--Briggs Type Indicator. This will help you notice certain behaviors and patterns from your developers.
Here are the typical best personality types for coders.
- INTJ (introverted, intuitive, thinking, judging): nicknamed the Architect; strong creative and performance drive; ability to see connections where others don't.
- ENTP (extroverted, intuitive, thinking, perceiving): The Debater; likes problem-solving and working with new challenges.
- INTP (introverted, intuitive, thinking, perceiving): referred to as The Logician; analytical, adaptable individuals; INTPs are in the best web developer companies and other tech-related fields
- ENFP (extraversion, intuition, feeling, perceiving): often nicknamed the Campaigner; the "hype" developers; enthusiast; strong communicators and personal interactive; ENFPs don't like working alone
- ISTJ (introverted, sensing, thinking, judging): the "Logistician"; responsible and practical organizer; dependable; like to enforce orders
Ask what is up
No person wants to deal with someone that talks to them only for favors or to solve problems. Similarly, you should build a relationship with your developers where you can find out how they're generally feeling aside from work.
Feel free to break the ice by discovering their hobbies and favorite sports or cracking a few jokes. Programmers are not code machines but regular people. But, at the same time, this doesn't mean you get too personal.
It's about balancing mutual respect and authority over the project. Building rapport allows your developers to communicate new ideas more freely and whether something is affecting their work.
Let them optimize and tinker
Programmers are passionate about coding and love to enhance their developer tools. Therefore, they should be free to optimize existing systems and tinker with new technologies.
This isn't to say they should always be experimenting, but dedicating a day to this can be good. Tinkering has a lot of positive impacts. First, it sparks many team conversations around testing and quality. Developers are inspired to improve their knowledge and skills continuously.
Invest in proper tooling
Like any profession, having the right tools for the job can make or break a project. While investment in this area is key, proper tooling doesn't always have to be pricey.
The most crucial factor is the usefulness and necessity for the intended product's success. Integration is related to this as well. Some tools merge quite nicely with existing tools.
Providing your devs with a better PC or laptop and an additional monitor may make the difference in the efficiency of tasks getting done.
If your team is working remotely or has a noisy work environment - it's much easier to cover the costs for noise cancellation headphones than to constantly deal with a distracted teammate, who has big value for your company's success.
Third, we need to consider the learning curve. In some cases, existing developer experience can determine a tool's usefulness for a project. Programmers have strong opinions on stuff they've already used and can express these freely.
It can also tie into what we mentioned earlier regarding tinkering. New and exciting tools will empower your developers and add to their industry knowledge. Yet, you should know that some tools may take more time and effort to deploy in a team and integrate with existing software. This, of course, can be a form of overhead.
Here is a list of the key tools that are necessary for keeping your devs happy:
- IDE (Integrated Debugging Environment)
- Build tools
- Source control
- Bug trackers
- Automated deployment/continuous integration tools
- Testing tools
- Noise cancellation headphones
- An extra screen
- Better computer
Aid, not dictate
Looking at the personality types we mentioned, you'll notice intuition, thought, perception, and judgment themes. Despite some individual differences, developers are generally logical beings.
Although they like to follow processes, they are happier knowing how it aids their work. Each process should be relevant. It must make sense why something has to be done a certain way. Times are always evolving, and change is the only constant.
It's easy to copy and implement something done by another organization into your team. Yet, that doesn't mean your developers will be happy about it.
So, a little bit of aid helps. But ultimately, don't dictate. Let the developers create their processes; they are here to code and not worry about the procedure. They are the ones that truly know about ensuring the best software creation.
Provide growth opportunities
People in life never want to remain stagnant. So, offering growth opportunities is essential for companies that train software developers. It's a common trend that most employees, particularly devs, don't stay in one organization for 2-3 years.
Many times, it's because they see their friends moving up the ladder, which propels them to search elsewhere. Promotions are rare. Yet, companies can encourage room for growth through learning, project participation, etc.
Even though developers may leave in search of greener pastures, they will be better equipped and can come back later for a different role. Still, it is also up to the developers to have the will to improve. But combined with support from their organization, growth opportunities are possible to ensure a brighter future.
Compensation always entices developers, but keeping them happy is a whole different story. Brilliant engineers are 'rare finds', with new opportunities often knocking on their doors.
That's why you should know how to keep them committed to you with the tips we've shared above.