Goblin on Nom-Nom-Nominalism

Deliciousness, and Other Properties

I got my degree in software engineering from Oregon Institute of Technology back in 2005.

I sometimes joke that my favorite philosophy classes were the programming classes.

Except I’m not joking!

Many of the concepts to which I was introduced through programming classes had a major prophylactic effect on my so-called philosophical intuition, priming me with deep suspicions about language — the non-programming kind — that Wittgenstein would validate when I read Philosophical Investigations for the first time a few years later.

In object-oriented programming (or “OOP”), for example, you get to define your own classes of objects. If you’re programming a roleplaying game, you can invent an object “Goblin” and decide what properties it has — Hair Color, Strength, Maximum Health, Current Health, and so forth.

You can also decide what it does. You can create a function (called a “method”) that reacts to emoting actions the player performs, e.g., if the Goblin receives an angry emoting action from the player, you can have the Goblin strike the player, whereas if it receives a courteous emoting action from the player, you can… well, you can have the Goblin strike the player then, too.

You could also make it so the result of the React function depends on a property of the Goblin, like its Courage property, where an angry emoting action prompts the Goblin’s submission if their Courage is rather low.

All of these contingent actions can be programmed as things the Goblin does and under what conditions, defined within the Goblin class.

But you don’t have to set it up this way.

Instead of a React function, you can just generate a list of pairs of emoting actions and reactions, e.g.:

• {“Angry”, “Strike”},

• {“Courteous”, “Strike”}

Or a list of emoting actions, conditional expressions, and reactions, e.g.:

• {“Angry”, “Courage <= 10”, “Submit”}

• {“Angry”, “Courage > 10”, “Strike”}

• {“Courteous”, “Amity <= 12”, “Strike”}

• {“Courteous”, “Amity > 12”, “Cooperate”}

Now, instead of having the Goblin do these things himself, these are now just properties of the Goblin.

Then you can have a function external to the Goblin class that determines reactions by looking at a particular Goblin’s properties and prompting the Goblin to do something by virtue of his properties and what emoting action the player performed.

Isn’t that weird?

You can reframe what he does in terms of what he is and get the exact same functionality in the end.

Now let’s chew on something else: A game where we have Characters (Irma, Janice, Kyle) and various Fruits (Banana, Strawberry, Durian) for them to try.

We could store their preferences as features of the world in an array of contingencies:

• {“Irma”, “Banana”, “Yum”}

• {“Irma”, “Strawberry”, “Yum”}

• {“Irma”, “Durian”, “Yuck”}

• {“Janice”, “Banana”, “Yum”}

• {“Janice”, “Strawberry”, “Yuck”}

• {“Janice”, “Durian”, “Yuck”}

• {“Kyle”, “Banana”, “Yuck”}

• {“Kyle”, “Strawberry”, “Yuck”}

• {“Kyle”, “Durian”, “Yum”}

Or, we could call these properties of the Characters, where Irma contains {“Banana”, “Yum}, {“Strawberry”, “Yum”}, and {“Durian”, “Yuck”}, and Janice contains {“Banana”, “Yum}, {“Strawberry”, “Yuck”}, and {“Durian”, “Yuck”}, and Kyle contains {“Banana”, “Yuck}, {“Strawberry”, “Yuck”}, and {“Durian”, “Yum”}.

Or, we could call these properties of the Fruits, where Banana contains {“Irma”, “Yum”}, {“Janice”, “Yum”}, and {“Kyle”, “Yuck”}, and Strawberry contains {“Irma”, “Yum”}, {“Janice”, “Yuck”}, and {“Kyle”, “Yuck”}, and Durian contains {“Irma”, “Yuck”}, {“Janice”, “Yuck”}, and {“Kyle”, “Yum”}.

Or, we could just make it so a Character has a Sampling function which is overridden with different reactions depending on which Fruit is passed to it.

Or, we could just make it so a Fruit has a Sampled function which is overridden with different reactions depending on which Character is eating it.

Many scrumptious options.

And they all do the exact same thing. It’s just a matter of how we wish to organize our hypotheticals.

We opt in to how we’d like to express an array of contingencies that, when we look at it from the bird’s eye vantage point, are clearly both Character-dependent and Fruit-dependent.

If we opt to organize those contingencies in a way by which a Character is granted but the Fruit is tested, then we pass the Character to a Fruit, who sees who’s tasting and triggers the appropriate response (Yum or Yuck).

If instead we opt to organize those contingencies in a way by which a Fruit is granted but the Character is tested, then we pass the Fruit to a Character, who reacts according to their taste (Yum or Yuck).

And now we’re ready to ask ourselves some questions about the real stuff instead of simulated stuff:

• Is “delicious” a property of a strawberry?

• Is “beautiful” a property of the Sonoran Desert?

• Is “hilarious” a property of Tim Heidecker?

• Is “what it means” a property of a sentence?

• Is either “morally impermissible” or “permissible” a property of swatting a housefly?

Food for thought!

https://twitter.com/StanRockPatton

https://www.youtube.com/@pattonpatterns