Jiri Dokulil

Using Methods of Parallel Semi-structured Data Processing for Semantic Web

The state of the art in semi-structured data processing (and XML in particular) and Semantic Web repositories correspond to each other: the non-scalability of pilot implementations, the inability of optimizations, and the cost of the fully native implementation. Although there are successful implementations in each of the approaches, none of the methods may be considered universal. The Bobox framework proposed in this paper is a relational-like storage engine applicable both as a native XML database and as a Semantic Web repository. The main purpose of the engine is in experiments in both areas. The main stress is put to the performance of complex queries and transformations, and to the ability of parallel evaluation in particular.

Edge Routing with Fixed Node Positions

The two basic problems of graph drawing - drawing of nodes and drawing of edges - are often handled by one algorithm that finds suitable positions for both nodes and edges. However, there are situations where positions of nodes are fixed, for instance if they were defined by the user or the exact position of the nodes is somehow significant. In these cases we need an algorithm that draws only the edges no matter what the positions of the nodes are. This paper presents one such algorithm. We present the very basic version of the algorithm followed by two ways of improving it to produce better looking and clearer results.

Semantic Web Repository And Interfaces

The semantic Web is not widespread as it has been expected by its founders. This is partially caused by lack of standard and working infrastructure for the semantic Web. We have built a working, portable, stable, high-performance infrastructure for the semantic Web. This enables various experiments with the semantic Web in the real world.

Visualization of Large Schemaless RDF Data

Since many XML documents do not contain any schema definition, we expected that there will be also RDF documents without RDF schema or ontology. Then the data can only be viewed as a general labeled directed graph and the idea to present the data to the user by drawing the graph seems natural. Because the data can be extremely large, it is impossible to display the whole graph at one time. Only a suitable start node is displayed and the rest of the graph can be explored by incremental navigation.To conserve space and show possible directions of further navigation to the user we have come up with a technique called node merging. By combining suitable graph drawing and navigation techniques we get a tool that can give the user good idea about structure and content of the data.Since many XML documents do not contain any schema definition, we expected that there will be also RDF documents without RDF schema or ontology. Then the data can only be viewed as a general labeled directed graph and the idea to present the data to the user by drawing the graph seems natural. Because the data can be extremely large, it is impossible to display the whole graph at one time. Only a suitable start node is displayed and the rest of the graph can be explored by incremental navigation.To conserve space and show possible directions of further navigation to the user we have come up with a technique called node merging. By combining suitable graph drawing and navigation techniques we get a tool that can give the user good idea about structure and content of the data.

Edge Routing and Bundling for Graphs with Fixed Node Positions

In some graph drawing scenarios, the positions of the nodes are already defined and cannot be modified (for example, they were provided by the user) and the graph drawing techniques are only used to draw edges between the nodes. The number of nodes in such cases tends to be relatively small (tens or hundreds of nodes at most) however the users want to see all of the edges. Various edge routing techniques can provide such services, but if the graph is dense, the drawing can get rather hard to read due to the high number of lines required to visualize the edges. In such cases, clarity can be improved by bundling individual edges (more precisely parts of their drawing) into larger groups and draw as a single line. In this paper, we provide several different techniques for edge bundling based on an edge routing algorithm, compare and evaluate them.

Navigation in RDF Data

There are already several tools available that are capable of visualizing RDF data. The problem with RDF data is that they tend to be very large. To handle the data, the visualizers cannot display the whole data but rather need to use some kind of navigation. We have designed and implemented such visualizer. This paper describes our approach to the navigation, which was designed specifically with the preservation of the users mental map in mind. We also compare our approach to the other visualizers.

Tri Query: Modifying XQuery for RDF and Relational Data

The ability to convert between different data formats is important in large and heterogeneous information systems. Although XML was established as an universal standard for data exchange, XML-related languages like XQuery lack the ability to access data in other formats; in particular, relational data and RDF. In this paper, we describe TriQuery - an extension of the XQuery language which adds records (tuples) and RDF-specific operators. Using the statically optimizable record types, relational data as well as the results from RDF sub-queries can be integrated more efficiently than with their traditional encoding using XML elements and attributes.

RDF Visualization - Thinking Big

Graph visualization is one of the popular ways to present RDF data. But all practical RDF visualizers have to somehow deal with the problem of the size of the data. Not only can the total number of triples in RDF data be very large, but even degrees of the nodes of the graph can be very high. This article discusses some problems and solution related to visualization and exploration of such data, usually in relation to the RDF node merging technique.

RDF Query Generator

There have been many attempts to create software that would allow the users to design SQL queries visually, even though it is not very natural to handle relations and relational algebra (the theoretical background of SQL) this way. But the RDF data format is based on directed labeled graphs, whose visual representation is very natural. We have created an RDF visualizer and tried to extend it to support query construction. It turned out that the nature of current RDF query languages only allows some basic support but prevents creation of a more sophisticated system. This articles describes our query generator and discusses the limiting factors.

Visualization of Open Community Runtime Task Graphs

The emergence of new types of high performance hardware also drives the need for new programming models. The Open Community Runtime (OCR) proposal uses a task-based programming model to target some of these architectures. In OCR, the whole program from start to end needs to be expressed using tasks and synchronized using task-to-task dependences, significantly limiting the applicability and usefulness of existing approaches to application development and debugging. In this paper, we present our approach to visualizing tasks and their synchronization, based on trace data from application execution. This way, the application developer may compare the intended organization of the tasks with the actual dependences as they are seen by the OCR runtime system.