His observation that ontological modeling alone is insufficient for syntactic disambiguation is spot on. The solution for semantic interoperability will combine ontological representations to model the relationships between data sources and a repository of transformation rules. What shape those rules will take is an topic in the research community.

Some folks at the University of Bremen published one such approach that combines ontological modeling with rule based transformations of syntactic elements. One of their conclusions is that rule-based transformations may be insufficient. They demonstrate classification transformation using traditional logic reasoning to deal with more complex transformations. They identify as an open issue the integration of these strategies to provide a comprehensive solution.

There was some applied work done by Robert Worden a few years ago on MDL or Meaning Definition Language. MDL attempts to define mappings between XML documents at a semantic level. Professional XML Metadata has a chapter dedicated to MDL where Worden demonstrates semantic interop between (IIRC) 13 different Purchase Order Schemas. XSLT is providing the transformation capabilities, while MDL models the relationships. MDL seems to be incarnated in a commercial offering from Charteris and renamed to Mapping Definition Language.

I would suspect that over time toolkits will emerge that will provide the building blocks for semantically sensitive syntactic transformations. Until then we are awash in a sea of bits.

Share/Save

Ben Trott of Moveable Type fame releases mltfo.pl fufilling the dream.

Share/Save

Share/Save

Share/Save

I have
been thinking about the intellectual barriers to information
interoperability. Practitioners in technology are bound, some would
argue, by reality or experience, but I would argue by tradition and
experience. This translates into a measurable acceptance and
open-mindedness about technologies such as EJB but the same crowd
dismisses technologies like JINI without a second thought. Ignore the
commercialization of these for a moment and focus on their
similarities. Both provide services and the ability to locate
services. EJB provides this in an almost parochial manner, focusing on
staticish configurations with purportedly increased levels of determinism. JINI on the other hand takes a more laissez-faire approach. Not worse. Not technically inferior. Not inherently less reliable. Just not as prescribed.

Now
before the masters of EJB come after me, arguing that EJB is dynamic
etc, my point is really that the manner in which a problem is solved
using EJB and JINI are different to the extent that each technology
exposes a different model for facilitating communication, a different
model for robustness and a different approach to determinisim.

I
would argue that most technicians today have difficulty with accepting
that the JINI way is better, much less even practical. This has
everything to do with models of familiarity, not demonstrated technical
superiority. People are comfortable with the CICS model where things are
there. The question of them not being there is not dealt with
directly. (It may very well be by DR and network and guys with short
ties, but not by developers). JINI proposes that a service with
certain capabilities may
exist, find out, it may not be the one that
you expected, in fact it may not even be there, deal with it, sometimes
bad things happen.

Whoa….my goal was not to deal with EJB
vs JINI, but rather to propose that a very similar phenomenon exists
with data and information representation. Developers flock to XML
because on the one hand it is indeed a vast improvement in many cases
for representing structured information but it retains the comfort
zone of header files, copybooks, IDL definitions, etc. The
epistemological boundaries of XML as data container are well understood
or not deeply contemplated at all.

Moving to the next level

I
would like to explore the development of a pragmatic knowledge
representation model that supports automated disambiguation and
seamless translation services. Users of this framework would be able
to build applications that interoperate at a semantic level with other
applications.

We will explore representational
technologies, select an approach, construct some sample domain examples
and work on a framework to support translation and interoperability.

Share/Save

The history of programming is littered with attempts to find the SilverBullet for sharing data and meaning between players.  The initial hype around XML was centered around it becoming technologies Esperanto…née the RosettaStone.  
The issue that remained is that if I have an XML document that refers to <product><quantity>1</quantity></product>, the recipient of this data is left to infer the meaning of quanitity.  Is that units?  Is that gross?  The construction of structured content in XML via DTDs or even XSD is/was an attempt to provide shared understanding.  Unfortunately, this ignores the history of similar attempts.  COBOL copybooks were one such attempt to share definition between parties.  Structures, variant records, objects, XDR, CORBA, etc have all tackled the issue of sharing and abstracting definition.  The rub is that everyone of these attempts has failed to impart meaning to the data they share.  

Now you may argue that this is IvoryTower talking, but the reality that all of these strategies and technologies become brittle over time.  Don’t shoot the messenger.

So where does that leave us?

There are some cool things going on with RDF and DAML+OIL that gives rise to the thought of imbuing application/object models with semantic meaning.  Rather than simply expressing that an object has these attributes, we codify the semantics of the model using ontologies.  While no perspective users of the resulting model may understand what a Product Quantity is by its object definition in some nGL language, associating Product Quantity with a #UnitOfMeasure type and corresponding constraints and relationships facilitates the interoperability of applications at a semantic level, rather than the syntactic bindings so prevalent today.

We’ll be spending some time drilling down into this.  Looking at CYC, DAML, and RDF and their applicability to metamodeling and object technologies.

Comments to me.

Share/Save

The first cool thing to talk about is the role of the CYC Upper Ontology [REF] in object systems. This guy Stephen Strom presented at OOPSLA 2000 a generic object model based on the CYC Upper Ontology. A colleague of mine commented “government work is good.”

I particularly like the point in the slides where a Person derives from CompositeTangibleAndIntangibileObject. I need to dig some more to see where this leads.

Suffice it to say that the introduction of BiologicalLivingObject into your object model will allow you to shift directions quickly.

Share/Save