EmpathiSEr: Validated Scales for Measuring Empathy Towards Software Engineering Practitioners and Users

summary

The gist

EmpathiSEr introduces two domain-specific scales to measure empathy towards software engineering practitioners and users…

In short

EmpathiSEr introduces two validated scales: EmpathiSEr-P for measuring empathy among software practitioners and EmpathiSEr-U for measuring practitioner empathy towards users. These instruments address a gap in research by providing psychometrically sound tools to study how empathy manifests in the unique context of software engineering, enabling better assessment and design of empathy-enhancing interventions.

Key concepts

EmpathiSEr-P
This scale measures the level of empathy shared among software engineering practitioners. It assesses three dimensions: cognitive empathy (understanding others' perspectives), affective empathy (feeling what others feel), and empathic responses (actions taken in response to others). It helps teams reflect on their internal interpersonal dynamics.
EmpathiSEr-U
This scale captures the degree to which software practitioners empathize with users. It is designed for organizations to reflect on user-oriented perspectives during development. This helps teams better understand user needs, preferences, and challenges from a practitioner's viewpoint.
Cognitive Empathy (CE)
Cognitive empathy is the ability to understand another person's mental state or perspective without necessarily feeling what they feel. In SE, this involves understanding a user's frustration with system usability or an engineer's technical constraints during implementation.
Affective Empathy (AE)
Affective empathy refers to the capacity to share and feel the emotions of another person. For practitioners, this means experiencing the frustration or satisfaction related to a user interaction or a team member's experience with technical challenges.

Terminology used across episodes

This episode discusses

The paper

EmpathiSEr: Validated Scales for Measuring Empathy Towards Software Engineering Practitioners and Users · Read on arXiv

Hashini Gunatilake, John Grundy, Rashina Hoda, Ingo Mueller

Monash University · Monash Centre for Health Research & Implementation

Empathy plays a critical role in software engineering (SE), for instance in situations where developers interpret non-technical users' frustration with system usability or where product owners account for the technical constraints experienced by engineers during implementation. Such interactions shape collaboration, communication, and user-centred design outcomes. Although SE research has increasingly recognised empathy as a key human aspect, there remains no validated instrument specifically designed to measure it within the unique socio-technical contexts of SE. Existing generic empathy scales, while well-established in psychology and healthcare, often rely on language, scenarios, and assumptions that are not meaningful or interpretable for software practitioners. These scales fail to account for the diverse, role-specific, and domain-bound expressions of empathy in SE, such as understanding a non-technical user's frustrations or another practitioner's technical constraints, which differ substantially from empathy in clinical or everyday contexts. To address this gap, we developed and validated two domain-specific empathy scales: EmpathiSEr-P, assessing empathy among practitioners, and EmpathiSEr-U, capturing practitioner empathy towards users. Grounded in a practitioner-informed conceptual framework, the scales encompass three dimensions of empathy: cognitive empathy, affective empathy, and empathic responses. We followed a rigorous, multi-phase methodology, including expert evaluation, cognitive interviews, and two practitioner surveys. The resulting instruments represent the first psychometrically validated empathy scales tailored to SE, offering researchers and practitioners a tool for assessing empathy and designing empathy-enhancing interventions in software teams and user interactions.

Transcript

Introduction to the show: ident: Computer Science. The day in computer science: software, systems and theory on arXiv.

Tom: I'm Tom.

Jane: And I'm Jane, here with Lu, Meng and our in-house large language model, Lalam.

Tom: We're looking at the paper: "EmpathiSEr: Validated Scales for Measuring Empathy Towards Software Engineering Practitioners and Users".

Jane: Here's the gist of the paper. EmpathiSEr introduces two domain-specific scales to measure empathy towards software engineering practitioners and users, addressing a critical gap in existing research The resulting instruments represent the first psychometrically validated empathy scales tailored to SE, offering researchers and practitioners a tool for assessing empathy and designing empathy-enhancing interventions in software teams and user interactions Pruning redundant reasoning tokens Empathy plays a critical role in software engineering (SE), for instance in situations where developers interpret non-technical users’ frustration with system usability or where product owners account for the technical constraints experienced by engineers during implementation Existing generic empathy scales, while wellestablished in psychology and healthcare, often rely on language, scenarios, and assumptions that are not meaningful or interpretable for software practitioners These scales fail to account for the diverse, rolespecific, and domain-bound expressions of empathy in SE.

Tom: To address this gap, the authors developed and validated two domain-specific empathy scales: EmpathiSEr-P, assessing empathy among practitioners, and EmpathiSEr-U, capturing practitioner empathy towards users.

Jane: Grounded in a practitioner-informed conceptual framework, the scales encompass three dimensions of empathy: cognitive empathy, affective empathy, and empathic responses.

Tom: How the training signal is built The development of the SE empathy scales followed a rigorous, multi-phase methodology that integrated established psychological measures with empirical insights from the SE domain This process comprised seven main stages, including defining the construct, item pool generation, pretest survey, expert evaluation, cognitive interviews, and large-scale validation survey.

Title and authors: Tom: So we’re talking about the paper "EmpathiSEr: Validated Scales for Measuring Empathy Towards Software Engineering Practitioners and Users" and how it tackles the problem that current empathy tools just don't fit the specific roles in software engineering.

Jane: Exactly, because we see developers interpreting user frustration or product owners thinking about technical constraints during implementation, and generic scales just aren't meaningful for those technical jobs.

Lu: The authors say that standard empathy measures often use scenarios that aren't relevant to actual software development work, so they developed EmpathiSEr P for practitioner empathy and EmpathiSEr U for practitioner empathy towards users in <ref:2510.12546#pg1>.

Meng: What does this mean practically? If we can't measure it, how do we actually improve team dynamics or user-centered design outcomes on a daily basis?

Tom: The paper explains that they defined empathy as the ability to experience affective and cognitive states of another person while maintaining a distinct self in order to understand the other in <ref:2510.12546#pg3>. They then broke this down into cognitive empathy, affective empathy, and empathic responses.

Jane: That framework is specific; it moves away from those vague scenarios that don't fit the actual work environment of software engineering <ref:2510.12546#pg2>. They are trying to capture how empathy looks in collaboration and design outcomes.

Lu: The development process was pretty detailed, involving seven stages including defining the construct, item pool generation, pretest surveys, expert evaluation, cognitive interviews and a large-scale validation survey in <ref:2510.12546#pg3>. They even tested it against established measures to prove it worked.

Tom: And the results confirmed that this structure holds up; they found a three-factor structure: cognitive empathy, affective empathy, and behavioral dimensions of empathy in <ref:2510.12546#pg3>. Plus, they showed positive correlations with things like the IRI and EQ which shows some established validity.

Meng: But I’m still skeptical about the application here; if these scales are just scores, they don't tell me what to do on a Tuesday afternoon when a sprint is hitting a snag at scale.

Lu: Right, they intend for these scales to complement qualitative evidence rather than reduce empathy to just a number or treat measurement as the final goal in <ref:2510.12546#pg3>. They want to use this for more systematic investigations into empathy across workflows.

The paper's summary: Tom: To summarize, the EmpathiSEr: Validated Scales for Measuring Empathy Towards Software Engineering Practitioners and Users paper introduces two specific scales that you can actually trust and use in this field <ref:2510.12546#pg1>.

Jane: Right, so they built EmpathiSEr P to check how empathetic the people doing the coding or building are, and EmpathiSEr U to check how empathetic those builders are towards the actual users in <ref:2510.12546#pg3>.

Lu: The authors didn't just make up some generic psychological scales that don't fit developers; they used a framework based on what engineers actually experience doing, focusing on three types of empathy: cognitive, affective, and response dimensions in <ref:2510.12546#pg3>.

Tom: So what does that mean for the research world? It means researchers can finally measure empathy in a way that actually makes sense for software teams instead of just using vague scenarios in <ref:2510.12546#pg2>.

Jane: Exactly. The authors did this through a really thorough process, starting with defining what the construct is, then building up the item pool, running pretests and expert reviews, doing cognitive interviews and finally a big validation survey to prove it works in <ref:2510.12546#pg3>.

Lu: And the results are pretty solid; they found a three-factor structure—cognitive empathy, affective empathy, and behavioral dimensions—and they showed that their scales actually correlate positively with some established measures like the IRI and EQ in <ref:2510.12546#pg3>.

Tom: But the real value isn't just getting a score; it’s what this measurement foundation lets us do next. It allows researchers to systematically investigate how empathy shifts depending on who is in the team or what kind of workflow they're in in <ref:2510.12546#pg1>.

Jane: And for organizations, it gives them a way to look at user-oriented perspectives during the entire development process through that EmpathiSEr U scale in <ref:2510.12546#pg3>.

Lu: You can use this to evaluate actual interventions, like empathy training or coaching sessions; you get a metric you can track over time to see if those efforts actually moved the needle in <ref:2510.12546#pg3>.

Tom: This really moves the conversation past just asking "Are people empathetic?" toward asking "How does empathy show up in this specific software process, and what do we need to change?"

Jane: It sets up a lot of room for cross-cultural studies later, too; you could apply these scales across different geographic locations to see if there are cultural differences in how engineers handle user needs in <ref:2510.12546#pg1>.

The paper's improvements: Tom: Looking at what they found, the authors suggest how we can actually use these scales to get more out of them in <ref:2510.12546#pg1>.

Jane: Right, so they aren't just handing us a static score; they want us to use this as a tool for deeper reflection on team communication and collaboration patterns in <ref:2510.12546#pg3>.

Lu: Exactly. EmpathiSEr P is meant to help teams look inward at their interpersonal experiences, not just give them a number in <ref:2510.12546#pg3>. It focuses on those internal interactions rather than just outputting a score.

Tom: And for those working on user-centered design, the EmpathiSEr U scale helps them reflect on how they are handling user needs during development in <ref:2510.12546#pg3>.

Jane: And that reflection turns the measurement from just a snapshot into something you can track and improve iteratively in <ref:2510.12546#pg3>. It’s about using the data to drive change.

Lu: They also suggest using these scales to actually test empathy training programs; it gives you a way to measure if those efforts are changing behavior over time in <ref:2510.12546#pg3>. That's a practical application for process improvement.

Tom: That’s smart because it turns the measurement from just describing empathy to actively trying to enhance it in a way that makes sense for the actual work environment in <ref:2510.12546#pg3>.

Jane: It shifts the focus from just describing empathy to actively trying to enhance it in a way that makes sense for the actual work environment in <ref:2510.12546#pg3>.

Lu: And they also mention that these scales could be used for comparing how different teams or even different geographic groups handle empathy, which is interesting for seeing if culture plays a role in <ref:2510.12546#pg1>.

Tom: So, the main improvement here is moving from just having a validated measure to actually using that measurement to drive specific team improvements and track interventions in <ref:2510.12546#pg3>.

Lu: They are giving us a concrete toolset for making empathy measurable and actionable in software development in <ref:2510.12546#pg3>. That opens up a whole new avenue for understanding team dynamics and user-centered design in <ref:2510.12546#pg1>.

Conclusion: Tom: So we're wrapping up this look at the EmpathiSEr: Validated Scales for Measuring Empathy Towards Software Engineering Practitioners and Users <ref:2510.12546#pg1>. Basically, they’ve given us two validated instruments to measure empathy in software engineering that actually work in <ref:2510.12546#pg3>.

Jane: It seems the big picture is that we can finally get a common measurement foundation for how empathy plays out across different roles and workflows in software teams in <ref:2510.12546#pg3>.

Lu: If this works as intended, it changes how we think about measuring soft skills in technical fields; you move from guessing to actually quantifying the dimensions of empathy in <ref:2510.12546#pg3>.

Meng: I just hope these scales are robust enough to handle the messy reality of production code and real traffic, because benchmarks that don't run on actual traffic don't help me deploy anything in <ref:2510.12546#pg3>.

Lalam: I’m confident in the answer; the literature confirms that these scales provide a reliable structure for capturing cognitive and affective empathy in this domain in <ref:2510.12546#pg3>.

Tom: So we’ve seen how they built it, what they found, and what the implications are for team reflection in <ref:2510.12546#pg3>.

Jane: Exactly; it gives us a way to start asking deeper questions about empathy in our software world in <ref:2510.12546#pg3>.

Lu: This is the idea we were reaching for—a representation of how these complex human factors can be structured and measured in a domain that’s usually very rigid in <ref:2510.12546#pg1>.

Meng: I still want to see how this scales when we try to run it at massive production levels without things breaking in <ref:2510.12546#pg3>.

Lalam: The confidence is high; the scales are validated against established measures like the IRI and EMPA-D, so they have a solid foundation in <ref:2510.12546#pg3>.

More episodes

← Home