While developing a web-application (= application with web UI) using semantic web resources / technology like RDF, OWL, SPARQL, there is constantly a feeling that at the same time semantic offers much greater possibilities to make a web more human and less “database-style” (not that I do like “parrot-style” popular with start-ups at the moment), as well as a feeling that means to create UI are somewhat limited in the face of openness of the data.

With a “database” approach the schema is fixed and application UI can be hard-coded around it and according to it. Web designers can apply unique styles to distinguish entities, site/app structure can be custom made, annotations (title-author-teaser-tags-…) are well-established and theme developers have ready solutions. Even users became accustomed to where the basic things are and do like that.

On the semantic side things are flexible and generic, and the UI is limited to faceted search, web-like and/or menu-like navigation (correct me if I missed some essential mode). It seems to work best when the curious user hops from node to node (from one page to another).

For example, if we have an author, then we can have all kinds of information about him or her. It is hard to foresee all possibilities in the UI to make it ‘nice’, so the authro as a subclass of, say, Person will need to have it’s own “page”, where those things will be mentioned. And some things aren’t even “plain text” but with some structure, which to make UI beautiful would need nested UI structures, etc, etc. My impression is that even the most advanced web UI libraries aren’t up to the task of representing the complexity in a robust and appealing way.

Of course, we can always restrict the supported annotations / properties and essentially have the same situation as with “database” approach. But assume we want to be open.

The question is, what is the state of the art on the human-machine boundary (i.e. UI), which does not sacrifice aesthetics and usability for flexibility and web UI tradition with necessary novelty? What practical (and not too costly, laborious) approaches exist today to bridge UI and semantic in the CRUD-heavy webapp (to be more specific)?

I am not even speaking of visualization per se. It’s more about how an application can represent new kind of knowledge to the user, which has not been specifically foreseen at the webapp development time (like coming of new-super-something-social identity). To compare with traditional web: we do not need to program in support each time we have new URL in our app, we just need to support certain protocols and any URLs are just content.

Please, do not tell me the whole semantic web thingie is kind of utopia. One way or another there is a need to use stricter knowledge representations than text and google-like search. And whatever technology (semantic web, linked data, etc) will have the same challenges.

There is some research and experimental systems like ActiveRaUL and LESS (not to be confused with Less.js), but it is still unclear what approach should be taken.

It’s not about replacing representation technology (which is HTML/CSS/Javascript), but rather UI-building approaches with the least “impedance mismatch” between tree-like / flat web-page space (screen space) and graph-like, dynamic semantic web model for knowledge. Data-heavy apps are challenging in itself, and hypothesis is that graph-like model may actually make more useful UI because it better matches human mental models. WWW itself is a large graph, but what about microlevel, one page.

Update: That said, Semantic Web thinking is forcing to map major classes and individuals to have their own URL in a web application (dereferenceable URI), where classes correspond to listings of individuals and pages for individuals represent their properties / annotations. So, part of the question is, should the temptation be resisted or just to let the mapping in a most natural, “web way”? (This is actually is not special to graph model, but also to hierarchical object systems like Zope.)

Update2: The Fresnel Vocabulary seemed to tackle the problem for tree-like GUIs. In a somewhat related question – https://stackoverflow.com/questions/26733978/how-to-display-rdf-data-described-by-fresnel-vocabulary – it is proposed to take a look at LDP (Linked Data Platform), but I fail to see how it helps. Systems like Callimachus, if I understand correctly, use some kind of conventional RDFa templates with ?vars in it for form templates…