[om-list] System Design

[Mark Butler]

Luke Call wrote:

> For the file format, do you mean only for export, or as the native
> repository? How would we store our whole system (eventually terabytes
> and beyond, I hope) in a text file format? Some kind of database seems
> the only way, unless I'm missing something.

My response was to your question "What causes us to require a special format
other than objects decomposed onto a database?"

The idea is to create a standard format to allow data to be imported and
exported from databases with widely different internal assumptions and
architectures.  

> Couldn't an OO model and a predicate calculus model (which I still naively see as a
> bunch of logical statements in a formal language that a computer loads,
> parses, and traverses) each represent the same things? 

Of course.  But none of the object oriented models we have discussed so far
are capable of representing very simple logical statements, such as for every
huamn being there exist exactly two biological parents, *unless* you convert
such simple sentences into a couple dozen different objects corresponding to
some sort of parse tree for the sentence.

> Listing properties & required values as a query
> definition, vs. expressing it in a formal language seem to both express
> the same concept

No they don't.  First of all, a class is *not* a query.  A class is a set with
ill defined and often unknown boundaries and composition.  Some synthetic
classes may be defined to be identical to well defined matching criteria over
the set of all objects, but most are not.  You would be very hard put to make
a query that can distinguish correctly between a dog and a cat for example.  

The only straightforward way for an automated system to identify an object as
a member of an arbitrary class is for a user to identify it as such.

Second, the properties of natural objects are not simple discrete values, but
rather are complex time varying functions.  For example, lets say we want to
describe the properties of the earth's orbit around the sun.  We need to be
able to represent at the very least, a second order non-linear differential
equation with at least the positions of the earth, the moon, and the sun as
independent variables.  Neglecting the problem of solving or expressing the
solution to the equation, how do you represent the basic laws of physics
themselves in an object oriented data model without converting it according to
a grammar system of a formal logical language?

As I suggested before, there is no way to express the simplest mathematical or
geometric truths in a system that is not equivalent to a formal logical
language.  As an exercise, please express the Pythagorean theorem in an object
model.

"For all right triangles T, the sum of the squares of the lengths of the two
sides adjacent to the right angle equals the square of the length of the
remaining side"

>But can't an OO model express the same things as FOPC(datums, values, >relationships), but much more efficiently, and in a way that better >represents the natural world as well?

No on all three counts.  First, because typical OO models are oriented towards
expressing only binary relationships.  Second, because non-binary
relationships have to be force fit into such simplistic systems, forcing them
to become an expensive version of more powerful ones.  Third, because the laws
that govern the natural world, at their simplest, are non-linear multivariable
differential equations (such as Newton's law of Gravitation or Maxwell's
Equations), not simple binary relationships.

> And where language is
> concerned, I think to decompose it into fundamental meanings & express
> it works find in an OO model as well. But you may see issues here that
> FOPC or such does and OO doesn't--what are those, specifically?

That is a misconception - the semantics are not any simpler than the syntax.
Another test exercise-Translate the following into a semantic object model:

John believes that the fundamental reason for the American civil war was
unresolved tension between the state and national governments over the correct
interpretation of the Constitution.

> One interesting thing from the article you sent is that different ways
> of representing knowledge have different strengths & commitments.
> However I fail to see weaknesses in an OO expression of anything. Once
> you help me see them, we may be able to do as the article suggests and
> combine them in ways that enhance the expressiveness and utility overall.

One of the main points of that article is that a knowledge representation
system entails a set of ontological commitments due to its necessary choice of
representation approximations.  Without a reasonable proposal to express the
simplest logical expressions in an object model, my position is that it is
fundamentally inferior to a formal language based model for a general
knowledge representation system.  This is why people in the field generally
use LISP rather than traditional databases.

 I have yet to run into any successful implementation that translates
knowledge of any linguistic complexity into any sort of conventional database,
object oriented or otherwise.  The reason for this is strictly performance.

If we want do put a comprehensive model of knowledge into a database we will
have to design a database architecture from scratch optimized for the purpose
of storing extremely sophisticated semantic relationships typical of the laws
of nature and the way the humans actually reason and express themselves.

> I think natural language (at least in current forms) seems like an
> inefficient way to communicate thoughts. We learn visually much faster.

You are confusing bandwidth with brevity of representation.  Natural language
is by far the most efficient way to communicate information with any degree of
abstraction.  How well could you teach history, philosophy, or religion if you
were limited to showing films with no written or spoken words?

> But it seems so inefficient to load terabytes of FOPC statements, then
> go thru & figure out where the relationships are, vs. following a few
> pointers to find out those relationships.

Natural language is not first order, but rather arbitrary order. Traditional
object oriented databases are *zeroth* order, because they have no way to
represent a variable (a repeatible symbolic placeholder for the same object in
an expression) at all.  

In addition, the argument for supporting complex statements does not have
anything to do with where we get the ones we choose to store.

This is interesting to talk about, but we are not getting anywhere, and even
if we did, it would take thousands of hours to make a particularly useful
system, and I doubt any of us has the spare time to get done this century
unless we abandon all our other responsibilities and lock ourselves in a
closet until it gets done.  There may be an impressive brand of social recluse
who can write large portions of major software projects in his spare time, but
I don't think I am one of them, unfortunately.

 - Mark

-- 
Mark Butler	       ( butlerm at middle.net )
Software Engineer  
Epic Systems              
(801)-451-4583