Re: Faceted Search

Sebastian,

there was little traffic on this list so far, yet your message went
unnoticed. Sorry for that!

You can view the webpage for your data as an (X)HTML representation of
RDF. It can be completely data-driven and simply a function that
transforms the RDF response into an (X)THML response. You could do it
in a number of ways: using an imperative language such as Java, or
various template engines.

>From a declarative perspective, XSLT (2.0) is probably the best tool
for this. The RDF/XML syntax is admittedly not straightforward, but
XSLT is a functional and Turing-complete language that can handle it
effectively and transform it to (X)HTML or other formats.
Graphity Client includes a number of predefined generic XSLT
stylesheets that can be imported, extended, customized etc:
https://github.com/Graphity/graphity-client/tree/master/src/main/webapp/static/org/graphity/client/xsl

The facets part is more complicated. If you are using SPARQL to
retrieve RDF results, you can modify the query on the fly, to narrow
down matches based on the facet selections. That is what we did in
this project: http://dedanskeaviser.dk/newspapers
If not, then it depends on the API you are using to access RDF.

I am not familiar with DCI or its concept of actors/roles/contexts.
Maybe it would be easier if you explained your goals. If you are
looking for a functional implementation of data-driven applications
that uses REST and HATEOS and builds interactive forms and other
navigation items, it is exactly what we provide:
http://graphityhq.com/technology

We would be happy to this topic discuss further.


Martynas
graphityhq.com

On Mon, Oct 12, 2015 at 10:26 PM, Sebastian Samaruga
<cognescent@gmail.com> wrote:
> Sorry if this is not the right list. I've came here from a reply in a
> previous post.
>
> I don't know if this is something new, it just seems it was useful for the
> kind of interface I was looking for. I was just wondering what would be the
> best way to facilitate browsing and search in the application demo I'm
> building that renders RDF / Semantic Web contents. I've figured out there
> must be a tree hierarchy of categories, roles and instances of data to which
> adhere the incoming data parsing so having a common denominator for
> different input structures.
>
> Having this structures, browsing through the tree of data, an item (leave or
> node) could be 'picked up' as a facet. For example, if the scenario is "Car
> Rental" as a category, "Car Model" and "Rental City" as roles and many
> models of cars and many cities as instances, what if I could pick a car
> model, a city or both and press "Aggregate" and this resulting in root
> categories for each specific car rental ("Car Rental 1", "Car Rental 2",
> etc) with its roles populated with the corresponding criteria values (the
> city corresponding to "Car Rental 1" given its car, etc).
>
> Maybe this sounds dumb. But the question is: how difficult would be to build
> such a filter criteria using only RDF datasources. RDF statement resources
> are not individualized by their occurrences. An RDF resource is the same
> regardless which statements it occurs. And, although I've found a way to
> individualize occurrences of, for example, Car Rental(s), I can't find the
> way yet to correlate this instances with the instances of their roles.
>
> Also, I'm restricting my mappings (ontology processing output) to three
> levels depth, which seems arbitrary. I could not restrict the graph to any
> depth. But I'll keep trying a while with this arrangements. It seems
> attractive the correlation of categories, roles and instances with some of
> the concepts in the DCI programming model
> (https://en.wikipedia.org/wiki/Data,_context_and_interaction) which could
> allow for a model driven focused approach of building the client
> application, again with the ontology 'common factors' concept in mind.
>
> And the concept of actors, roles and contexts seems as an ideal case for a
> functional language implementation of what could be a runtime environment
> for data driven applications (think of a REST-HATEOAS client that
> interactively builds forms and other navigation items simply by content
> negotiation with a functional data-state-based endpoint).
>
> Source, examples and the demo web application are available in the project
> web page:
>
> http://cognescent.blogspot.com
> http://sourceforge.net/projects/cognescent/
>
> Regards,
> Sebastian

Received on Wednesday, 18 November 2015 16:30:39 UTC