Re: Picking the Tools

[Uche Ogbuji <uche.ogbuji@fourthought.com>]

> You are the right person to ask, Uche.  I don't have to
> like the answer.  And I thank you.
>
> So the basic leg of the SciAm article,
> a universal system for the Semantic Web,
> is kaput:  no top-level, up-translation.
> Just noisy peers...

Ah, but I continue to plead ignorance of the claims for the Semantic Web.

Funny this should come up now.  Last week I joined www-rdf-logic.  Some
perusal of the archives gave me some worry, but I ploughed in anyway
(should have known better).

I found out in my very first thread there that there was an impedance
mis-match between what I wanted to get done with XML, RDF and the like,
and the ambitions of many others.

I see RDF as an excellent modeling tool for closed systems.  In my
practice, most of the real "knowledge" is in the XML documents at the
nodes, but RDF can provide important indexing and relationship expression
between these nodes.

Examples of how RDF serves my modeling needs:

When I need composition in my modeling, I either use XInclude, or I use
part-of relationships between XML documents encoded in RDF, depending on
where the composition fits into the model (closer to the abstract or
closer to the representation).

When I need associations in my modeling, I usually use RDF or
XLink, again depending on the abstraction in question (it's a short hop
thence to XTM).

When I need delegation in my modeling, I almost invariably use
appropriate RDF relationships between the XML schemata and the
stylesheets or RIL expressions that are behind the processing in which
the delegation is actuated.

The process-flow for resulting apps tends to be something like

     [ RDF processing (handle abstract behaviors) ]
                           |
                           |
                           V
    [ Assembling low-level XML source (XInclude, etc.) ]
                           |
                           |
                           V
 [ higher-level processing (XSLT, XLink resolution, etc.) ]


This is an incredibly simple conceit, and it's surprising how many apps it
works well for (and how rapid the resulting development can be).  But note
that the amount of modeling magic I need (Semantic Web sorts of things, I
guess) is at a minimum.  The RDF statements are low-level with basic
semantics, so matters such as inference and ad-hoc querying are quite
straightforward.  RDF basically carries a manageable burden.

I quickly found out on www-rdf-logic that in the discussion there, the
assumption appear to be that in the semantic Web the RDF statements would
carry a heavy burden of the "knowledge" in the system.  I've started to
think that this idea is a straw man set up by folks who would like RDF to
be a fully-blown knowledge-representation language, but if "strong RDF"
is indeed a cog in the SW wheel, I fear I must excuse myself from
contributing to that discussion because It places me immediately out of my
depth.

So my point is that if all you need is expressive modeling,
and you are (IMO) realistic about the involvement of programmers and
human agents in the design, implementation and maintenance of a system,
RDF modeling works very well.  I don't claim that this idea extrapolates
to such an ambitious undertaking as the SW, and since I am able to get a
good deal of work done in XML/RDF without needing the SW around, I tend
not to bother myself too much with the issue, anyway.


-- 
Uche Ogbuji                               Principal Consultant
uche.ogbuji@fourthought.com               +1 303 583 9900 x 101
Fourthought, Inc.                         http://Fourthought.com
4735 East Walnut St, Ste. C, Boulder, CO 80301-2537, USA
Software-engineering, knowledge-management, XML, CORBA, Linux, Python