c# theology: How clearly can we explain what we are saying about God?

Logic is a useful tool, and originally a branch of philosophy. Then computers were invented, and over the years logical languages became far more specialized than their ancestors that were used in basic syllogisms. With the advent of object-oriented programming (OOP), logical languages made enormous gains in their ability to model the real world. But has computer programming, the now-grown independent child, ever returned the favor to philosophy to see how much the more advanced logical tools can help clarify philosophical problems?

For example, someone once used the question "What is a chair?" to explain to me just how complex a thing can be. Roughly their side of the conversation ran like: "A chair is a noun, isn't it? And yet, if you change all kinds of things about it, is it still a chair? Can't we take two very different things (maybe a squashy recliner for one, and an uncomfortable hard plastic stackable armless seat for another) and say they are both chairs? So what can we really say about chairs?" And I thought to myself, quietly, "The effort we put into outsmarting ourselves!" I was very young at the time so simply filed away the example in my mind; these days I suspect they simply didn't possess the right analytical tools. Because from an OOP point-of-view you could argue that "chair" is an interface -- roughly a set of certain predefined requirements, in this case mainly the ability for one person to sit on it -- that is implemented by any number of specific chairs. Or you could argue that "chair" is a function that returns a specific object that can be used as a chair. There are probably other options for how we model our thoughts about what "chair" means. But we don't want to confuse "slightly complex" with "ineffable".

On Trinity Sunday, I often come to the question: How clearly can we explain what we are saying about God? And it's hard to know where to start. For example, what if I start here:

public class God
{
    // what it means to be God
}

We run into open questions immediately. What does it mean to be God? In the Athanasian creed, the content of what it means to be God would be filled in along the lines of "uncreated, infinite, eternal." In the Nicene creed, it would be filled more along the lines of "Father Almighty, creator". In various parts of Scripture we'd also see holy, wise, compassionate, merciful, slow to anger, abounding in steadfast love (or simply "love"). For today I'm fine with leaving "what it means to be God" as an open question; we'd hardly settle it in the course of a post anyway.

But then on Trinity Sunday here, there's more to say. So what if we sketch out:

public class Word : God
{
    // class Word is from class God
    public purpose Speak(person[])
        {
        // do something
        }
}

For those who don't code for a living or use other languages to code, I'll mention: the above says that Word inherits from God, so that everything God is, the Word is also. And I've sketched in one method (action) that belongs to "Word": the Word can Speak. The Word speaks to one or more persons; we haven't defined persons yet but pseudo-coding theology is not a small project and we have to start somewhere. I'm not sure that putting "purpose" in the return value is the best construction for Speak() but I certainly didn't want to pseudo-code it that Speak returns void. (Yes, there's a coder-theology-geek pun in there, but might be on the obscure side.) At any rate, while it's open to a more fully-developed model, it will do for the first draft -- with the understanding that it's not done yet, and wouldn't even pass a programmer's logical syntax-check at this early stage. Most code starts that way.

And while there are some points I'd like to discuss on that, it might help to bring the Holy Spirit into the discussion (in more ways that one!)

public class Spirit: God
{
    // class Spirit is from class God in the most ancient constructions
    public childOfGod Indwell(this, person)
        {
        // do something
        }
}

Again, that says that everything God is, the Spirit is also. And I've so far described one action of the Spirit, which is Indwell, an action which requires both the Spirit (this) and a person, and returns a childOfGod (again not even defined yet).

Now the number of things incomplete about this is fairly mind-boggling. If any reader feels the need to say so, you'll have my full agreement. But it opens up for us to have more exact discussions over our questions about God. Because the above is not the only possible arrangement; far from it. For example:

Which methods (actions) really belong to the child classes, and which to God as the originator? Is the Word of God more like a class, or more like an interface (having all the properties of God but not an independent class)? How about the Spirit of God: class or interface?

I know, some will find this hopelessly ... unhelpful (at best). But I hope that what it lacks in refinement, it makes up for in possibility.