Computing Encounters Being, an Addendum

As soon as I finished yesterday’s post on Brian Smith’s On the Origin of Objects, I had a thought: Ahh...so THAT’s why the philosophy of computing leads to metaphysics. If your intuitions about computing are dominated by your practice of arithmetic, well, that’s calculation, and calculation is only an aspect of computing has it has evolved since World War II.

Consider the opening paragraph to the Preface of Domain-Driven Design by Eric Evans (xiv):

Leading software designers have recognized domain modeling and design as critical topics for at least 20 years, yet surprisingly little has been written about what needs to be done or how to do it. Although it has never been formulated clearly, a philosophy has emerged as an undercurrent in the object community, a philosophy I call domain-driven design.

In that paragraph the object community is not a fellowship of philosophers, it’s a bunch of computer programmers using languages such as C++ or Java and working in a style that came to be called object-oriented long before the philosophers re-coined the phrase for their own purposes.

But that’s a side-note.

What I want you to think about: “domain modeling” and “domain-driven,” about that “domain.” The point is that programs are ABOUT some world, aka the domain. Programs are written to perform some useful task, e.g. inventory control in a liquor store, simulating fluid flow around an airfoil, formatting strings of alpha-numeric characters in text documents (a word processor), moving fictional characters and objects through fictional worlds as in, e.g. video games, and so forth. To write such programs one must model the application domain: What kinds of objects, relations, and processes are in that domain? One then writes software that not only embodies that model, but also gives human users the ability to control and manipulate that model. That is, the software itself embodies, enables, translates an interaction between humans and the world.

Programming’s a very difficult job, and one that’s not often done well. There’s lots of lousy software in the world and the failure rate of custom software projects is ferocious. But that’s another side note.

So, here we have this complex and difficult task, writing software. And now Brian Cantwell Smith wants to philosophize, not about the writing of software, or even about the software itself, but about what the software does: computing, in the largest sense of the word. How can he NOT engage in metaphysics? If computing, in that largest sense (as opposed to the more restricted notion of calculation), is always about the world, then a philosophy of computing must also be a philosophy of the world.

So, it’s inevitable then that, properly engaged, a philosophy of computing must be metaphysics of the deepest sort.

Now, how do we get from that to the observation I made two months ago that reading some current philosophers seems, in places, very much like reading computerists thinking about knowledge representation? Both kinds of talk are very abstract probings about basic things, relations between them, and processes among them all. And there seems to be some kind of deep rift between these folks HERE who want to make objects the basic stuff of the world and those folks over THERE who see processes and relations as the basic stuff. What I’m wondering is whether or not, at a sufficiently abstract level, these competing views aren’t mutually interconvertible?

Enough.