It’s challenging at times to remember the men, women, and even Internet trolls who will eventually use our products. But it’s important to be able to see things from their perspective, eventually getting to the point of knowing how they think and feel. That’s important because it helps you make more informed decisions as a developer.
No, empathy isn’t a hot new programming language. But empathy can function as a superpower for software developers.
There are four situations in which empathy can be a software developer's secret weapon. But first, let's first start with a definition.
What Is Empathy?
Empathy is understanding and being sensitive to the experiences of others. The kicker is being able to understand without those experiences being explicitly communicated to you.
Dr. Brené Brown, an empathy researcher, writes in her book Daring Greatly: “Empathy is a strange and powerful thing. There is no script. There is no right way or wrong way to do it. It’s simply listening, holding space, withholding judgment, emotionally connecting, and communicating that incredibly healing message of ‘You’re not alone.’”
So with empathy, you understand the other person without them telling you directly how they feel. It’s recognizing emotions in others and being able to put yourself in that other person’s shoes. It’s the calm cashier listening to an angry customer first without interrupting with solutions.
We can apply empathy to our work as software developers, so let’s look at the four ways you can be empathetic.
Empathy For Software Developers
If you’re developing software, it’s almost always going to be for or with other people. Because software development involves other people, empathy can be useful.
It can help us solve problems by getting to the heart of what’s important to people, both users and fellow developers. When you put empathy at the center of technology, human connections become stronger.
On the developer side, these connections boost collaboration and employee retention. It makes for a better working space for everyone involved.
It helps us create better products because we better understand the people who will be using them.
Empathy has a logical place for user experience testing but can be found in these four areas as well.
1. When Gathering Requirements
Software developers should use empathy when gathering requirements for their projects. We’re building software for people; by using empathy, you’ll have a better understanding of the people who interact with your software.
Empathy is a required ingredient for successful software. Software is an expression of an idea. Coding is building that idea into a tool that others will use to achieve a goal. By having empathy for someone else, or even your future self, you’re able to build a more effective tool.
With empathy, you're on the fast track to understanding the people that will use your software. Other developers may choose to take a logical approach to fleshing out requirements. But by using empathy as your secret weapon, you’ll have a clear way to stay focused on the most important people – your end users.
2. During The Coding Process
Software developers should use empathy when building software with other people because you’ll be more likely to predict the reactions of your teammates. Empathy is a big part of working in teams.
Code is another form of communication. When architecting and developing a system, we should strive to share an understanding with the people who will interact with our code. Empathy can help us put ourselves in those people's shoes.
In addition, with empathy, you’re more likely to build maintainable code. Other developers may not think about the advantage that empathy gives them. They’re quick to sacrifice maintainability for speed. They don’t think about other developers or their future self at the component level of the system. By using empathy as your secret weapon, you’ll write cleaner code with proper documentation.
3. While Supporting Programs We Create
Software developers should use empathy while operating the software we create because everyone on the team should be responsible for delivering valuable software.
There are multiple roles on a software team. One person could be wearing multiple hats, but typically each role is carried out by an individual team member.
Some developers are happy throwing problems over the fence to QA, IT, or Customer Support. They feel that their work is done after the code has been merged.
Empathy helps us work with and understand our teammates at a deeper level. Empathy allows a developer to comprehend what it’s like for someone else to clean up their mess, and in turn makes them want to cause fewer messes for others. It helps the developer take responsibility for their own work.
By using empathy as your secret weapon, you’ll be able to break down silos and help support others better, thus becoming a more valuable team member.
4. When Being A Leader
Software developers should use empathy when they’re leading. Leadership is relevant to all of us, because we’re always influencing others, even when we’re not trying to.
Empathy in software development leadership is a balance between freedom and accountability. You'll be more effective at convincing others of your point of view, but at the same time, you’ll be more likely to see both sides of a technical debate.
This ability to see things from others’ perspectives is a key skill when taking the lead.
Some developers are happy to go it alone, only focusing on their own needs. But by using empathy as your secret weapon, you’ll be able to relate to the needs of your co-workers and give them the leadership they need to be a great team.
Empathy Could Be Your Superpower
As software developers, we’re typically locked into technology. Too often to the outside world, the stereotypical good developer looks like a data-driven, Spock-like character, and sometimes it’s easy for us as developers to fall into that mindset.
But having or practicing empathy can be a secret weapon for software developers. Because empathy helps us see things from others points of view, it allows us to solve problems as we’re gathering requirements, during coding itself, when we’re supporting our work, and as we lead.
Practice empathy as your superpower and you’ll be a hero to your team, your users, and your employers.