Those who have dabbled with machine-learning are familiar with bayesian inference - essentially, if X and Y are found to occur together, then X and Y are probably related. The fact that I have 10k spam emails and 0 real emails with "v14gr4" in the subject probably indicates that the next email with "v14gr4" in the subject is also spam.
But what if it turns out that I really am friends with the prince of Nigeria, and he really does want to give me forty million dollars in exchange for letting him use my bank account?
In order for us to evaluate this possibility, we need to know the probability distribution. There are far more people who pretend to be the prince of Nigeria than there actually are princes of Nigeria (there are, in fact, no princes of Nigeria). Therefore, we can make a pretty good guess that any email claiming to be from a prince is a scam. But how frequently are there chairs masquerading as rocks?
We might argue:
1. Things tend to look like what they are
2. This looks like a chair
3. Therefore this probably is a chair
But premise (1) here is unsupported - we have no idea how frequently things tend to look like what they are.
What we do instead is to talk about the abstraction layer - the interface of the chair, if you will (abstraction layers are referred to as universals in philosophy). We change our argument to state:
1. If something looks like a chair, then it probably implements ISittable
2. This looks like a chair
3. Therefore it probably implements ISittable
I can then sit on it. We now avoid the question of what the chair actually is in a noumenal sense, but instead ask about the phenomenon (i.e. the public API vs. the private implementation). Perhaps when I sit on what I think is a chair it is really a rock, but as long as it's a comfy rock, who cares?
This is the pragmatist's resolution to our ontological problem - perhaps when I ask for a quicksort you really do a mergesort, but the important part is that you implement ISorter. So problem solved, right? Unfortunately, we have now traded in one problem for another.
I claim that all chairs implement the ISittable interface. We are left with some questions:
- What is an interface?
- Where does an interface live?
- How does one implement an interface?
- Are certain interfaces more "real" than others?
One of the most fundamental interfaces is Collection. Java specifies the following:
public interface Collection
I have one stone, then I add another stone. I now have a collection of stones. But who implemented the interface? I can see that size() = 2, and I can iterate through the stones; does this mean that I implemented the interface? But then why is it that anyone else who looks at this collection will also see that size() = 2? Is there some repository of interface implementations which we all have access to? Furthermore, why is it that not only does one stone plus one stone equals two stones, but one planet plus one planet equals two planets and so far up (and down) the scale?
There are certain propositions like "x == x" which seem to never be violated. In Java, all classes inherit from object - is there an analogous requirement for interfaces that they must implement these "a priori" assumptions? If so, how do we determine which assumptions are always true, which are sometimes true, and which are never true?
There are three basic answers to these questions:
- Interfaces are real. They exist in some realm of interfaces which we have access to through unspecified means. This is known as realism.
- Interfaces don't exist. It is only through human stupidity that we think they do. This is known as nominalism.
- Interfaces exist, but only as ideas. This is known as idealism.