[
Lists Home |
Date Index |
Thread Index
]
> [Uche Ogbuji]
> [Tom P asked]
> > > Uche, could you give one or two more concrete examples of this (I mean,
> > > examples of replacing rules and inference by declarations and class
> > > analyses)? Especially something that gives the flavor of what surprised
> > > you. Not of course something that you shouldn't be talking about, but
> some
> > > kind of illustration. It would be very useful to me and, I'm sure, many
> > > others.
> >
> > OK. One of the sensitive things about the project is the sorts of data in
> the ontology, so I'll just have to completely make up an example that I hope
> will do for illustration.
> >
>
> Many thanks, Uche. There are almost too many interesting things here,
Well, now you get a sense of the froth that has been brimming my scalp in my journey from staid C++ developer through discoveries of Python, XML, RDF, and now ontologies.
I can't tell you how lucky I feel to have worked most of this progress through practical projects, many of them successful.
> especially including the posting you linked to from 1993.
It's one for the archives, eh?
I was in this thread, live, just about to graduate in computer engineering, though I'd already been working off my hefty tuition as a fully professional consultant part-time. I was a C++ maniac and the thread touched on everything that was brilliant and infuriating about C++ in those great days before ANSI got their hands on it.
I think the whole baobab got kicked off with a discussion of the NIH C++ classes, which are well known as the pinnacle of ultra-orthodox OO design (and thus mightily admired or reviled depending on your attitude toward pure OO). I do remember the turn it took through the problems with C++'s handling of co-variant constraints, and in particular, the fact that polymorphism is crippled in return values more so than in function parameters (a flaw that I think almost every statically typed OO language "interits"). Anyway, when I read Skaller's post, I thought "that's the kind of C++ programmer I want to be", and I printed it out for future reference.
> This reminds me of the way I usually approach high level modeling of the
> problem domain. I try to model in a way that is neutral as to whether an OO
> or non-OO would be used. It's true that I use a loose combination of ER and
> Object modeling, mostly ISA and composition, but that doesn't automatically
> commit you. I find that an informal approach modeling (which is actually
> rigorous about the basic relationships and responsibilities in the model,
> but loose about most everything else) is useful and productive, at least for
> me.
>
> My rationale for this is two-fold. First, the problem domain generally does
> not know or care anything about OO engineering, and I want to understand the
> problem domain. Of course, there has to be some kind of model, and that
> will entail some kind of mental filter. Second, I think that it's good if
> the model could be implemented in several different systems, because that
> approach helps keep implementation out of the understanding of the problem
> domain.
>
> Anyway, I think this fits right in with the emphasis on ADTs and mixin
> classes in your linked post.
Yes. I turned quickly to hybrid approaches as I started to wonder about OO. ADTs and mix-ins, which are not so far outside the curtain, and then ER and even AI frames. The most important attitude is that fidelity to the problem space is more important than fidelity to the methodology. Simplistic it may sound, but I see almost *no* evidence of such thinking in mainstream development projects.
> > We can then attach application behaviors to classifications in some way.
> This is similar to the idea of methods in OO, but our big gain is that we've
> decoupled the classification of objects from low-level implementation
> details.
> >
>
> If I read you right, you have tried to replace dynamic application of rules
> to known classes with dynamic discovery of (ontological, not just OO)
> classes, whose discovery entails certain rules and behaviors. Is that close
> to the mark? This puts the emphasis on classification, I can see that.
Yes. I think we're on the same page.
> In a way, a certain rule could be considered a property of a class, right?
> Classify an instance and you have the rule. Interesting.
Precisely. And we do just this in the Sun project, with RDF triples linking DAML classes to an abstract rule, which can in turn be linked to implementations in Java, XSLT, Web service, 4Suite HTTP API, etc.
> Hmm, I wonder if you could create xslt stylesheets - if a structure is an
> instance of a certain class, it gets a certain template. Of course, that
> happens now if you think of an XPATH expression as classifying a set of
> nodes, but I mean to actually construct a stylesheet, as opposed to applying
> templates. Maybe that's too far-fetched.
If I understood you correctly, I've done this sort of thing. I create an XSLT stylesheet for a coherent business scenario which contains some templates which are associated with the rules that are connected to each classification. I then run the stylesheet over some representation of the ontology such that the appropriate template gets matched for each instance encountered, according to its classification. Actions for which XSLT is not appropriate are invoked through extensions.
--
Uche Ogbuji Fourthought, Inc.
http://uche.ogbuji.net http://4Suite.org http://fourthought.com
Track chair, XML/Web Services One (San Jose, Boston): http://www.xmlconference.com/
DAML Reference - http://www.xml.com/pub/a/2002/05/01/damlref.html
The Languages of the Semantic Web - http://www.newarchitectmag.com/documents/s=2453/new1020218556549/index.html
XML, The Model Driven Architecture, and RDF @ XML Europe - http://www.xmleurope.com/2002/kttrack.asp#themodel
|
