Introduction

In the world of software engineering, where we mostly think about systems and platforms, where success is measured in SLOs and RPSs there are two things that are crucial to the teams that actually build these software systems: empathy and respect. These two qualities might not be lines of code or algorithms, but they are the heartbeat of cohesive and innovative software engineering teams. This is why it is important for software engineering managers and team leads to be aware of them even though they are not hard technical matters.

Empathy is the ability to step into another person’s shoes and understand their feelings, thoughts, and experiences. It’s a nod to the fact that each one of us brings a unique perspective, and by understanding that perspective, we unlock the potential for deeper connections and more meaningful collaborations. Empathy acknowledges that behind every line of code is a coder – someone with aspirations, ideas, and the occasional cup of coffee.

Respect, on the other hand, is the recognition that every individual, regardless of their role or level of expertise, carries inherent value. It’s the understanding that differing opinions aren’t roadblocks but rather pathways to better solutions. Respect acknowledges that the act of listening can sometimes be as powerful as typing out a thousand lines of code.

While empathy is about understanding, respect is about honoring. When these two qualities intertwine, they create a synergy that fuels teams with trust, collaboration, and innovation. Empathy opens the door for open conversations, while respect ensures that those conversations are met with genuine consideration. And fostering good communication is at the centre of building high performance teams

Putting Empathy and Respect in to context in Software Engineering Teams

But what does that have to do with what we do in our day to day work in our engineering teams? The above descriptions seem quite theoretical and abstract. How can we actually put these in to practice in our day to day work. Let’s take a few examples

1. Story Refinement:

   Empathy: Understanding the end user’s perspective is at the core of story refinement. By putting yourself in the user’s shoes, you can ensure that the software you’re building meets their needs effectively. This goes twice for backend engineers such as my own team. We like to think that we have less user experience concerns because our clients are not direct customer but other development teams. In truth this is even more important because if we do not design a good, developer friendly, usable API, we will be putting other developers in to unnecessary hardships.
   Respect: Respect for diverse viewpoints during story refinement allows for a well-rounded understanding of the problem. Every perspective contributes to a more comprehensive solution. Understand that product owners, UX designers, Data Engineers and various other teams will come at a problem from their own viewpoints. They each bring their own ideas to the table and make sure to consider them all in equal weight so as not to dismiss any ideas out of hand.

2. Coding:

   Empathy: While coding, empathy is about considering future maintainers. Writing clean, organized code makes it easier for your teammates to understand and collaborate. Remember the old quip - “Always code as if the person who ends up maintaining your code is a violent psychopath who knows where you live.”.
   Respect: Respect for coding standards and conventions maintains consistency across the codebase, making it accessible to everyone who interacts with it.

3. Code Reviews:

   Empathy: During code reviews, empathy involves understanding that mistakes happen. Providing feedback in a constructive and considerate manner promotes a positive learning environment. Make sure to let the team members know that the comments are about making their skills better and making the product better.
   Respect: Respectful code reviews acknowledge the effort that went into the code and offer suggestions for improvement without undermining the coder’s skills. Understand that the you should make an equal effort to make sure they get good feedback. Make sure they feel good about them when they have done a good job as well. Too often people only offer criticism and while that is important, you should let them know when they have done a good job.

4. Build and Release:

   Empathy: In the build and release process, empathy means considering the impact of your changes on other team members and downstream processes. More often than not, when doing releases, we are more concerned about getting the application out and hitting our deadlines. But good practice calls for coordination and advance notification. If you have operations teams - let them know in advance, make a summary of changes and distribute it. If you have folks who are on call in the team, include them in the communications. And most importantly for backend teams (again like my own team!), let the downstream clients know and give them a chance to verify the changes, preferably with you standing by to help if required.
   Respect: Respect for the release process and schedule ensures that the efforts of all team members are aligned, minimizing disruptions. Make the necessary changes to allow for other team’s practices and conventions. If you need to change things, talk to the other teams, most of the time they will be willing to budge or compromise.

Empathy and respect aren’t limited to a single activity; they infuse every aspect of software engineering. By understanding each other’s roles, appreciating diverse viewpoints, and valuing the collective efforts, software engineers can create a harmonious ecosystem where innovation flourishes and collaboration thrives. So, as you embark on your coding journey, remember that behind every line of code is a world of empathy and respect.

The Role of a Team Lead

As a software engineering team lead, you’re not just responsible for managing code; you’re entrusted with cultivating an environment where empathy and respect flourish. Your role goes beyond technical guidance, encompassing the creation of a team culture that prioritizes these foundational values. Here’s how you can play a pivotal role in fostering a culture centered around empathy and respect:

1. Lead by Example:
   Demonstrate empathetic and respectful behavior in all your interactions. Your actions set the tone for the entire team. If you do not show empathy and respect in practice, your team will not either.
2. Encourage Open Communication:
   Promote transparent and open communication channels, encouraging team members to share their perspectives and insights freely. There can be no empathy if people are not openly communicating how they feel. Your team should be able to communicate the need for improved software quality, improved processes and better software engineering culture without feeling like they are personally targeting anyone. Equip them to communicate these ideas properly, and as it says above, lead by example.
3. Address Imposter Syndrome:
   Provide resources and guidance to help team members navigate imposter syndrome. Offer a support system to bolster confidence and self-assurance. This is crucial in practice I have found. Engineers from more diverse and varied backgrounds often feel like they do not belong and are not worth the position and role they find themselves in. I, myself have gone through this early in my career. As a software team lead it is your responsibility to identify this, and make sure they know their worth and capability. Tell them that having a self respect for their own capability is the first step towards making the team better by using their skills. If they do not feel empowered and compelled to make the team better using their skills, it is game over already.
4. Embrace Diversity:
   Recognize the significance of diverse viewpoints. Embrace the unique qualities that each team member brings to the table. If your team does not have diverse opinions, take corrective action. Hire for diversity, offer coaching, reward contrary and diverse viewpoints - because homogeneous thinking never improved any team.
5. Navigate Conflicts with Empathy:
   Address conflicts with empathy and fairness, ensuring that all voices are heard and understood during resolution. As a team leader, the onus will be on you to solve most of the team internal conflicts as well and external conflicts with other teams. Always understand, where they come from and remind yourself that whatever the problem at hand is, all of you are on the same team and have the same goal - make the product better.

Your role as a team lead extends far beyond the technical realm. By nurturing a culture steeped in empathy and respect, you lay the foundation for a cohesive, innovative, and high performance software engineering team.

Case Studies in Empathy and Respect in Software Engineering

This kind of emphasis is getting quite frequent in software engineering field these days. Take spotify for an example. They have released a developer portal generating tool called backstage and on the blog post announcing the tool, they list four principles that they want the users of that tool to follows. They themselves follow the principles as well

> 4. Our fellow developers are our customers, so build with empathy
> 
> Developers deserve as great an experience as our listeners and creators do. 
> Ensure that the tools in the Spotify platform are the right tools for the job — and listen and adapt when they aren’t. 

And clever says something similar about their engineering culture as well. Here is a blog post explaining how they value empathy. To quote the interesting bits

> Code with Empathy

> We develop software with our customers and our fellow engineers in mind. To gain empathy for our customers, we embed product managers within engineering teams so they may work closely together. We also encourage engineers to participate in product specifications, user testing, and school visits. We choose to write code that is readable over code that is clever or terse, to help our colleagues and future selves read and update the code. We value simplicity as a key ingredient in  software architecture and implementation, as simple systems are easier to maintain, debug, and operate.

And this is again repeated in various places from infoq to newstack. But the common theme is the same. Empathy is a key ingredient in a high performing software engineering team.

Summary

Remember Empathy is not just a feeling. It is a core part of what makes good teams perform better. It is the thing that keeps the members together and work as a team. What makes the whole greater than the sum of it’s parts.

• Respect Enhances Empathy: When you respect someone, you are more likely to listen actively and engage with an open mind. This can lead to a deeper understanding of their feelings and viewpoints, fostering empathy.

• Empathy Deepens Respect: Empathy allows you to see things from another person’s perspective, which can lead to a greater appreciation for their uniqueness and the challenges they might be facing. This, in turn, strengthens the respect you have for them.

• Both Support Positive Relationships: Building relationships based on both respect and empathy creates an environment of trust, understanding, and support. It promotes effective communication and reduces misunderstandings.

• Both Counter Conflict: In conflicts or disagreements, both respect and empathy can play essential roles in defusing tension. Showing respect even during disagreements and trying to understand the other person’s perspective can prevent conflicts from escalating.

In summary, respect and empathy are interconnected values that contribute to healthier and more compassionate interactions. Practicing both in your relationships can lead to better communication, reduced misunderstandings, and a more harmonious environment overall.