Tuesday, November 27, 2007

Embedding OWL-RDFS syntax in XHTML with RDFa

Short introduction to RDFa, OWL and Microformats

The OWL-language (web ontology language) is a recommendation by the W3C. is a language that allows proper definition and representation of . It is supposed to form the foundation of the next generation of the internet: the semantic web (a.k.a. web3.0). Unfortunately, even though it has been a recommendation since 2004, it has gained very little traction in the online community.
There are several reasons for this, and some of them are discussed in this article.

Microformats are small structural mark-ups of HTML, with a very consistent format. They are somewhat of a web 2 and a half approach, allowing machine readability through consistent structure, but lacking the flexibility to capture more than what is defined in the limited Microformat standard. Microformats have more or less emerged spontaneously. Through their ease of use, Microformats have gained a lot of momentum, but as mentioned, they lack the expressivity required to really push the boundaries of the current internet experience.

This article is about coming up with a solution that reconciles the ease of use of Microformats with the expressivity of a language like OWL.
Some problems hindering OWL adoptation will be highlighted, and a first experiment with the use of RDFa mark-up to embed OWL data directly into an XHTML page will be demonstrated, a solution that can be considered as a step higher than Microformats on the evolutionary ladder of the web.

Terminology frequently used in this article:

A real world occurrence of a class (a bordeaux wine you just bought in the store).


A unit of meaning (wine as a 'category').


With meaning a little broader than the given Class (less specific), for example 'Potable (drinkable) Liquid' in the case of wine.

Semantic items

Human and machine understandable content.


There are three sublanguages of OWL, named OWL-Full, OWL-DL and OWL-Lite. Funnily enough, and contrary to what you might think, OWL-Lite is the most strict of the three and hardest to achieve. OWL-Full is the least interesting of the three dialects; it is often gibberish to reasoners (programs that interpret your semantic constructs) because you can intermingle anything with everything. Usually, the goal is to produce OWL-DL syntax at the least.
All OWL syntax examples in this document validate as OWL-Lite, copy-paste the syntax into the OWL Validator to check. For a more complete introduction on OWL, see the W3C OWL language guide.

Why OWL-RDFS has such poor web presence.

There are several reasons why OWL syntax is nowhere to be seen on the web, and some of these problems are as follows:

1. OWL is Verbose

It really is, but, in my opinion, this does not constitute that much of a problem. Verbosity can be good if it improves readability.
See next point for some considerations however.
On verbosity; below is an example of the minimal OWL-DL compatible syntax required to declare one class, with one parent specified, and one outgoing relation, no comments or labels included, and no advanced relating. As you can see in the figure below, that is already quite a mouth full.

xmlns ='http://this.page'
xml:base ='http://this.page'
xmlns:owl ='http://www.w3.org/2002/07/owl#'
xmlns:rdf ='http://www.w3.org/1999/02/22-rdf-syntax-ns#'
xmlns:rdfs ='http://www.w3.org/2000/01/rdf-schema#'
xmlns:xsd ='http://www.w3.org/2001/XMLSchema#'>
<owl:Ontology rdf:about='http://example.com/dummy_ontology'/>
<owl:Class rdf:ID='id_for_this_class'>
<owl:Class rdf:about='http://example.com/dummy_parent' />
rdf:about='http://example.com/dummy_target' />

Figure 1: OWL Verbosity: Expressing one class, including one parent and one outgoing relation.

2. OWL is Incomprehensible

Well, not really, there is a lot of logic in OWL. At least computers should have no problem understanding. Honestly!?
But to the average human, it is a bit like learning to read bits and bytes. Part of the reason why Microformats are successfull is that every web designer understands css and html. Before you delve into OWL, you should have a good understanding of RDF, xml Namespaces, URI's, ... and even though all OWL documents are RDF documents, the language is in many ways nothing like RDF. Finally, you also need to become familiar with ontological jargon (classes, instances, subsumption, disjoints, ...) and methodology and how it impacts your ontology. This, in many ways, resembles learning algebra. The methodology is not something people are acustomed to, there is a general 'why bother attitude', but once learned it paves the road to new insights. So there is a bit of a learning curve.

Perhaps the most significant problem however, is that there are multiple ways of expressing one and the same thing. Consider the examples below. For both, ONLY the syntax varies from what is expressed in Figure 1, the content remains the same (mind that this is still about the very simple set-up: one class, one parent and one relation). They both validate as OWL-Lite as well. The bottom example is the one that resembles the most an original RDF graph, but it is also the hardest one to read. It is an important example however, seeing that this is more or less what RDF, extracted from an RDFa-XHTML page looks like (more on that later).

xmlns ='http://this.page'
xml:base ='http://this.page'
xmlns:owl ='http://www.w3.org/2002/07/owl#'
xmlns:rdf ='http://www.w3.org/1999/02/22-rdf-syntax-ns#'
xmlns:rdfs ='http://www.w3.org/2000/01/rdf-schema#'
xmlns:xsd ='http://www.w3.org/2001/XMLSchema#'>
<owl:Ontology rdf:about='http://example.com/dummy_ontology'/>
<owl:Class rdf:ID='id_for_this_class'>
<rdfs:subClassOf rdf:resource='dummy_parent' />
<owl:onProperty rdf:resource='dummy_property' />
<owl:someValuesFrom rdf:resource='dummy_target' />
<owl:Class rdf:about="dummy_parent"/>
<owl:ObjectProperty rdf:about="dummy_property"/>
<owl:Class rdf:about="dummy_target"/>

reference to parent & to target: must be declared
in this document as being of the owl:Class type to be
owl-DL compatible.
reference to property: must be declared as being of type
owl:ObjectProperty in this document to be owl-DL compatible.

xmlns ='http://this.page'
xml:base ='http://this.page'
xmlns:owl ='http://www.w3.org/2002/07/owl#'
xmlns:rdf ='http://www.w3.org/1999/02/22-rdf-syntax-ns#'
xmlns:rdfs ='http://www.w3.org/2000/01/rdf-schema#'
xmlns:xsd ='http://www.w3.org/2001/XMLSchema#'>
<rdf:Description rdf:about="http://example.com/dummy_ontology">
<rdf:Description rdf:ID="id_for_this_class">
<rdf:type rdf:resource="http://www.w3.org/2002/07/owl#Class"/>
<rdfs:subClassOf rdf:resource="#dummy_parent" />
<rdfs:subClassOf rdf:resource="#restriction1" />
<rdf:Description rdf:ID="restriction1">
<owl:onProperty rdf:resource='#dummy_property' />
<owl:someValuesFrom rdf:resource='#dummy_target' />
<rdf:Description rdf:ID="dummy_parent">
<rdf:Description rdf:ID="dummy_target">
<rdf:type rdf:resource="http://www.w3.org/2002/07/owl#Class"/>
<rdf:Description rdf:ID="dummy_property">

Figure 2: OWL variancy: The two examples above only differ syntactically from the OWL expression found in figure 1, the content is the same, and both validate as OWL-Lite as well. Cfr. OWL Validator.

3. No explored approaches to align / integrate OWL with current web content.

In my opinion, this is the biggest roadblock that stands in the way of public OWL-adoptation.
For ontological data to truly be useful, you need to somehow tie current web content with semantic classes and instances. OWL has failed miserably in this respect so far. It is much like a far away island of Eden, and a man without a canoe. All the important data could be there but no-one knows how to reach it. Granted, OWL does define a standard format for data interchange between applications, but this limited scope cannot be what the semantic vision is about.

What we need is semantic annotation. You need to be able to tag sections of your content with explicit ontology classes and even relations, without it hindering the display of your content. If you wrote a piece on a certain bordeaux for example, you could mark up the section as being about an instance of wine, perhaps even with some properties defined (or even more amazing, just by knowing it is about wine properties can be extracted automatically, a mention of red is bound to be about the wine color).

Take a look at our freebase widget for the desired search engine functionality. You should be able to look for wine (example), by specifying color, origin, vintageyear and more. The funtionality present on that page is thanks to the Freebase service.
Freebase (big thumbs up) really understands the need to couple instance data (they call it 'Topics') and content (images, text) to semantic classes ('Type' in freebase lingo).

The amazing observation here is that you would not need a service like freebase to pull out this kind of data if:

  • It where possible to directly associate your content with certain units of meaning (semantic classes), something which is referred to as 'semantic annotation'.

  • Search engines would index these annotations.

To achieve this goal we need several things to happen:

  • The ability to easily reference ontological classes; at the least there should be some highly accessible repository(/-ies) of ontological data to which one can refer. This is part of the rationale behind ontologyonline.org and why it offers one page per semantic class, it can be seen as an ontological tag index.

  • The ability to embed semantic content directly and invisibly within (X)HTML.

This brings us back to the topic of this section: the current divide between semantic data and web content. There is hope on the horizon however, there seem to be possibilities, and I'd like to demonstrate one of them in this article: the use of RDFa.
Roughly said, RDFa is a next-generation Microformat. It is a structured mark-up that allows direct inclusion of RDF into XHTML, and seeing that OWL is more or less an extension to RDF an interesting thought would be to try and use RDFa to embed OWL in a web page.

Integration into XHTML markup: the promise of RDFa

This article does not attempt to provide a full introduction to RDFa, for that: see W3C's RDFa Primer. As mentioned above, the use case for the majority of people would be to mark up content with reference to semantic classes (e.g. tag your content as being an instance of semantic class Y). In this experiment however, we focus on embedding OWL class information and ontology information directly within XHTML. Embedding Instance information (as required for the above) should be easier and may be discussed in a later Online Ontology Visualisation blog entry.

As said before, part of ontology online's design is the offer one page per semantic class. This makes referencing a lot easier, instead of having to usi URI's (like an URL, but may also point to sections of a certain page or a given part of a document), you can just use a page URL to retrieve a reference to an ontological class. As will be demonstrated, it also makes the RDFa approach a lot cleaner. Of note, the mark-up has been simplified a little (information not required for this demonstration has been stripped) for easier reading. The figure below demonstrates how the content that has RDFa embedded looks like visually (the RDFa is completely invisible to the user).

Figure: Visual output of the RDFa-embedded XHTML.

Step 0. Being Standards-compliant

This is the only pain-point of embedding RDFa. If you wish to get your page to validate against the W3C-Validator service then you must set up your page properly. This means that, besides the fact that you better have valid XHTML if you wish to extract the RDFa out of the page, you also need to change the DOCTYPE declaration of the page, and the content-type you serve, plus include any namespaces you are using in your document. Beware that changing the DOCTYPE may influence the display of your page a little (css is more strict) and changing the content type may affect javascript functionality. This may not even be a possibility to you. Fortunately, this is only a long-term goal to strive to, the RDFa will still be extractable even with less properly defined doctype & content-type (hence step 0).

<html xmlns="http://www.w3.org/1999/xhtml"
xmlns:rdfs ='http://www.w3.org/2000/01/rdf-schema#'
<meta http-equiv="Content-Type"
content="application/xhtml+xml; charset=UTF-8"/>

Figure: Declarations you need if you wish to be Standards-compliant.

You might notice that when you try to run Ontology Online concept pages through the W3C validator still one error persists: 'Conflict between Mime Type and Document Type'. This is because the server does not yet serve the correct content type (it seems to affect javascript functionality and that is something we do not wish to deal with at this point).

Step 1. Declaring the ontology

On any page describing a semantic class (concept page) the ontology is reference by a 'rev' attribute on an anchor element. 'rev' expresses an inverse relationship in RDFa. In this case we say that the ontology (defined at the target of the 'href' attribute) has an owl:Class (designates a class of the ontology) which is described on this page. The mechanism to declare the ontology itself is not discussed in this article, but can be easily seen by examining the source of any of the ontology html pages at ontologyonline.org.

<a rev="owl:Class"
Cell Type Ontology</a>

Figure: Declaring the ontology on a concept page.

Step 2. Declaring the Class

In RDFa an 'about' attribute is used when talking about something that does not refer to the entire page. Seeing that the resource here is indeed the entire page (the entire page equals the semantic class) we do not use an about 'attribute'. The class is defined simply by adding a class attribute with value owl:Class in the markup. Notice how the markup does not affect the content itself, nor it's display (hint: for those who did not know, it is possible to use multiple classes in html markup, by providing a space-separated list: example class='owl:Class concept blue', css will take into account all of them). The property attribute with value rdfs:label provides a nicer representation name than just 'this page url'. Ideally an xml:lang attribute would be specified as well, denoting that the label is in English for example (xml:lang="en", work in progress).

<h1 class="owl:Class" property="rdfs:label">mature B cell</h1>

Figure: Declaring the semantic class.

The parents are declared on another page, hence a link (anchor element) is used to reference them. By wrapping the anchor element in an additional html element we can specify two relations, firstly that the class expressed on this page has a subclass relationship to something (as expressed by the 'rel' attribute with value 'SubClassOf'). And secondly, that this 'something' is an actual owl:Class, which is very important if we wish to achieve OWL-DL syntax and state that this concerns a parent. We do this by setting the 'rel' attribute on the anchor element to 'owl:Class'. In the figure below two parents are declared:

<span rel='rdfs:SubclassOf'>
<a rel='owl:Class' href='c/CellTypeOntology/B_cell'>B cell</a>
<span rel='rdfs:SubclassOf'>
<a rel='owl:Class'
professional antigen presenting cell</a>

Figure: Declaring Parent(s).

Outgoing relations are specified by taking a similar, yet slightly more complex, approach. The outgoing relation requires a property declaration (type of relation) and a target declaration, another class of the ontology to which the class on this page relates. At this time properties at ontology online do not have their own page just yet, so they are referenced only in text. For the target of a relation a link (anchor element) is used as reference. The top html element with attribute 'rel' and value 'rdfs:SubclassOf' again denotes that the class expressed on this page has another subclass relationship to something. The element underneath it tell us that this subclass relationship is a kind of outgoing relationship (instead of a parent relationship) by having an attribute 'rel' with value 'owl:Restriction'. This element wraps around two elements, one which designates the property (recognized by having the attribute 'property' with value 'owl:onProperty' The second is an anchor element for which the href attribute specifies the target, while the 'rel' attribute 'someValuesFrom' adds some additional logic the relationship (see W3C's OWL language guide for details on someValuesFrom).

Of note, it should be expressed that the property is of the type owl:ObjectProperty and the target is of the type 'owl:Class' to be OWL-DL compliant, again work in progress (still deciding on the most optimal way to convey this...).

<div rel='rdfs:SubclassOf'>
<div rel='owl:Restriction'>
<span property='owl:onProperty'>develops_from</span>
<a rel='owl:someValuesFrom'
href='c/CellTypeOntology/immature_B_cell'>immature B cell</a>

Figure: Declaring Outgoing Relations.

Last thing to do is to add a description and perhaps some additional language terms that define the class described on the page. This is done though 'rdfs:comment' and 'rdfs:label' properties (when the target is text on the same page then the attribute 'property' is used in RDfa). Again, it would be better to also append an xml:lang attribute as well specifying the language of the comment or language term.

<div property='rdfs:comment'>"A mature form of a B cell, a type of
lymphocyte whose defining characteristic is the expression of an
immunoglobulin complex." [GOC:add, ISBN:0781735149]</div>
<span property='rdfs:label'>mature B lymphocyte</span>
<span property='rdfs:label'>mature B-cell</span>
<span property='rdfs:label'>mature B-lymphocyte</span>

Figure: Declaring description and additional language terms.

Testing out: Operator Plugin

It is possible to see how the RDFa extract from any of the concept pages looks like by using a browser plugin: The latest version of Mike Kaply's Operator Plugin recognizes RDFa data embedded within XHTML pages.

Browsing any of the Concept pages on OntologyOnline.org should highlight the 'Resources' button, which should show both the ontology to which the concept belongs (if on a concept page) and OWL-syntax like information about the concept itself:

Browsing an Ontology information page (e.g. Cell Type Ontology) should reveal one resource recognized, the ontology itself.

@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
@prefix owl: <http://www.w3.org/2002/07/owl#> .
@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .


rdf:type owl:Class ;
rdfs:label "neutrophilic promyelocyte" ;
rdfs:label "neutrophilic premyelocyte" ;
rdfs:label "neutrophilic progranulocyte" ;
rdfs:comment ""A neutrophil precursor in the granulocytic series, being a cell
intermediate in development between a myeloblast and myelocyte, and containing
a few, as yet undifferentiated, cytoplasmic granules."
[GOC:add, ISBN:0721601464]" ;
rdfs:SubclassOf [
owl:Restriction [
owl:onProperty "develops_from" ;
owl:someValuesFrom <c/CellTypeOntology/neutrophilic_myeloblast>
] ;
rdfs:SubclassOf [
owl:Class <c/CellTypeOntology/promyelocyte>
] .

Figure: OWL-DL based Syntax extracted from an Ontology Online concept page by the firefox Operator plugin.


To my knowledge, this is a first attempt to finally reconcile OWL-RDFS with standard XHTML web pages.
The extracted RDF (as tested with RDFa Distiller) does not validate as OWL-DL just yet. But this initial venture into OWL-enabled XHTML shows promise. There is room for improvement, so RDF-Guru or not: feedback and suggestions are greatly appreciated.

If you found the content of this article interesting, consider digging it.

Saturday, October 20, 2007

Style and Ajax functionality update.

  • The search and browse sections of the site have been restyled, be sure to check it out (example links: , ATP catabolic process).
  • A new Logo has been put into place.
  • Javascript/ functionality has been upgraded.
  • xHTML markup has been improved, the site is not completely yet (which is hard to achieve for any site using AJAX), but steps have been made in the right direction.

The new style has actually already been in place for more than a week, the reason why this announcement comes with delay is that I experienced some unexpected problems with the Ajax functionality update. The script ran smoothly in Mozilla Firefox, but getting the script to run in Internet Explorer proved to be a debugging nightmare. At first I resorted to write plumbing code to meet crossbrowser inconsistencies, but soon enough I learned a valuable lesson that each Ajax programmer sooner or later learns:

"Rely on a javascript-library / framework instead of writing pathwork code, good frameworks take care of browser incompatibilities in a much more elegant way than one person could possibly implement."

For me, the holy grail has been JQuery. Not only does it smooth out the issues with Internet Explorer, you really can do more yet write less code. The methods I had been trying to implement that met crossbrowser differences or just were generally useful (importnode, clone, remove nodes, get elements by class name, ..) apparently also exist in JQuery, and on top of that their implementation is more elegant and functional than what I ever achieved. So JQuery, I'm officially a fan.

Also discovered another quite funny example of how semantics are missing from search engines (see also the earlier post 'why we need the semantic web'). The sequence Ontology has an entry called ''. One of our ontology widgets pulls images from google to match the concept, but in this case the results are not exactly as expected. Querying a search engine and finding results specifically on 'A Band' as in the 'dark-staining region of a sarcomere' instead of some music-playing people might not be that easy.

Sunday, September 16, 2007

minor application update

The web application has received a small update. Ontology information pages now display more details again (example: GeneOntology information page), this functionality had been broken by the code overhaul we performed this month. In addition we expanded the available namespaces with the sequence ontology, an ontology about gene sequence types and features. The sequence ontology contains 1311 concepts.

Monday, September 10, 2007

Why we need the semantic web

Two search strings with the same syntax can have dramatically different semantics. What if your looking for pages about a less popular topic which happens to share the same syntax as a highly popular yet 'totally irrelevant to you' topic? Finding what you need will take time and ingenuity. The newly introduced concept feeds (external feeds matching the concept of the given page), for example those associated with the concept page on Cells (in it's biological sense), demonstrate our dire need for semantically enabled search engines.

'Cell', as an English term, applies to a wide variety of concepts: 'cell' in the biological sense, 'cell' as in 'cell phone', 'cell' as in prison cell, 'cell' as in an aggregation of people, and many more including some combinatorial uses (e.g. a title for games, novels, etc). No search engine at the moment is capable of disambiguating between these different meanings and filter results accordingly. The books feed will display a novel by Stephen King, and a book about 9/11. The blog feed lists a police break-up of a Nazi-cell, many entries about cell phones and one about solar cells. The Digg news feed is again mainly about cell phones. Imagine if one of them offered the ability to filter results pertaining only to cell in the biological sense, you might imagine that becoming the next-gen search engine.
And that's exactly what ontologies do, provide a means for disambiguating syntactically equal but semantically different items. Ontologies tell you that there are in fact different concepts (owl classes), one being a designed artifact, another a part of an organism, yet another being a certain aggregation of people, etc etc which all share the same language term 'cell'. Knowing this is already half the work.

You could argue that dictionaries might point to you the different semantics as well, yet by browsing the ontology you have easy access along a variety of axes (horizontal & hierarchical) to a plethora of related concepts such as organisms and cell structures for cell in it's biological sense, telephony in the case of cell phones, social groups and people in the case of 'cell' as an aggregation of people.. you get the picture. When using an ontology as a backbone for indexing, you might be able to figure out which concept applies by examining the context in which it is found.

Tagging/Indexing with concepts, as opposed to language terms, might be a core requirement for future search engines.

Sunday, September 9, 2007

Concept Feed Widget, a new level of ontology interaction.

We are pretty excited about some new functionality we added to the Ontology Concept Information Pages. By selecting the appropriate tab button you can now retrieve a list of the most relevant Books, Blog entries and Digg news Items (of any) about the concept itself.
For a quick example: see Domain Ontology - Ontology Directory. This gives you some amazingly focused search results with only one handclick away.

The new Concept feed widget retrieving books about 'domain ontology'.

Monday, September 3, 2007

New OntologyOnline WebApp Version

A new version of the ontologyonline web application has been uploaded.

This marks the completion of the first phase of a major code overhaul. The most important result is that all ontologies now aggregate in one MySQl database.

The biggest change should be noted in the search results section. The search engine now mines all namespaces and the search output provides the ability to filter on both namespace and language (if the results contain terms from multiple languages). I'm hoping the transition went smooth, although a little hiccup here and there is not totally avoidable.

OntologyOnline Search Engine
Screenshot of the search engine in action.

About the search engine

The ontology online search engine differs quite dramatically from regular google/yahoo etc searches. Each ontologyonline web page is about one given unique ontology concept. In contrast to google/yahoo and similar search engines the search is not about retrieving relevant pages which contain the specified search string in text, but about retrieving exact concepts: As such our search engine attempts to match the search string against all names and synonyms (including different languages) of the concepts present in the knowledge warehouse.
If no exact match can be found, a list of partial matches (where the name or synonym contains part of your search string) will be displayed, in alphabetical order.

So if one for example wishes to search for neuroblast, the search string 'neuro' will yield partial matches for, amongst other, 'neuroblast'. Functionality of the engine is expected to increase/improve in the future.

Monday, July 16, 2007

Code overhaul

It's been quiet for some time on the ontology online newsfront, reason is that we are performing a major overhaul of the java code. Currently, each imported ontology for which the content should be preserved as is requires it's own database schema. This imposes some strong limitations, and we are therefore recoding to centralise ontologies to one unique MySQL database schema, this is done by implementing ontology-specific namespaces. It will open up a lot of exciting possibilities once finished (which may take some time). Some
results will be a greatly improved search engine, the possibility to offer a lot more content, etc..

Monday, June 25, 2007

A true semantic web application

OntologyOnline.org was launched in April 2007. It offers one of the first true semantic web applications (often referenced as web 3.0) by allowing users to interact with ontologies at runtime. Ontology Online's proper search engine crawls the available ontologies for exact phrases, but also synonyms and even word fragments, the querying ability is only limited by the content itself, not by the semantics.

As an example illustrating this, when searching organisms with the OntologyOnline search engine the search parameters 'velvet worm', 'spitting worm', 'onychophoran', or even the word fragment 'onyocho' will all lead to the same page describing the Onychophora(e.g. velvet worms) phylum.

The search engine is also accessible by means of a Google Gadget.

Sunday, June 17, 2007

All about OWL - RDF tags.

We have started adding OWL - RDF element tag descriptions and definitions to the Ontology Directory Project at Ontology Online. You might have seen that the official W3C documentation on OWL tends to be quite verbose, with the Ontology Directory Project we wish to provide a focused, comprehensive and quickly accessible description of the OWL language.
The benefits of this projects are that by offering documentation in the form of an ontology you can deliver indepth information without having to resort to lengthy text-descriptions which repeat a lot of the same information.

For an example see owl:class definition, where the hierarchy around this concept and the horizontal relations attributed to this concept provide a level of detail you would only be able to express textually by writing several paragraphs of information.

Monday, May 14, 2007

The Ontology directory

I've started putting together an ontological directory of existing third-party ontologies, controlled vocabularies , terminologies, and more.
While it is still incomplete, I expect it to grow substantially in the nearby future.

To browse: Ontology Directory

Tuesday, May 8, 2007

Dynamically Generated Ontology Pages

We are in the process of updating the website with dynamically generated ontology pages and searchbox functionality for content.
For a preview (still under construction) please see:
Online Ontology Browsing.

Friday, May 4, 2007

Blog creation

This blog has been created by Ontology Online.
Its purpose is to discuss possibilities in online ontology visualisation (website integration) and use.