My understanding of Kelley's error

With clarity, I finally understand the major error in David Kelley's approach to moral judgment. And oddly enough, the integration came from re-reading my systems analysis and design book. My goal in this post is to outline my thought process that lead to this understanding.

In systems development and design, their are different methodologies for understanding an information system. Traditionally, these have been through either data-driven methodologies and process-driven methodologies. In data-driven methodologies, analysts attempt to understand reality by identifying things (entities) that have properties. These things have specific states that may change over time, but not through any identifiable force. These things are only weakly related to other entities through relationships. In process-driven methodologies, analysts attempt to understand reality by identifying actions that must be performed. These actions refer to work that must be done, but are only weakly tied to people or data. In each of these cases, there is an implicit division between what is and what should be done. A division between consequence and motive. A division between facts and values. While it is true that these two methodologies attempt to cover both sides of data-process dichotomy, each is weak and requires an enormous amount of effort on the part of the analyst to tie them together. This effort has been manifested in my students who have attempted put them together for my class.

A similar dichotomy exists in types of programming languages. Some languages are procedural (Fortran, BASIC in its original form, C) while other languages are state-oriented (RPG, HTML, XML). While both styles of language have purpose in creating information systems, they both fall short in their ability to do so efficiently and effectively. Few people today still use a procedural or pure state-oriented languages (HTML was soon augmented with JavaScript for processing after a pages had loaded).

Today, there exists programming languages called object-oriented languages with a related analysis and design technique called Unified Modeling Language (UML) that rejects the implicit state-process dichotomy. Object-oriented programming emerged back in the 70s with the invention of SmallTalk, where inventor Alan Kay explicit tried to model human thought with a programming language that focused on objects that contained both attributes and methods (measurements and actions). Objects (which are real instantiations of a class of things, just like an object in reality is an instantiation of a concept) could "inherit" attributes and methods from broader abstractions and apply them where appropriate.

In a comparison between Ayn Rand's Objectivist epistemology with object-oriented methodology, Adam Reed discovered that there are a number of striking similarities (as a warning, this article is posted on the Atlas Society's website. The irony is that Reed's article helped me to understand why Kelley is wrong). While I haven't had time to throughly compare and contrast Reed's findings with my own understanding of reality, my brief read leads me to support his basic comparison.

While there are some striking similarities, the analogy only goes so far. Procedural languages and process-oriented methodologies are not inherently better or worse than object-oriented languages and methodologies. It depends on context. Objectivism's epistemology and ethics, however, are fundamentally "better" than other philosophies because it is true in all contexts.

What was important to my understanding of Kelley's error however is that an object-oriented approach to programming is a fundamentally different way of thinking about information systems and a fundamentally different approach to logic when designing applications. You simply can not combine procedural and state-oriented languages to get object-orientation languages. Just like you cannot combine process-oriented and data-oriented methodologies to get UML. An IT friend of mine, Jeff, showed me to some code that perfectly demonstrated this fundamental mistake from a new programmer who, while programming in Java, created a class that contained over 20 nested if-statements. Although he was using object-oriented language, he was thinking in terms of procedural languages. The vast number of if-statements gave evidence of an inability to understand inheritance (abstraction in philosophic terms). By adopting the procedural mind-set he was unable to use an object-oriented language appropriately.

While re-reading Diana's post about Kelley introducing the mind-body dichotomy into his analysis of moral judgment, I thought about this new programmer. Kelley, by starting with the mind-body dichotomy became stuck in that mind set and could not reconcile it with Objectivism, no matter how much fancy foot-work he attempted. This is what leads Kelley to reject the fact-value relationship, embrace the mind-body dichotomy, and evaluate motive and consequences differently. As Diana shows, this is fundamentally at odds with Objectivism. You can't understand Objectivist ethics if you start with the wrong mind-set, in his case from the mind-body dichotomy.