• Tawny-OWL is fully programmatic environment for Ontology Development

  • Presents a different model of ontology development

  • Very powerful

  • Allows reuse of commodity tooling


  • Some taught material

  • Some "follow-by-leader"

  • Plenty of time for questions

  • A flexible tail


Today, we will have some taught material, particularly at the beginning and the end, where I need to describe parts of the system, some practical time where we build a small ontology using tawny. Then I have a reasonably flexible tail where I try and address questions that people have. Also, there is a degree of guesswork into how much material I can get into the time available, which this helps to address.

I do not have time to describe all of the features of tawny, nor give a full tutorial.


  • Attempted to make decoupled

  • Aware that people will come in and out

  • Probably not be entirely successful at this.

  • Gets more programmatic as we go on

  • Will not explain all of the programming


Although the tutorial does "build" I have tried to make it as loosely coupled as possible, although the truth be told, I have probably not been entirely successful at this.

The latter half requires more programming knowledge, and there is probably little that I can do about this. I will skip over what some of it means, in the hope that those who care can go back later and look it up. I do not want this to become a Clojure tutorial.

Knowledge Prerequisites

  • Required

    • Basic knowledge of ontologies

    • Basic knowledge of OWL

    • Basic knowledge of biology (amino-acids!)

    • For last 1/3: Basic Programming Knowledge

  • Not Required

    • Knowledge of Clojure

    • Knowledge of OWL API

    • Knowledge of Tawny-OWL


  • Understand the motivation behind Tawny

  • Understand and use basic Clojure infrastructure

  • Build a basic ontology with Tawny

  • Understanding pattern usage within Tawny

  • Implementing a pattern

  • Extending Tawny locally

Secondary Outcomes

  • Understand how to repurpose software tooling for ontologies

Notes on Notes

  • All materials are available

  • These slides (2015_lisbon.html)

  • As a book with lecture notes (2015_lisbon_book.html)

  • Same thing as PDF (but less well checked!).


  • Tawny-OWL was initially an accidental tool

  • We did not start off writing a new environment

  • We discovered we needed while trying to build an ontology

Use Case (chromosomes)

  • The human karyotype is complex to describe

  • Alterations more so


We didn’t start out to develop a new ontology engineering tool. It happened along the way, as we tried at address a specific use case, which was modelling human karyotypes.

Use Case (karyotypes)

  • Current, representation comes from ISCN

  • Written in a book, no computational representation.

  • 47,XXY

  • 46,Xc,+21

  • 46,XY,+21c,-21

  • 45,XY,-10,der(10)t(10;17)(q22;p12)

  • 46,XY,der(7)t(2;7)(q21;q22)ins(7;?)(q22;?)

  • 46,XX,der(8)t(8;17)(p23;q21)inv(8)(p22q13)t(8;22)(q22;q12)

  • 46,XX,der(9)del(9)(p12)t(9;22)(q34;q11.2),der(9)t(9;12)(p13;q22)inv(9)(q13q22)

  • An ontological representation seems like a nice idea

The current representation goes back to the days of type writers. The specification is not machine interpretable, the ISCN strings themselves are not interpretable, in fact, you cannot even represent them fully in ascii because they use meaningful underlines.

A partonomy?

  • What you see is what you get?

  • There are 23 chromosomes

  • Around 1000 bands, at different resolution levels.



  • Could do this in protege

  • Technically, it scales well to an ontology of this size


Technically, 1000 terms is not a problem for protege, it can scale to this size (or, indeed, considerably larger) with relative easy.


  • But the user interface does not

  • Generating many similar classes is painful

  • Hard to know how an axiomatisation will perform at the start

  • Changing them afterwards even worse