Xesam meta-meta-data spec needs attention.

[jamie]

On Fri, 2007-05-04 at 18:27 +0300, Evgeny Egorochkin wrote:

> 
> This apparently solves the storage issue for this particular case. However, 
> there are several shortcomings:
> 1) Structures are not extensible.
> 	*You cannot define generic structure for an OO language and subclass it if 
> necessary.
> 	*Applications can't add custom fields to existing structures.
> 2) Data retrieval. 
> If you put the whole structure in a single property, you make it hard e.g. to 
> use several  files to describe a single structure. Also, it is hard to 
> interlink classes e.g. point to ancestor class(es).
> If you make all structure nodes e.g. c++ classes high-level nodes just like 
> files, you get an issue with node classes which cannot be resolved by 
> introducing node type property due to lack of inheritance.

the struct type is a resource in rdf terminology not a literal so it
should not have any additional limitations as such. The Child metadata
can be optional (just as in an rdf schema)  and theres no reason to not
make it extensible.

We can easily add an Extensible property to the desktop file like :

[Email:Address]
DisplayName=Email:Address
Type=struct
Children=Contact:Name;Contact:Email;
Extensible=true

where Children are the required members of a struct (this is same as
having an rdf schema with property minOccurs=1 against them)

I dont see any limitations here - its more a question of nailing down
what properties of a metadata type are needed to satisfy application
needs.


> 
> and the reason we experience these thoubles is...
> 
> 3) This approach departs from RDF in the sense that RDF is 
> property-centric(not class defines its properties, but properties define 
> their class) and omits class type information which is quite essential.
> This quite expectably backfires.

There is class info - the metadata types themselves are classes and you
can subclass them.


> As you can see, implementing e.g. a generic source code browser is 
> problemmatic with this approach.

I dont think so - by supporting struct metadata we can support any
deeply nested structure just like RDF.

jamie.