[Taverna-users] Re: [MOBY-l] Biomoby and Taverna 1.2

[Tom Oinn]

markw at illuminae.com wrote:
> Quoting Tom Oinn <tmo at ebi.ac.uk>:
> 
> 
>>1) It can be discovered as 'set of aligned sequences' as a single entity.
>>
>>2) It can also be discovered as a collection of 'sequence'
>>
>>As I understood it the collection / simple wasn't part of the ontology
>>so this isn't possible? 
> 
> You're correct, and that is a good point!

Nice to know my brain's working again :)

I don't think a decomposition widget is the right way to go - the data 
in question _is_ a group of sequences, however that's described. If 
you're using RDF to describe the types can't you express the above? I 
think there's a misconception that semantic types are the same as 
classical object types in e.g. Java.

In the latter case an entity has exactly one type (ignoring things like 
interfaces!) and that type then has inheritance and restriction 
relationships. This causes issues when you want to use that entity in a 
different way - an example of this is in Taverna's code where we have a 
type that represents a user interface widget that can bind to a workflow 
model but we also know that all such widgets are instances of one of the 
core Java ui classes. Because Java doesn't have multiple inheritance or 
mixins we can't express this in the Java type system - I believe this is 
exactly analogous to the case I described above.

In the case of a semantic description you can make statements describing 
the entity, in the current Moby implementation these statements are 
pretty much hardcoded as 'entity has type foo', which makes them 
directly equivalent to the types used in languages such as Java, with 
all the same issues. There's no fundamental reason you need to do this 
though, with an extension into generalised descriptions you should be 
able to say 'entity is represented by collection of sequences which are 
related by...'. The key is to stop thinking of semantic types as being a 
lazy way of growing an object heirarchy and actually take advantage of 
their full expressive power. I can appreciate a desire to keep things 
simple but we have a clear case here where we need something a bit smarter.

Could someone, for example Phil, who actually knows what they're talking 
about on these lists perhaps give an example of how this would look in 
RDF? I know it's possible to do but a concrete example might be helpful 
and I don't have the required knowledge.

Tom