Posted by JeremyFrench on March 22, 2010 at 3:49pm
I am working on a very exciting drupal/ symantic web project. Part of what I am doing will involve theming data which has come from an RDF triple store.
I was thinking about the possibility of using RDF data to help choose the theme function to use.
For example I may be trying to theme something which is a imdb:director, and have no idea how to theme that. But if I have something which I know can theme a foaf:person and my rdf says that an imdb:director is a foaf:person I can use that function to theme the item.
It may be quite a departure from the normal theming system, which is scary but it could be very helpful in theming all sorts of RDF data.
I would be very interested in hearing the groups thoughts on this.
Comments
conStruct's templating architecture
Hi Jeremy!
Indeed that it is an interesting project :) I would suggest you to take look at conStruct to see what has been done so far in that direction:
http://constructscs.com/
It leverages the ontological structure of a structWSF node to know what template to trigger to a given record instance type. There is a cascade of inference that happens depending on the record type, the templates availables and the ontological structure loaded. The root (and most generic) template that is created is owl_thing.html.
Some more information is available here: http://constructscs.com/features/structdisplay
However this page doesn't talk about all the story (ontological structure and template selection based on ontological inference). Also note that the TinyMCE editor hasn't been released so far (was a prototype that didn't see the light so far).
A new "conStruct skinning tutorial" should be written in the coming month or two.
In any case, this templating system of conStruct is already used in some conStruct/structWSF instance deployed for different projects and organizations.
Hope it will helps!
Thanks,
Take care,
Fred
So you are theming a node
So you are theming a node differently depending on properties of that node. Is that really a new concept?
Theming while allowing unknown properties
While the concept is not new, it is interesting to consider that all the properties or data types may not be known in advance. I would certainly encourage having the data model (and thus the data instances) carry information about possible/default theming, based on the relationships of certain unknown properties to known properties. It's an open-world approach, extending the RDF model (or an OWL ontology overlay) outside a particular UI representation of the data, without breaking the UI. Of course, I'm a data-driven UI designer, not a developer, so everyone gets to be horrified now at such flexibility. ;-)
To Jeremy, I wonder if you've seen the Fresnel work that cam out of the W3C a few years ago: http://www.w3.org/2005/04/fresnel-info/. It was an exploration of the concept, giving the data creator ways of expressing the types of views that might "by default" be applicable to the data, so the data consumer (generic data browser or specific application) could see the design intentions and a basic view. At that point the view could remain useful in the model or be ignored, allowing the data to be styled differently from the position of greater understanding.
Not sure if it applies, and I've not heard people (besides some of the originators) talking much about it in the last few years, but may be worth a look.
Duane
The idea is very powerful and
The idea is very powerful and compelling to me.
Lately I have also been thinking of how the power of ontologies could be used as well for usability in general and testing in particular. For example, usability guidelines could be incorporated in OWL ontologies by defining datatype restrictions, allowing you to measure user-friendliness in a somewhat automated manner. And of course, they could be used in combination with other restrictions on properties (e.g., owl:hasValue) like what their value and cardinality ought to be. Finally, a "semantic" usability test suite could then be build that would enable you to remotely test websites, make conclusions and propose appropriate recommendations. I have elaborated on this idea here:
http://krisvandenbergh.eu/content/using-power-ontologies-automate-usabil...
Would love to hear your thoughts and if this idea is somewhat complementary in a sense to the theming of data using RDF triples.