Talia is a web-based distributed digital library and publishing system, designed for scholarly research in philosophy. Talia is based on semantic web technology; it's being developed with the Ruby on Rails web framework. Rails is a relatively new environment, which allows developers to easily create well-structured web applications. By combining its power with semantic web technology and leveraging on existing solutions like ActiveRDF, it is possible to quickly create a full-featured semantic library platform, from scratch, in a short time. Talia does not aim at creating new semantic web technology as such, but at providing practical solutions for embedding the existing technology in modern web applications. This paper focuses on a few select features of Talia to show the possibilities.
Discovery3 is a European project to create an extensive online library for philosophers. The four content partners of the project will provide tens of thousands digitised and annotated pages, so that the project will start with a large body of material.
Philosophers usually work in a traditional, print-and-paper based way.
However, finding all relevant publications on a topic is difficult and acquiring copies
is yet another matter. This is especially true for original manuscripts, which can
be notoriously hard to acquire [
By creating a comprehensive resource with original manuscripts and secondary writings, we can provide an invaluable tool to the scholarly research community.
Discovery will be based on Philosource, a federation of interlinked online libraries. The libraries currently use the Hyper platform. Hyper was created for the preceding HyperNietzsche project (now NietzscheSource4). 3 http://www.discovery-project.eu/ 4 http://www.nietzschesource.org/
The Hyper platform was developed specifically for a Nietzsche library. Particular assumptions about Nietzsche are hardcoded into the application, and the codebase is not flexible enough to be a viable long-term solution for the project. It will be superseded by the Talia platform described in this paper.
In the humanities, the text itself is the subject of study. Talia aims to provide an integrated library system that offers tools to work with original content. This is in marked contrast to citation systems like CiteSeer5, CiteULike6 or even online archives like arXiv7. These focus on bibliographical metadata, the actual content is not more than an opaque, downloadable document.
Talia provides a tight integration between a semantic backend store and
a powerful interface toolkit, making it unlike existing “infrastructure” library
systems, such as BRICKS [
Within the Discovery project, Talia does not exist in a vacuum – it’s a means to an end. There are a number of features and components that must be implemented in Talia to make the software useful within the project: – Users expect that the User interface contains all features that are already present on the Hyper platform. – Metadata and ontology support is essential. Each group of scholars will create their own domain ontology to order their material. – A Remote Federation API has to be implemented to allow automatic bidirectional references between documents in different libraries. – Publication and Workflow. Scholars will be able to publish new results online. Talia must offer a number of workflow models for peer-reviewed publication.
A speedy development is also essential, since the existing content has to be migrated in the second year of the project and Talia must be running for the project to succeed.
The rapid development of Talia would not be possible without leveraging existing technology, both from commercial web development and semantic web research.
– Ruby on Rails9 is a web development framework that has been picking
up a lot of pace recently. It uses the Model-View-Controller [
As a general rule, Talia tries to avoid any unnecessary complexity. This is also true for the use of RDF metadata: – Talia is schema-agnostic. Ontology descriptions may be used by the system; however the software does not rely on their presence. It also doesn’t attempt to enforce any kind of schema rules on the RDF data. – Talia does not attempt to do any inferencing on the RDF data. If this is needed, it will be the responsibility of the RDF store. – Talia tries not to use specialised RDF store features, in order to be compatible with any RDF endpoint. 3
Talia uses a hybrid RDBMS/RDF store solution in the storage backend. A relational database as a highly reliable, transaction-aware storage for the critical data. It is kept in sync with an RDF datastore for advanced semantic features, which may range from SPARQL queries to inferencing, depending on the type of the store. Using a standard RDF store also provides an easy way to interoperate with semantic web software.
The hybrid design is feasible because a Talia library has relatively static content. Data access will mostly be read-only, the few modifications can be easily synchronised without much overhead for the system.
Talia provides a simple API that hides most of the internal workings of the data store. Each document is represented as an object of type Source; the object provides access provides access to all properties of the document, no matter if defined as RDF or not. Listing 1.1 shows an example of this API.
Listing 1.1. Basic Operations on a document document = T a l i a C o r e : : Source . new ( " http : / / u r l . com/my_document" ) document . wo r k fl o w _s t a te = 2 # non r d f p r o p e r t y document . dcns : : t i t l e << "My␣ f i r s t ␣ document " # RDF p r o p e r t y author . i n v e r s e . dcns : : c r e a t o r # " i n v e r s e " # Replace t r i p l e document . dcns : : t i t l e . r e p l a c e ( "My␣ f i r s t ␣ document " , "New␣name" ) document . dcns : : t i t l e . remove # remove t r i p l e s 10 http://www.activerdf.org/ 11 http://librdf.org 12 http://www.openrdf.org/
The interface borrows heavily from the ActiveRDF interface, and ActiveRDF is used in the backend to connect to the RDF store. However, ActiveRDF was designed mostly as an easy read interface for web applications. The library was substantially refactored to improve the data manipulation capabilities (such as deleting triples). Other modifications were made to make it easier to call the library indirectly as part of a backend, instead of directly as a part of a script. 3.1
Talia provides an unified query interface for both database and RDF metadata, as shown in listing 1.2. For normal queries, the interface hides most of the complexity and automatically decides wether to use a RDF/SPARQL or an RDBMS/SQL query on the backend.
# The f o l l o w i n g w i l l do a q u e r y on t h e RDF s t o r e T a l i a C o r e : : S o u r c e . f i n d ( : a l l , N : : DCNS. C r e a t o r => " D a n i e l " ) # The f o l l o w i n g w i l l LIMIT a q u e r y t h a t u s e s RDF and DB d a t a T a l i a C o r e : : S o u r c e . f i n d ( : a l l , N : : DCNS. C r e a t o r => " D a n i e l " , : w o r k f l o w _ s t a t e => 2 , : l i m i t => 5 )
During development we found that the SPARQL [
SPARQL does not provide an easy way express OR statements in a single query (for example “subtype OR supertype”), and it’s filter mechanism is highly inefficient for large result sets. A straightforward COUNT implementation is also missing from the standard. Another problem is that in different RDF stores the SPARQL specifications is implemented to various extents, making it difficult to provide a store-agnostic solution.
Early versions of Talia also encountered the problem of reconciling “mixed” queries that use both the database and the RDF store. With the new hybrid design it will be possible to answer each query either from the RDF data or the database. This will allow the backend engine to select the query language best suited for the job.
The built-in query mechanism is optimised for compatibility with a number of RDF stores and RDBMS. If this is too limiting the developer has the choice issue queries (either SQL or SPARQL) directly and access store-specific features. 3.2
As mentioned, Talia’s core functionality does not rely on an ontology description. Still, if one is needed, it can easily be loaded into the RDF store and queried from Talia.
Talia provides a SourceClass abstraction to represent RDF classes and to navigate the ontology hierarchy, as shown in listing 1.3. The user may also retrieve metainformation from the ontology, supertypes or subtypes of a class.
# Get t h e f i r s t r d f t y p e and g e t sub f i r s t _ c l a s s = document . r d f _ t y p e s . f i r s t sup = f i r s t _ c l a s s . s u p e r t y p e s and s u p e r c l a s s e s 4
Source objects can be used in HTML templates to create a web representation a document. Talia uses Rails’ standard rhtml templates that contain HTML with embedded ruby code. Listing 1.4 show a simple template that renders a HTML snippet with some properties from the RDF store.
<p> The c u r r e n t document i s <%= document . r d f s : : l a b e l . f i r s t %> i t ’ s authored by <%= document . dcns : : c r e a t o r . j o i n ( " , ␣" ) %> </p>
Talia needs a rich user interface for each document type. Unlike many semantic web applications that use an “auto-generated” generic interface for semantic metadata, Talia needs to provide specialised views depending on the RDF type of a resource.
A automatic semantic template engine is built into Talia to do just that. Listing 1.5 shows a simple example; the site developer simply passes the Source object to the source_snippet UI widget, and the semantic template engine does the rest.
Listing 1.5. Rendering a document with a semantic template <% my_document = T a l i a C o r e : : Source . new ( u r l ,
N : :MYONT: : the_type ) %> <%= widget ( : s o u r c e _ s n i p p e t , : s o u r c e => my_document ) %>
When the template engine renders a document, it will look at the document’s RDF type and attempt to find a template which has a name that matches the namespace and name of one of those types. In the example the document has the type myont:the_type; if the template engine finds a template named _myont_the_type.rhtml it will use it to render the document. Otherwise it will fall back to a default template.
The template engine allows the UI templates to be easily created by professional web designers who don’t know semantic web concepts. In the final web application, template selection happens automatically and it’s very easy to add new templates. By providing a sensible default template, the engine is still able to deal with elements of new and unknown types.
This paper showed a quick glimpse of Talia’s semantic web features and demonstrated how semantic web development can be made a breeze by combining the power of an existing framework with a dynamic RDF store API.
More semantic web features will be included in future version, like semantic links between remote libraries, user-created metadata and integration with the DBin desktop application.
Talia is freely available from its home page13, the page also contains some instructions and additional documentation for the software. There’s also an online demo of the current development version14.
This work has been supported by Discovery, an ECP 2005 CULT 038206 project under the EC eContentplus programme.
The authors wish to thank Eyal Oren and the ActiveRDF team for their work and support.