Teaching Empathy in Software Engineering Education in the Age of Artificial Intelligence
This study identifies five key categories of teaching practices that integrate empathy into software engineering education, demonstrating how educators can embed considerations of bias, accessibility, and societal impact directly into the development of AI-enabled systems rather than treating empathy as a separate topic.
Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer
Imagine you are teaching a class of future architects. Traditionally, you'd teach them how to calculate load-bearing walls, mix concrete, and design blueprints. These are the technical skills.
But what happens if those architects build a bridge that looks beautiful but collapses because they never thought about how a wheelchair user would cross it, or how a flood might wash it away? They built a technically perfect structure that failed the people it was meant to serve.
This paper is about teaching software engineers (the architects of the digital world) to be more like empathetic community planners rather than just code calculators.
Here is the breakdown of the paper in simple terms, using some analogies to make it stick.
The Big Problem: The "Robot" Mindset
In the past, software engineering education was like a video game tutorial. You learn the rules, you beat the level, you move on. You focus on making the code work.
But today, software isn't just a game; it's AI (Artificial Intelligence). AI makes decisions that affect real people's lives—like who gets a loan, who gets hired, or how a self-driving car reacts to a pedestrian. If the "architects" (engineers) only think about the code, they might accidentally build a system that is biased, unfair, or harmful to certain groups of people.
The researchers asked: "How do we teach these engineers to care about the humans behind the code, especially when AI is involved?"
The Solution: The "Empathy Toolkit"
The researchers didn't just ask, "Do you think empathy is important?" They went to seven experienced professors from around the world (Canada, Brazil, UK, etc.) and asked them to show their lesson plans. They used a method like a card-sorting game where the professors wrote down what they actually do in class.
They found that the best teachers don't treat "empathy" as a separate subject (like a "Kindness 101" class). Instead, they bake empathy into the technical cake.
Here are the 5 Ways they found to do this, explained with analogies:
1. The "Real World" Lens (Societal Framing)
- The Old Way: "Build a database for a library."
- The New Way: "Build a database for a library, but imagine the library is in a poor neighborhood with no internet, and the users are elderly people who can't read well."
- The Analogy: It's like telling a chef, "Don't just cook a steak; cook a meal for a family that is allergic to gluten and has no money for expensive ingredients." It forces the student to think about the context before they start writing code.
2. The "Fairness Filter" (Bias & Accessibility)
- The Old Way: "Test your app to see if it crashes."
- The New Way: "Test your app to see if it crashes for a blind person using a screen reader, or if your AI hiring tool rejects resumes from people with foreign names."
- The Analogy: Imagine building a house. You don't just check if the roof leaks; you check if the door is wide enough for a wheelchair. This category teaches students to run a "Fairness Scan" on their code, looking for hidden biases before they release the product.
3. The "Guest Speaker" Strategy (Representative Users)
- The Old Way: "Guess what the user wants."
- The New Way: "Invite a blind person to class to tell you what they need," or "Use examples in your slides that show people of all races and genders, not just the same 5 guys."
- The Analogy: It's like a movie director casting the right actors. If you only cast white actors to play a story about a diverse city, the movie feels fake. This practice ensures the cast of characters in the software reflects the real world.
4. The "Role-Play" Game (Stakeholder Awareness)
- The Old Way: "You are the developer. Build it."
- The New Way: "Today, you are the developer. Tomorrow, you are the regulator. The next day, you are the person who lost their job because of your AI."
- The Analogy: It's like playing a board game where you have to switch seats and play as the other players. This helps students understand that everyone has a different perspective and that their code affects people differently depending on who they are.
5. The "Mirror" Moment (Reflection)
- The Old Way: "Submit your code. Get a grade."
- The New Way: "Before you submit, write a short note: 'Who might get hurt by this? Did I forget anyone?'"
- The Analogy: It's like a pilot doing a pre-flight checklist. But instead of checking fuel, they are checking their conscience. It forces a pause to ask, "Is this actually a good idea?"
Why This Matters
The paper concludes that we don't need to stop teaching coding. We just need to change how we teach it.
Think of it like driving a car.
- Technical Skill: Knowing how to steer, brake, and accelerate.
- Empathy: Knowing that there are pedestrians, cyclists, and other drivers who might make mistakes, and driving in a way that keeps everyone safe.
In the age of AI, the "cars" (algorithms) are driving themselves. If the engineers who built them didn't learn to "drive with empathy," the cars might crash into the wrong people.
The Bottom Line:
This study gives teachers a recipe book. It shows them that they can teach students to be human-centered engineers without sacrificing the hard technical skills. By mixing "caring" into the "coding," we prepare the next generation to build AI that helps humanity instead of hurting it.
Drowning in papers in your field?
Get daily digests of the most novel papers matching your research keywords — with technical summaries, in your language.