Re: The IDS, the EDS and the DBMS

"mAsterdam" <mAsterdam_at_vrijdag.org> wrote in message news:413af3cf$0$34762$e4fe514c_at_news.xs4all.nl...
> Marshall Spight wrote:
>
> > I would say rather that attempts to bridge the impedance
> > mismatch are trying to answer the wrong question.
> > Despite my background as an OO coder, I am convinced
> > that the power and generality of the OO model is not
> > up to the level of the relational model.
>
> This is, again, us vs. them of the my-model-is-better variant.
> This flows to a need to convert the OO-thinking people to the one
> true data religion, Tha Reletional Model.

Perhaps; perhaps not. Please remember that in my case, "us" is the OO camp. I have been a professional OO programmer for 19 years, and only began learning about relational 8 years ago.

> Maybe you are right. Hard to tell when we need to conclude
> that somebody is wrong and somebody is right (we are, of course).

I don't so much see it as adversarial. In any event, what is under discussion is models of data and computation; not people.

> I prefer a situational approach:
> First try: Where is OO used? Where is RM used?
> What are the assumptions, environmental requirements?
> Let's inspect how they - in fact - cooperate.
> Let's list what is the same, where the
> differences are and where these differences become relevant.
> Let's forget, for now, the flags of the combattant groups:
> OO & RM. This is where the power of Laconics' IDS and EDS
> comes in (mapping wonderfully to Fowlers' integration/application
> database).
>
> > Thus, any attempt
> > to wrap relational in OO is *necessarily* going to have
> > less expressive power than the unwrapped plain relational
> > model.
>
> You point out a loss going from RM to OO.
> Ok. No gains? At all?

A fair question.

To my mind, the three areas of OO that are interesting are (in order) polymorphism, inheritance and encapsulation. Lately I have also begun to pay attention to how OO promotes modularity, but I don't have as good an understanding of the implications, so I can't add it to my ordered list of features yet.

Subtyping polymorphism is extremely useful, although not as powerful as parametric polymorphism. OO just absolutely nails subtyping polymorphism.

Inheritance is interesting and underrated. It has its dangers, but I think these are mostly because the kinks haven't been worked out yet; as a result, I feel that it has something of a bad rep that is not deserved.

Encapsulation is absolutely necessary for OO languages, but I think ultimately, it will be discarded. Encapsulation is something you need when you don't have declarative integrity constraints; if you had them, you wouldn't need encapsulation. (This is probably a controversial position.)

Here's a big point: the relational perspective pays a lot of attention to relations and relatively little to non-relations (objects, scalars, primitives, whatever.) The object perspective attends exclusively to objects, ignoring relations or attempting to build them up out of objects. Neither approach is sufficiently broad.

What is needed, then, is not a "mapping" from one to the other, but rather a *unification.*

Marshall Received on Sun Sep 05 2004 - 18:25:27 CEST