COEUS

Fork COEUS on GitHub

About COEUS Brief history, support, and more

History

Despite its promise, we can argue that the Semantic Web has underdelivered. A decade later, its usage is still reduced. The lack of killer apps and streamlined frameworks makes developers life very difficult, having to start every new information system from scratch and digg in piles of code and documentation...

Therefore, we started developing a Semantic Web Application Framework, geared towards researchers/developers working on integrating heterogeneous data or interoperable software. COEUS includes an ontology, APIs and a web app skeleton by default to speed up the creation of new Semantic Web applications.

Support

This is the first alpha release for COEUS. Hence, support is very limited.

Software is provided as is, so feel fry to modify anything!

If you can't wait for a final version, you can contact me and I'll try and answer your requests (no promises though, PhD thesis to write...)

What's included

Current COEUS version includes a working sample:

  • All Java code.
  • Sample configuration files (for a disease-related instance)
  • Web API and default web app (this!).

Download »

COEUS is a Semantic Web Application Framework and is, therefore, targeted at Semantic Web application developers. Since this is still a work in progress, some expertise regarding Semantic Web technologies, standards and usage is required for a better understanding of this software stack.

Use at your own risk!

The Basics Do you fancy gardening?

Organizing Knowledge

COEUS is focused on integration and interoperability. These are the key goals that defined COEUS development and its internal organization.
For a simpler interpretation of COEUS internal structure, we thought about organizing it according to a gardening metaphor.

The first thing to consider are single COEUS instances. These standalone applications are built according to a configuration file, in Javascript, and a setup file, in RDF, adopting COEUS Ontology.

Each COEUS instance integrates data in a mini-warehouse (or a large warehouse, depending on the number of resources you are collecting!) and is called a Knowledge Seed.

Once a Seed is built, integrated data is made available through an API (internal Java methods + external REST services). Remember interoperability?
Since all seeds publish acquired data by default, we can deploy multiple seeds and connect them easily, creating a knowledge federation layer: the Knowledge Garden.

Building

COEUS includes data connectors to CSV, XML, SQL and SPARQL resources. With them, you can triplify (almost) any external data into COEUS semantic data storage and use it in new applications.

Building COEUS

Knowledge Seeds

A simgle COEUS instance is a seed. This basically represents a standalone application with a public API.

COEUS Seed

Knowledge Garden

And you get multiple seeds working together... they bloom, creating a garden: a truly federated semantic knowledge network.

Building COEUS

Ontology

COEUS Ontology

For organizing all resources and setting up a new seed, COEUS ontology comes to play.

Check it out »

Documentation

Documentation is also available!

Entity Concept Item

To manage as various data organizations as possible, COEUS data structure is organized in a tree: Entity > Concept > Item.
Entities are classes for the upper data types, Concepts for a middle division and Items for individual level.

For example, to create a seed with transportation information we might have the following structure:

  • Entity: Vehicle
    • Concept: Land
      • Item: Car
      • Item: Motorbike
    • Concept: Air
    • Concept: Water
Entity Concept Item Concept Item

Resources

The Resource class handles setup information for external resources. Basically, resources are apps, services or databases where integrated comes from.
In this version, COEUS enables data loading from CSV, SQL, XML and SPARQL resources through generic connectors. In the future, plugins will be supported for custom data loads, covering even more resource types.

Resources are tied to Concept objects. That is, when we load data from a Resource, we will be creating new Item objects for the related Concept. Easy, right?

Resources can be loaded directly or extending existing Concept data. For instance, if you have a list of IDs and want to load data from a remote web service based on those IDs, you just need to setup the Resource Concept extension properties accordingly.

Entity Concept Item Entity Concept Item Entity Concept Item

Seeds

At last, there's the Seed information. Connecting seed Entities to a main Seed object enables a quicker registry access. Hence, knowing what entities, concepts or items are available at a given seed requires a single SPARQL query.

Entity Concept Item

API

APIs

Since COEUS is focused on interoperability, there's more than one way of getting your data. If you are also developing your applications in Java, you can use the internal API. If you're using something else, just use the REST API! or LinkedData! or SPARQL!

To (visually) check your COEUS dataset, there's a simple web application that will list all relationships to a given item, you can test it here with a UniProt Protein item.

Java

How are your Javadoc reading skills?
There will be better docs for the internal methods in the future, but in the meanwhile this will have to do...

View Java Documentation »

SPARQL Endpoint

All data collected in a COEUS instance can be accessed through a SPARQL endpoint and taking advantage of SPARQL's advanced querying features.

The endpoint default location is at <app>/sparql.

Warning
Please remember to configure the ../src/java/coeus_joseki_sdb.ttl file with your custom triplestore connection settings to get COEUS SPARQL endpoint working properly.

Test it here »

LinkedData

COEUS publishes all data through LinkedData patterns & guidelines by default. With pubby included in all COEUS seeds, data is easily available to external appications.
Using the ../resource/* pattern, you can access object data in the web or RDF browsers.

Warning
Please remember to configure the ../src/java/coeus_pubby.ttl file with your custom ontology and application settings in order to get COEUS LinkedData working properly.

REST

To access all triples in COEUS Semantic Storage, you can combine subjects, objects and predicates to iteratively get data!

JavaScript

Easily perform SPARQL queries to your COEUS-generated endpoint with this new library.
Check the documentation and the library at ../assets/js/coeus.sparql.js

Web Apps

Stripes and Twitter

COEUS includes the Java Stripes framework for streamlined Web Application development on top of existing Java APIs and Twitter Bootstrap CSS/JS framework for the web apps presentation layer.

Stripes

Stripes is a presentation framework for building web applications using the latest Java technologies. The main driver behind Stripes is that web application development in Java is just too much work! It seems like every existing framework requires gobs of configuration. Struts is pretty feature-light and has some serious architectural issues. Others, like WebWork 2 and Spring-MVC are much better, but still require a lot of configuration, and seem to require you to learn a whole new language just to get started.

Go to Stripes »

Twitter Bootstrap

Bootstrap is a toolkit from Twitter designed to kickstart development of webapps and sites. It includes base CSS and HTML for typography, forms, buttons, tables, grids, navigation, and more.

Go to Bootstrap » New

Download and installation instructions

1.0b

Get it while it's hot!

You can fork the latest stable version (1.0b) from GitHub...
Get 1.0b »
... and get the sample database here!

Requirements

Package Contents

  • coeus1.0b.zip Java source code: NetBeans Web Project + required libraries
  • coeus_streamdb.zip MySQL database ready for database import (destination DB: coeus)

All included libraries are use according to their respective licenses. No commercial software is used.

Installation

  1. Create a new database/user in MySQL for COEUS
  2. Extract coeus_streamdb.zip and restore it to your COEUS database
  3. Extract coeus1.0b.zip (source code) to your workspace.
  4. Open COEUS Project in NetBeans and correct server/classpath issues
  5. Update the src/java/coeus_sdb_<environment>.ttl file with your MySQL access credentials for the COEUS storage (file content is self-explanatory)
  6. Update the src/java/coeus_joseki_sdb.ttl file with your MySQL access credentials for the SPARQL server(file content is self-explanatory)(same as above)
  7. Update the src/java/coeus_pubby.ttl file with your custom ontology settings.
  8. Your COEUS install is ready to use!

Warning
There are three working environments in COEUS: testing, development and production. Each of these environments will read a distinct .ttl setup file for the working environment defined in the src/java/config.js environment property.

Configuration

COEUS seeds’ configuration defines the entire instance structure. Three files have control over the application properties, model and, above all, integrated data. Application properties such as naming, version or deployment environment are stored in a local JavaScript file (src/java/config.js). Using a JSON object for the configuration permits faster reads, in comparison to XML, while maintaining a good object-oriented structure, in comparison to simple properties files.

In some scenarios, the “reuse instead of rewrite” principle may not suffice for the entire application model. As such, COEUS allows the creation of custom ontologies to use in one or various seeds. Starting with the basic COEUS ontology, developers can setup their own applications models, taking full advantage of RDF/OWL’s modeling flexibility.
This ontology is defined in the ontology property of COEUS JavaScript configuration file.

The third required configuration file includes the data integration and exploration setup (src/java/coeus_setup.rdf). In this file we define the application individuals for each class, configuring entities, concepts, bridges and resources. Summarily, content in this file is used to guide the entire framework instance setup, from the handling of external resources in the connectors to the labeling rules for each Item individual. Considering the setup files OWL/RDF nature, relying on Protégé is advisable to ease the configuration process. In this widely used ontology modeling tool, the configuration can be visually organized.

Running

I recommend that you start by running the existing application setup and read the documentation before building a new seed.

  • Before running, make sure the src/java/config.js file points to the correct files and environment definitions
  • To run, simply build the project and press run on NetBeans

Building

The default seed included in COEUS contains the setup for a disease-based information system. You can use Protege and open up the src/java/coeus_setup.rdf file to analyze the configuration. Using Protege is advisable for a clearer understanding of the setup structure.

Since the default seed setup is very complex (and with plenty dependencies), the data import process is divided in various levels. You can use this strategy in your own system or rely on the coeus:order property for each Resource.

  • To build a new instance, start by setting up the seed ontology (if you need a new one), and the data organization in the setup file (coeus_setup.rdf)
  • With the RDF setup file comple, update the pt.ua.bioinformatics.coeus.common.Run Java file with the level configuration or with the full thing
  • Execute the Run class file.

License

Free

Creative Commons

COEUS and COEUS Ontology are licensed under the Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License. To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-sa/3.0/ or send a letter to Creative Commons, 171 Second Street, Suite 300, San Francisco, California, 94105, USA.

DETI/IEETA, University of Aveiro

Use, modify, change, update as you need!