W3C home > Mailing lists > Public > semantic-web@w3.org > October 2007

Re: [announce] URF: a new replacement for RDF, XML, and JSON

From: Garret Wilson <garret@globalmentor.com>
Date: Tue, 16 Oct 2007 18:23:58 -0200
Message-ID: <47151DDE.3020506@globalmentor.com>
To: "Stephen D. Williams" <sdw@lig.net>
CC: Semantic Web <semantic-web@w3.org>

Hi, Stephen. Thanks for the friendly words. Here are a few answers to 
some specific points. I'll be terse because much of this is covered in 
the URF specification.

Stephen D. Williams wrote:
>
> I like it so far.  There are some areas of comments that come to mind 
> initially.  I definitely have an interest in at least talking through 
> some solutions and possibly helping with specification if they are not 
> already solved.  I like RDF and various semantic web efforts and I 
> don't want to slow anything down, but alternatives should be examined 
> as there is a bit of pain here and there.
>
> What specific improvements does URF have over RDF and RDF/*?  Have you 
> built a clear comparison yet?

Currently there are only the sections in the specification at 
http://www.urf.name/ entitled "Differences between URF and RDF" and 
"Differences between TURF and RDF/XML". I'll work on a more in-depth 
examination, as well as well as a convenient table, but note that many 
of the enumerated differences in the specification are self-explanatory.

>
> There are reasons to have data / knowledge in an XML format, even if 
> the native / better format isn't XML.  While RDF/XML is somewhat 
> reasonable, what improvements might result from URF->XURF?

Some of the improvements of XMURF would be those that have been talked 
about on this list regarding RDF/XML---strings in lists, etc. But please 
note the superiority of Text URF (TURF) over data-oriented XML---I'm 
hesitant even to create an XML-based format for URF. XML for text markup 
such as XHTML is fine, but I'd rather not see XML for storing data. If 
data-oriented XML went away in favor of something like TURF or even N3, 
the world would be a better place.

Please note that URF and TURF are not just ideas---these are completely 
specified and almost every feature has been implemented. XMURF is an 
option that we may never need (and hopefully won't).

>   You say that URF is a superset.  What would need to be added?

You mean what does URF have that RDF doesn't have? Here are a few things 
off the top of my head:

* URIs for literals.
* The ability for literals to serve as subjects in assertions.
* A facility for specifying enum-type classes (the instances of which 
have canonical lexical forms).
* The ability to order properties.
* The ability to have contextual assertions.

>
>
> How does URF handle reification?  
[cut]

> N- Related to reification, there are many types of properties that 
> might need to be pervasively tracked in a set of statements.  These 
> should not have to trigger long-hand reification and there should be 
> some way to avoid statement explosion.  Examples of this might be 
> source of a statement, probability or trust, date/time stamp, and 
> similar.  Ideally, there would be a concise way to optionally 
> associate such metadata without resorting to reification or even to 
> separate statements.

URF has the same reification capabilities as does RDF, and this is 
explained at http://www.urf.name/ under "Reification". TURF has a 
particularly easy way of referring to a reified statement by giving it a 
label; here, I've given the proposition juan->name->"John" the label 
|proposition|; later I could give it a URI or describe it. (URF allows 
long-form reification through explicit urf.Proposition instances as well.)

||example|<http://example.com/example>,
example.juan:
  example.name|proposition|="John"
;|


But URF also has a very useful facility called "scoped properties" which 
may be what you're looking for. These are assertions that are only valid 
within the context of another assertion. They don't require 
reification---they are built into the framework. They are similar to 
your "quads", but more generalized. (In fact, all assertions actually 
have a scope chain built in---but I don't want to rehash that here when 
it's explained in the spec.)

Here's one way to think of scoped properties. You know the common 
pattern in RDF of creating complex values (see 
http://www.w3.org/TR/REC-rdf-syntax/#rdfvalue ), where you create a 
blank node, make the real value the object of the blank node's 
rdf:value, and then put related data as other properties of the blank 
node? Well, you could imagine that every assertion in URF has one of 
those blank nodes hanging around in case you need it. In fact, when you 
assign properties to these blank nodes, those property/value 
combinations themselves have something like blank nodes that allow 
contextual properties. This is not exactly how it works, but it's one 
way to conceptualize it.

So URF allows you to assign properties to objects that are only valid in 
the context of the *scope* of some other property assignment. TURF gives 
a very convenient notation for adding scoped properties using '~'. In 
fact URF allows properties to be ordered by assigning them scoped 
urf.order properties---but again TURF has another convenient notation 
for such "sequences". Check out the specification regarding "Proposition 
Scope" and "Ordered Properties"; as well as the URF grammar; for 
complete info.

Best,

Garret
Received on Tuesday, 16 October 2007 20:25:09 GMT

This archive was generated by hypermail 2.3.1 : Tuesday, 26 March 2013 21:45:18 GMT