[
Lists Home |
Date Index |
Thread Index
]
On Tue, 30 Nov 2004 16:16:49 -0800, Dare Obasanjo <dareo@microsoft.com> wrote:
> > -----Original Message-----
> One of the things I've found interesting about discussions with the
> RDF/Semantic Web crowd is that many of them fail to see that moving to
> ontologies and the like basically is swapping one mapping mechanism
> (e.g. transformations using XSLT or regular code in your favorite OOP
> language) for another (e.g. creating ontolgies using technologies like
> OWL or DAML+OIL). At the end of the day one still has to transform
> format X to format Y to make sense of it whether this mapping is done
> with XSLT or with OWL is to me incidental. However the Semantic Web
> related mapping technologies don't allow for the kind of complex and
> messy mappings that occur in the real world.
This is one of the many things I just don't grok about the world. So
much effort is spent on removing the necessity to write procedural
code! For whatever reason I find it easier to think in terms of
sequences of operations to do something rather than to think in terms
of the abstract definition of what is to be done. But maybe I'm weird.
This motivated me to Google for "declarative procedural" to refresh my
memory on what the theoretical advantages of the declarative approach
are. Oddly enough, hit number 3 is a post from an xml-dev thread 4
years ago, which it appears that I started
http://lists.xml.org/archives/xml-dev/200011/msg00059.html
(Actually it was Paul Tchistopolskii's response that got the high page
rank - http://lists.xml.org/archives/xml-dev/200011/msg00068.html)
That thread is pretty interesting reading ... It did establish to my
satisfaction that XSLT is not really "declarative", but I'm pretty
sure the approach that Dare and I are talking about of creating
ontologies that would then be used by some tool to generate the
transformation would be a pure declaratie approach.
But back to the issue of the advantages of a declarative approach:
They seem to be, in theory anyway, from what I learned re-reading the
old thread:
- procedural approaches don't scale well; think of how much better SQL
(or XQuery!) DBMS work than the old hierarchical or CODASYL navigation
model did. A more modern analogy would be the difference between
using XPath (quasi-declarative) vs raw DOM operations (procedural) to
search an XML document for some pattern.
- Ordinary mortals can use GUI tools to declare relationships (e.g CSS
stylesheets); nobody has really been able to automate the hard part of
procedural programming, and a relatively small percentage of people
seem to be comfortable thinking that way.
- The declarative approach is more amenable to parallelization, e.g. a
PDF (declarative) formatter could process each page in a separate
process whereas a PostScript program (procedural) could not because it
has to run from the beginning to setup the necessary state for a given
page.
- Overall declarative approaches allow complexity to be managed -- at
least within some coherent domain -- because the poor humans just deal
with defining concepts and relationships one at a time, and the more
patient machines plow through all the implications.
So, do these theoretical advantages of the semantic web approach to
transformation over just writing code in your favorite OOP language
actually hold up in practice? Or is it just a matter of transferring
the messy grunt work from somebody called a "software engineer" to
somebody called an "ontology engineer"?
|
