PR #2: Should I Care About Animal Suffering?

I always wonder about why I should even care about animals suffering. I mean they don’t really add any value to my life, do they?

Let me try and put this into code to see if it helps me figure out if I should care about them.

Welcome to the Party!

// Every Party has some details about who they are
type Party = {
  name: string;
  species: string;
  whereTheyAre: string;
  addsValueToMyLife: boolean; // do they directly add value to my life or will helping them benefit me in some way?
  isConscious: boolean; // is there someone "in there"?
  feelsPain: boolean;
  myActionsContribute: boolean; // do my actions directly contribute to their suffering?
};

const homelessPeople: Party = {
  name: "homeless people",
  species: "human",
  whereTheyAre: "the street outside",
  // ...
};

const warRefugees: Party = {
  name: "war refugees",
  species: "human",
  whereTheyAre: "some camp miles away",
  // ...
};

const strayKittens: Party = {
  name: "stray kittens",
  species: "cat",
  whereTheyAre: "the street outside",
  // ...
};

const petCats: Party = {
  name: "pet cats",
  species: "cat",
  whereTheyAre: "in my flat",
  // ...
};

const farmAnimals: Party = {
  name: "farm animals",
  species: "pig, cow, chicken",
  whereTheyAre: "a cramped warehouse",
  // ...
};

Here are five groups that are all different in terms of species, location, and whether they add value to my life.

The empathy function

Let’s start with who I already care about or who I give moral consideration to. My heart goes out to people like the homeless and war refugees (not that it means much to them) and I would love for their suffering to be alleviated. I can say that I do care about them, but let me try and put it into a function to see if I can capture the pattern.

// I care about a party if they are human, conscious, and can feel pain
const empathy = (party: Party): boolean =>
  party.species === "human" &&
  party.isConscious &&
  party.feelsPain;

empathy(homelessPeople); // true
empathy(warRefugees);    // true

Here’s my empathy function. Note that it doesn’t matter if the addsValueToMyLife property is true or false, or where the party is located. All that matters is if they are human, conscious, and can feel pain.

Wait a second, this doesn’t seem right. I care about some animals too, like my cat and stray kittens. So the function is missing something.

Bugfix: Cats!

empathy(petCats); // false 🐛

What?! According to my function, I don’t care about my pet cat Aloo, my beautiful boy! Need to fix that part!

empathy(strayKittens); // false 🐛

And I couldn’t watch a stray kitten suffer without wanting to help in some way as well. I would still feel empathy for them, even if they aren’t human.

So which checks are failing? Both cats are conscious and both feel pain, so it’s not those.

They both only fail species === "human". So I should remove the species check from my empathy function. Cause I mean would any trait really make a case for denying someone moral consideration based on species?

Refactor v2

// v2: I care about a party if someone's in there, and they can be hurt
const empathy = (party: Party): boolean =>
  party.isConscious && party.feelsPain;

species check gone. Let’s run every party through v2:

empathy(homelessPeople); // true
empathy(warRefugees);    // true
empathy(strayKittens);   // true ✅
empathy(petCats);        // true ✅
empathy(farmAnimals);    // true

All passing now, and it looks correct to me! I guess I don’t need to check species, whereTheyAre or addsValueToMyLife. The thing kittens, homeless people and refugees all have in common is that they’re conscious and feel pain. And so do cows, chickens, and pigs.

(If you’re wondering where that line stops, I’ve covered plants, fish, and bivalves separately.)

What’s in it for me?

homelessPeople.addsValueToMyLife; // false
warRefugees.addsValueToMyLife;    // false
strayKittens.addsValueToMyLife;   // false
petCats.addsValueToMyLife;        // true
farmAnimals.addsValueToMyLife;    // false

Being so for real here, most of these parties don’t add any direct value to my life. I’ll probably never interact with any of these groups and they won’t directly affect my day-to-day life.

My cat Aloo is the exception. He doesn’t do anything practical for me, but he gives me a type of emotional comfort, so he definitely adds value to my life.

Now put him next to a stray kitten. If I was walking by someone kicking a stray kitten for fun, I’d hope I would step in to prevent this, the same as I would for Aloo. One adds value to my life and the other doesn’t, but I care about both. That’s why addsValueToMyLife doesn’t factor into the empathy function.

Burning building

“So you think a refugee is the same as a cat or a chicken? That’s what your empathy function is saying!” So is there a merge conflict here? The priority says I don’t value everyone equally whereas empathy says they all count. Can both be true?

I think they can, but let me double check. We can run these parties through a different function to see if they have equivalent priority in terms of who I would save in an emergency.

Let’s code the classic thought experiment. The building’s on fire and for some reason there is one member from each of two parties trapped inside. I can only save one. Who do I save?

For this one, I’m adding my wife into the mix (she was thrilled to be a part of this thought experiment).

For this case an Individual has the same structure as a Party and can be evaluated using the same priority function. memberOf just picks one member out of a party.

// One member of a party, with the same structure as a Party
type Individual = Party;

// Pick one member out of a party
const memberOf = (party: Party): Individual => ({
  ...party,
  name: "one of the " + party.name,
});

const myWife: Individual = {
  name: "my wife", species: "human",
  whereTheyAre: "our flat", addsValueToMyLife: true,
  isConscious: true, feelsPain: true,
  myActionsContribute: false,
};

// Humans first, then whoever adds value to my life
const priority = (entity: Party | Individual): number =>
  (entity.species === "human" ? 2 : 0) + (entity.addsValueToMyLife ? 1 : 0);

// I can only save one
const save = (a: Party | Individual, b: Party | Individual): Party | Individual => {
  if (priority(a) === priority(b)) {
    return Math.random() < 0.5 ? a : b; // coin flip
  }
  return priority(a) > priority(b) ? a : b;
};

Every entity gets a priority score. Humans get 2 points (cause of course I would save them over animals) and anyone who adds value to my life gets 1 more (cause I’m selfish). Whoever has the higher score gets saved. So my wife comes before any stranger, refugees come before Aloo, and Aloo comes before the strays. You know I can’t very well pick between homeless people and war refugees, so it’s a coin flip.

// Only if I didn't care about them at all
const hasRightToThrowIn = (entity: Party | Individual): boolean => !empathy(entity);

I added hasRightToThrowIn to check whether not saving someone means I don’t care about them, and so can justify throwing them into the fire. Notice that it doesn’t use priority at all. How highly I rank someone has nothing to do with whether I’m allowed to hurt them.

Pick who’s trapped and run it. Try the ties a few times.

1// ...Party, the parties and empathy from above2 3// One member of a party, with the same structure as a Party4type Individual = Party;5 6// Pick one member out of a party7const memberOf = (party: Party): Individual => ({8...party,9name: "one of the " + party.name,10});11 12const myWife: Individual = {13name: "my wife", species: "human",14whereTheyAre: "our flat", addsValueToMyLife: true,15isConscious: true, feelsPain: true,16myActionsContribute: false,17};18 19// Humans first, then whoever adds value to my life20const priority = (entity: Party | Individual): number =>21(entity.species === "human" ? 2 : 0) + (entity.addsValueToMyLife ? 1 : 0);22 23// I can only save one24const save = (a: Party | Individual, b: Party | Individual): Party | Individual => {25if (priority(a) === priority(b)) {26return Math.random() < 0.5 ? a : b; // coin flip27}28return priority(a) > priority(b) ? a : b;29};30 31// Only if I didn't care about them at all32const hasRightToThrowIn = (entity: Party | Individual): boolean => !empathy(entity);33 34const a: Party | Individual = myWife;35const b: Party | Individual = memberOf(homelessPeople);36const saved = save(a, b);37const other = saved === a ? b : a;38 39console.log("Trapped inside: " + a.name + " and " + b.name);40console.log("Same priority? " + (priority(a) === priority(b)));41console.log("I save: " + saved.name);42console.log("Gives me the right to throw " + other.name + " into the fire? " + hasRightToThrowIn(other));

After experimenting we can see that yes, of course I will save any human first. Even though Aloo adds value to my life, if it’s him against a human, I’ll save the human (just know that I would live with sadness forever after that point!). So species does matter to me, but only for who I save first, not for whether they count.

After that I would save the animal that adds value to my life (again cause I’m selfish), so Aloo over a random stray cat or a farm animal.

However, even though I would save my wife over a stranger, it doesn’t mean that I don’t care about the stranger at all. I wouldn’t then think to myself that because I don’t value them as highly, I have the right (or would even want) to throw them into the fire.

I go into this in more detail in Anthropocentrism vs Sentientism.

Am I part of the problem?

homelessPeople.myActionsContribute; // false
warRefugees.myActionsContribute;    // false
strayKittens.myActionsContribute;   // false
petCats.myActionsContribute;        // false
farmAnimals.myActionsContribute;    // true

I didn’t make anyone homeless, I didn’t start a war, and I didn’t dump any kittens in an alley. I still care about them, even though none of it is my fault.

Farm animals are the odd one out. Every time I buy meat, I’m paying for the breeding, raising (in terrible conditions), and slaughtering of these animals. I am directly contributing to their suffering. Therefore, if I care about their suffering, shouldn’t I at the very least stop contributing to it?

Run it

Pick a party and run it. Then try the others.

1type Party = {2name: string;3species: string;4whereTheyAre: string;5addsValueToMyLife: boolean;6isConscious: boolean;7feelsPain: boolean;8myActionsContribute: boolean; // do my actions directly contribute to their suffering?9};10 11const homelessPeople: Party = {12name: "homeless people", species: "human",13whereTheyAre: "the street outside", addsValueToMyLife: false,14isConscious: true, feelsPain: true,15myActionsContribute: false,16};17 18const warRefugees: Party = {19name: "war refugees", species: "human",20whereTheyAre: "some camp miles away", addsValueToMyLife: false,21isConscious: true, feelsPain: true,22myActionsContribute: false,23};24 25const strayKittens: Party = {26name: "stray kittens", species: "cat",27whereTheyAre: "the street outside", addsValueToMyLife: false,28isConscious: true, feelsPain: true,29myActionsContribute: false,30};31 32const petCats: Party = {33name: "pet cats", species: "cat",34whereTheyAre: "in my flat", addsValueToMyLife: true,35isConscious: true, feelsPain: true,36myActionsContribute: false,37};38 39const farmAnimals: Party = {40name: "farm animals", species: "pig, cow, chicken",41whereTheyAre: "a cramped warehouse", addsValueToMyLife: false,42isConscious: true, feelsPain: true,43myActionsContribute: true,44};45 46const empathy = (party: Party): boolean =>47party.isConscious && party.feelsPain;48 49const party: Party = homelessPeople;50 51console.log("Who? " + party.name);52console.log("Species: " + party.species);53console.log("Where: " + party.whereTheyAre);54console.log("Adds value to my life? " + party.addsValueToMyLife);55console.log("Is conscious? " + party.isConscious);56console.log("Feels pain? " + party.feelsPain);57console.log("Do I care? " + empathy(party));58console.log("Do my actions directly contribute to their suffering? " + party.myActionsContribute);

We can see that with every party, no matter the name, species, or whereTheyAre, I care about each of them because they’re all conscious and can feel pain. I don’t value them all the same, and the burning building experiment shows that.

The thing is, none of my actions directly contribute to the suffering of the other parties. The only party I’m actively harming is farm animals, every time I eat meat. So if animals deserve my moral consideration, and I don’t need to eat them, doesn’t that mean I have to be vegan?!

Farm animals get left behind in the burning building nearly every time. But eating them isn’t failing to save them. It’s throwing them into the fire.

I would love to be able to go back to eating meat without feeling guilty. So if you can find a bug that gives me the right to throw them in, please send it over!