Advancing Evidence-Based Social Sustainability in Software Engineering: A Research Roadmap
This paper addresses the lack of clear foundations for social sustainability in software engineering by reviewing existing definitions, analyzing key aspects and challenges, and proposing a comprehensive definition alongside a research roadmap for measuring and integrating social sustainability into software development processes.
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 software engineering as the construction of a massive, global city. For decades, the architects (software engineers) have been obsessed with one thing: making sure the buildings don't fall down, the electricity works, and the doors lock securely. They measure success by how fast the elevators go and how much steel they use.
But this paper argues that we've been ignoring the most important part of city planning: how the city actually feels to live in.
Here is the paper, "Advancing Evidence-Based Social Sustainability in Software Engineering," explained in simple terms with some analogies.
1. The Problem: We Built a City, But Forgot the People
Right now, software companies focus on speed and profit. They ask, "Does the app work?" but rarely ask, "Does this app make people's lives better, or does it hurt them?"
- The Analogy: Imagine a bakery that makes the fastest, most delicious bread in the world. But, to make it, they use flour that makes the workers sick, and they sell it only to rich people while the poor starve. The bread is "technically" perfect, but the business is socially unsustainable.
- The Reality: Software can be fast and secure but still be racist, exclude people with disabilities, burn out developers, or tear communities apart. This paper says we need to stop ignoring these human costs.
2. The Big Confusion: What Does "Social Sustainability" Even Mean?
The authors noticed that everyone uses the term "social sustainability" differently. Some people mean "good working conditions for coders," while others mean "software that helps society." It's like everyone in a room trying to order "soup," but some want tomato, some want chicken, and some want a bowl of rocks.
To fix this, the authors split the concept into two clear buckets:
- Bucket A: The Product (Socially Sustainable Software)
- What it is: The actual app or website you use.
- The Goal: Does it treat everyone fairly? Does it protect your privacy? Does it bring communities together or tear them apart?
- The Definition: A system that serves everyone equally, respects your dignity, and doesn't push its bad side effects onto poor people or future generations.
- Bucket B: The Process (Socially Sustainable Development)
- What it is: How the software is built.
- The Goal: Are the people building the software treated well? Do they have a say in decisions? Are they overworked and stressed?
- The Definition: A process where developers are treated with dignity, have a voice, and aren't burned out to make a profit.
3. The Hard Part: How Do You Measure "Kindness"?
This is the trickiest part.
- Environmental sustainability is easy to measure: You can put a meter on a server to see how much electricity it uses.
- Technical sustainability is easy to measure: You can count how many bugs exist.
- Social sustainability is like trying to measure "happiness" or "fairness" with a ruler. You can't see it directly.
Why is it hard?
- Context is King: What feels "fair" in one culture might feel "rude" in another. A measurement tool that works in Canada might fail in Brazil.
- Levels of Impact: An app might make a team of developers happy (good for the team) but cause a community to lose their jobs (bad for society). You have to look at all levels at once.
- It's Abstract: How do you put a number on "dignity" or "community cohesion"?
4. The Roadmap: How Do We Fix This?
The authors propose a four-step plan to turn this from a "nice idea" into a real science.
Step 1: Create "Social Fixes" (Interventions)
We need to stop just talking and start trying things.
- The Analogy: Instead of just saying "we should be nice," we need to install "speed bumps" in the development process.
- Examples:
- Training: Teaching developers to think like their users (empathy training).
- Nudges: Putting a warning sign on the screen that says, "Hey, this feature might exclude people with slow internet," so the developer thinks twice.
- Checklists: Adding a "Social Impact Check" to the to-do list before a new feature is built.
Step 2: Build a Measurement Toolkit
We need a standard "ruler" for social health.
- Currently, we don't have one. The authors suggest creating specific scores for things like "How inclusive is this?" or "How much does this hurt the community?"
- We need to combine numbers (surveys) with stories (interviews) to get the full picture.
Step 3: Run Real Experiments
Most software research just watches people code in a lab. This paper says we need to do real experiments.
- The Challenge: It's hard to get real companies to let researchers mess with their projects.
- The Solution: Use "Action Research." This means working inside a real company, trying a new method, seeing if it helps, and fixing it if it doesn't. It's like a doctor testing a new treatment on a patient, rather than just reading about it in a textbook.
Step 4: Team Up with Everyone Else
Software engineers can't do this alone. They need help from sociologists, psychologists, and ethicists.
- The Analogy: You wouldn't ask a plumber to design a heart surgery. Similarly, you shouldn't ask a coder to solve complex social problems without help from social scientists.
- We also need to study these things over years, not just weeks, because social changes take a long time to show up.
The Bottom Line
This paper is a wake-up call. It says: "Software isn't just code; it's a social force."
If we want a future where technology helps everyone rather than hurting the vulnerable, we need to treat social sustainability with the same scientific rigor we treat speed and security. We need to define it clearly, measure it honestly, and test our solutions in the real world.
In short: Let's stop building software that just works, and start building software that matters.
Drowning in papers in your field?
Get daily digests of the most novel papers matching your research keywords — with technical summaries, in your language.