W3C home > Mailing lists > Public > public-media-annotation@w3.org > December 2008

Re: [Fwd: Re: [Mediann] Ad. "Return Type / String vs Uri" - Issue]

From: Felix Sasaki <fsasaki@w3.org>
Date: Tue, 23 Dec 2008 21:17:58 +0900
Message-ID: <4950D6F6.9000206@w3.org>
To: Tobias Bürger <tobias.buerger@sti2.at>
CC: "public-media-annotation@w3.org" <public-media-annotation@w3.org>

Hi Tobias, all,

two points: first, Jason is just one serialization - as is XML, RDF or 
anything else. We had a starting discusssion about "XML vs. RDF" a few 
weeks ago, and I'm worried that we get another one - "Jason vs. xyz" or 
"Jason version a vs. version b".
As you say below "This approach is valid in RDF ..." - but how about 
other formats?

My second point is that this discussion is "top down", that is: we 
discuss whether we want a feature or not without looking into the 
behavior of existing implementations of metamodels for metadata (using 
the terminology from Chris here), and without looking into what existing 
formats do.

For implementations, both you and Chris said at the f2f that you only 
return one type for each property on the metalevel, and I haven't seen 
something different yet. For mappinges: The page
http://www.w3.org/2008/WebVideo/Annotations/wiki/Format_mapping
is still empty. One approach to continue this discussion which I propose 
is to do it "bottom up" by filling the page and describe what existing 
formats do about types of properties. We know that Dublin Core allows 
for heterogenous types, and XMP does not (each XMP property has just one 
type). How about other formats.

Joakim, Daniel: do you think filling this page would be a good way to 
(also) work on the "return type" topic?

Felix

Tobias Bürger さんは書きました:
> (I forgot to CC the list...)
>
>   
>
> ------------------------------------------------------------------------
>
> Subject:
> Re: [Mediann] Ad. "Return Type / String vs Uri" - Issue
> From:
> Tobias Bürger <tobias.buerger@sti2.at>
> Date:
> Tue, 23 Dec 2008 12:45:30 +0100
> To:
> Joakim Söderberg <joakim.soderberg@ericsson.com>
>
> To:
> Joakim Söderberg <joakim.soderberg@ericsson.com>
>
>
> Hi Joakim,
>
> thanks for the assembling of the page!
> Comments below
>
> Joakim Söderberg schrieb:
>   
>> Hi all,
>> In order to facilitate the discussion on data interchange format, I have assembled the options on a wiki page:
>> http://www.w3.org/2008/WebVideo/Annotations/wiki/Dataformat
>>
>> Personally I like the idea of JSONs collection of name/value pairs.
>> Some thoughts are:
>> 1) Can we have two levels of complexity e.g. simple (string) and complex (e.g. collection of name/Value pairs) depending on property or application?
>>   
>>     
> If we want to have it we can implement it I guess. Please have a look at
> how RDF can be represented using JSON [1]:
>
>  "http://example.org/about" : {
>         "http://purl.org/dc/elements/1.1/creator" : [ { "value" : "Anna
> Wilder", "type" : "literal" } ],
>         "http://purl.org/dc/elements/1.1/title"   : [ { "value" :
> "Anna's Homepage", "type" : "literal", "lang" : "en" } ] ,
>         "http://xmlns.com/foaf/0.1/maker"         : [ { "value" :
> "_:person", "type" : "bnode" } ]
>     } ,
>
> "_:person" : {
>         "http://xmlns.com/foaf/0.1/homepage"      : [ { "value" :
> "http://example.org/about", "type" : "uri" } ] ,
>         "http://xmlns.com/foaf/0.1/made"          : [ { "value" :
> "http://example.org/about", "type" : "uri" } ] ,
>         "http://xmlns.com/foaf/0.1/name"          : [ { "value" : "Anna
> Wilder", "type" : "literal" } ] ,
>         "http://xmlns.com/foaf/0.1/firstName"     : [ { "value" :
> "Anna", "type" : "literal" } ] ,
>         "http://xmlns.com/foaf/0.1/surname"       : [ { "value" :
> "Wilder", "type" : "literal" } ] ,
>         "http://xmlns.com/foaf/0.1/depiction"     : [ { "value" :
> "http://example.org/pic.jpg", "type" : "uri" } ] ,
>         "http://xmlns.com/foaf/0.1/nick"          : [
>                                                       { "type" :
> "literal", "value" : "wildling"} ,
>                                                       { "type" :
> "literal", "value" : "wilda" }
>                                                     ] ,
>         "http://xmlns.com/foaf/0.1/mbox_sha1sum"  : [ {  "value" :
> "69e31bbcf58d432950127593e292a55975bc66fd", "type" : "literal" } ]
>     }
>
>
> Here a resource @ http://example.org/about is described. For the creator
> they return a literal and for the maker a person object with more
> properties attached (so a complex object so to speak). So this is a way
> we could implement it.
>
> If we want to have a property which has two different return types than
> we could subclass this property, e.g. hasMetadataValue is the
> SuperProperty (with no specified range) with two sub-properties
> hasMetadataValueLiteral (range: Literal) and hasMetadataValueComplex
> (range: class representing some "complex" objects).
>
> This approach is valid in RDF(S), OWL Lite and OWL DL.
>
>   
>> 2) How does the application know what is returned?
>>   
>>     
> The application would have to see for which sub property a value is
> returned to determine if she gets a literal or a complex object.
>
> Just one idea....
>
> Best,
>
> Tobias
>   
>> /J
>>
>>   
>>     
> [1] http://n2.talis.com/wiki/RDF_JSON_Specification
>
>   
Received on Tuesday, 23 December 2008 12:18:45 GMT

This archive was generated by hypermail 2.2.0+W3C-0.50 : Tuesday, 23 December 2008 12:18:45 GMT