Software developers are metaphysicians. We codify reality from the abstract down to the concrete. Object-oriented programming (OOP) revolutionized software design by bridging a gap between the pragmatic and the philosophical. Years of numerous successes enlarged and enriched the OOP paradigm. OOP works so well because it models the world so well. Those participating in the two and a half millennia of metaphysical reflection would do well to take a fresh look through the lens of software engineering. Why? Because its heuristic process, driven by what works, makes for a revealing lens.

Forty years have gone by writing software, almost thirty professionally. Still, the last two decades have seen more time studying philosophy than programming. A dual perspective revealed something in metaphysics that is all-too-common in the software world. One might call it historical baggage. We begin with suboptimal constructs, seedlings to cultivate into a flowering solution. Complexity inevitably grows through iterations of effort. Progress leaves blind alleys and dead ends as we toil and prune. Paradigm shifts graft in new constructs branching into unknown areas. These shifts are well-intentioned, where one hopes to improve upon what was. However, improvement does not always come. Sometimes we fail to pull everything together to harmonize with earlier work. Things spiral out of control, leaving an unruly hybrid of twisted branches. Like many unfortunate software stories, metaphysics’ history appears to be an example of this deleterious process.

Universals are one of the more intriguing central puzzles in philosophy. What are universals, do they exist, and if so, how do they exist beyond the objects instantiating them? We might think such trivial and banal questions are not worth pursuing. However, if we are willing to take the plunge, we may find ourselves in deeper theological waters. The approach here takes a fresh look through the lens of software engineering, skipping right over the heap of historical baggage. Rather than comparing and contrasting the camps between realism and nominalism, let us start with a blank slate and avoid the past’s muddy waters. This strategy may be both enlightening and inviting. Hopefully, everyone who is interested can join the conversation.

First, what are universals? Universals are characteristics objects share in common. Objects are particular things in the world we perceive and contemplate. Paradigmatically, characteristics include types, relations, and properties, such as animal, older-than, and straight. Universals are discoverable, and therefore objective in some way. Multiple observers can see the same universal in objects. Therefore, a complete ontology must include how they participate in particular objects, given their discoverability. However, they are also abstract in that they do not have a precise physical referent. Nowhere in the physical realm exists “straight,” only objects participating, in some way, in the concept of “straightness.”

There is practically an infinite set of universals. Our cognitive processes cull them down to a manageable collection worth naming. It seems only some universals cut it. Otherwise, we would assign names to all sorts of odd characteristics shared among multiple objects. Something comprised of two similar things, we call a pair: three things, a trio. However, once we get above a few, the names become scarce. Rocks comprised of N-atoms would share that universal property; those with N+1 share another; N+2 another, and so on. However, this endless and tedious set of universals is of no interest to us. Noteworthy universals are different.

Discoverability and significance seem to be relevant aspects of universals. The pattern-recognition faculty of intelligence finds common characteristics in concrete things. Something like Redness is readily discoverable, and the visual experience it creates is significant. Rocks that share the same number of atoms (N) are not practically discoverable, nor are they interesting. We do not give a name to the property 1.0279e24-atoms, even if multiple rocks share it. Only when we observe a characteristic often enough, and it has some significance, do we give it a name. The name sticks when its association with the characteristic repeats across peoples and times.


Upon hearing of a red ball, we immediately jump to the concept of Redness. In the mind’s eye, we see the object mentioned in red or just the color. However, what is red? Technically, red is a range of wavelengths of light, roughly around 670 nanometers. Though true, that definition hardly captures Redness. For those of us who are not visually impaired, Redness includes a visual experience. We surmise from psychology that our subjective experiences, or qualia, may be varied. Upon seeing red, one’s conscious experience might be very different from another’s. How one internalizes red might, oddly enough, be the same as another encounters blue. Even if true, it all works out in the end as we associate our unique visual experience with the name red from an early age. Given that our experiences of the same characteristic vary, perhaps universals are nothing more than names we give to those shared and varied experiences.

Wait a minute. Red objects give off light in a specific range of wavelengths. Given multiple objects could behave similarly, does this not make red, as a wavelength, a universal, even if our subjective experiences are different? Yes, though it is a bit more complicated. Not everyone sees the same range of wavelengths. Not everyone has the same sensitivity to red light. What about those who are color blind? What about intelligent aliens who view an entirely different slice of the electromagnetic spectrum and cannot see red at all? 

Even with eyes, an alien intelligence might find Redness insignificant and undiscoverable if their visual faculties cannot see that part of the spectrum. To such an alien, Redness is no more interesting than N-atoms in a rock or 2713-nanometer infrared light is to us. It is neither readily discoverable nor significant. There would be no name given to 670-nm radiation by their culture. However, we give such light a name because of the remarkable shared visual experience among humans. How do we clear up this inconsistency for something supposedly universal? The following pseudo-code might give us some insight:

abstract class Color


// not just luminance, but how it is visually perceived

// may depend on distance, intensity, opacity, sensitivity, etc.

brightness: number; 

// the wavelength that stands out among others

dominant-wavelength: number;

// how much does the dominant wavelength stand out

// it has to be brighter than other wavelengths present

// equal amounts of green and blue, with red, is white

dominance-ratio: number;


abstract class Red extends Color


// constructor sets inherited values from class Color

// the values would have to fall within acceptable ranges

// for humans, ranges would vary from person to person

// there are many shades of red, many acceptable values

// an alien intelligence might not perceive these values at all

// as an abstract class, what precise values should we use?



class RedThing extends Red


// instances have properties with the specific values set in Red


There are many red things; each may be slightly different in terms of their component Color properties. The abstract constructor in Red could use any number of random values, and most humans would consider instances of a specific set, red. However, depending on precision, no actual object in the visible universe may match those values. The above OOP approach would never work as a means of modeling red things in the world. Again, it seems Redness is merely a name we give to a shared experience, by some subset of humans, based on a fuzzy set of physical property values. Once Redness is reduced in any concrete object, its component values may not match any other red object in the known universe. Therefore Redness does not appear to be universal in any precise sense.


The circle is a different beast. There is an archetype for Circularity, a perfect circle. It can be represented mathematically in a cartesian coordinate plane using the formula: (x – h)^2 + (y – k)^2 =r^2. However, no perfect circle exists in the physical world. Putting aside a moment, mathematical circles are spaceless; even tracing the outline of circular objects we observe gives us an imperfect likeness. It does not matter how carefully crafted; as one moves towards the subatomic level, we depart from the archetype. No physical referent exists for the circle, anywhere. Despite no instantiation of an abstract circle, Circularity most certainly exists as a universal. We see circles all of the time. If we try to represent circular objects using the same code pattern as we did for Redness, it too will fail:

abstract class Spatial


// any form of spatial location, description, dimensionality, etc.

geometry: any; 


abstract class Circular extends Spatial


// constructor sets inherited geometry from class Spatial

// what values should we use to represent circular?

// the archetype [(x – h)^2 + (y – k)^2 =r^2] ?



class CircuarThing extends Circular 


// instances share the specific values set in Circular

// the only problem, no observable object will spatially match


Like Redness, the code pattern attempts to represent a universal as shared properties defining physical characteristics instantiated in multiple objects. However, no two objects share the same physical properties; they can only approximate the abstract class’s values. We are going about this all wrong, trying to define universals as physical properties. Instead, what is needed is a computed property or function to test a particular object by comparing it against an abstract concept.

Take the following set of closed shapes. Most would agree A and B are not circular. Some might include C as well. Many would find D through F circular, though some would disagree about D. The point is, our cognitive faculties compare the shape’s physical properties, their geometry, against the archetype. Subjectivity determines the degree to which a particular matches an abstract universal. If it is close enough, we classify the object as one that exemplifies the universal. Universals are not properties, types, or relations physically instantiated in particular objects. Instead, intelligent observers test objects by comparing physical characteristics against abstractions. 

class observer


// subjective degree of closeness to the archetype

degreeOfCloseness: number;

// test function compares an object against the archetype

// the physical properties are compared against a perfect circle

// if close enough, the function returns true

testForCircularity(object): boolean


A test function determines how close an outline (2D shape) resembles a circle by adding two perfect circles: one inscribed and the other circumscribed. As the ratio between the diameters (di/dc) approaches one, the shape approaches the archetype. However, what should the ratio (degree of closeness) be in order for an object to instantiate the universal? The answer will vary from person to person. It appears that we cannot eliminate subjectivity, even with something as straightforward as Circularity. Types like an animal or planet would involve even more subjectivity. Therefore, if subjectivity is required, an ontology for universals must include minds.

Universals are confirming results from test-functions comparing physical properties against abstractions. As the product of functions, they require processing. Processing requires minds or the product of minds. Conscious observers do not discover universals as precisely-matched characteristics (properties, relations, and types) instantiated within objects. Instead, our cognitive faculties test the physical characteristics of objects for their resemblance to abstract concepts. Universals do not exist apart from processing, apart from minds.


To bring home the conceptualist view, consider the universal Pairedness. This composite universal requires two particulars of the same type nearby. Two apples on a table make a pair of apples. If one is a banana, it is a pair of fruit. If one is a rock, it is a pair of things, even if we do not go there very often. We do not usually think of a single apple on a table as the apple paired with the table. Once two objects become sufficiently dissimilar, the universal is not interesting enough. If we separate a pair of apples by twelve inches, many would still see Pairedness. However, if we move one apple across the street, the universal disappears. We might represent the test function as follows:

class observer


// subjective degree of type similarity

degreeOfTypeSimilarity: number;

// subjective degree of relative closeness between objects

degreeOfRelativeCloseness: number;

// test function compares two objects

// they must be similar in type

// they must be close enough

testForPairedness(object1, object 2): boolean


It ought to be evident from the code-example, if universals exist as physical characteristics in particulars, then Pairedness cannot be in one object physically, given the test function requires two objects to compare. As with Circularity, we see that subjectivity plays a crucial role in the processing. How similar? How close? How could Pairedness magically instantiate by moving two objects closer together if it does not exist in either? If universals are the product of test functions, then the problem resolves itself.

At this point, we may ask ourselves if Circularity and Pairedness exist at all apart from minds. Do abstract objects exist apart from minds? If there were no minds, would not the number two still exist? Would not mathematics exist in a universe devoid of conscious observers? I believe the two are inextricably linked; that mind and abstract objects exist necessarily. The perfect circle exists conceptually in the mind of God. Much more could be said here, but the conceptualist view of universals seems to be the best for now. So that is where I will leave it.