For more news, see the news archive.

2023-11-09

Grundfos' Industrial Ontology Engineering Platform uses OTTR. Read all about it in their ISWC 2023 industry paper: Building an Industrial Ontology Engineering Platform, and in https://medium.com/wallscope/developing-ontology-tools-with-grundfos-d84a961bd4cd.

2023-11-07

Moritz Blum et al. shares Insights from an OTTR-centric Ontology Engineering Methodology at WOP@ISWC2023.

2022-08-17

On 2022-08-31 we are giving a talk on OTTR at OntoCommons Workshop on Ontology Engineering and Knowledge Graphs tool ecosystem. Registration is free and open!

2022-08-15

Our paper on abbreviations for complex OWL expressions has been accepted at KGSum 2022.

2022-07-08

Our paper on syntactic modelling structures in ontologies [1] has been accepted at ISWC 2022.

2022-04-04

Please register for the 3nd OTTR user forum which will take place physically and co-located with the general assembly of SIRIUS.

2022-03-16

We are very happy to see that Veronika Heimsbakk, CapGemini is giving a tutorial on OTTR and a talk on the use of OTTR "Growing Your Graph With OTTR" at The Knowledge Graph Conference (https://www.knowledgegraph.tech/) More information here:

• https://www.knowledgegraph.tech/speakers/veronika-heimsbakk/
• https://veronahe.wordpress.com/2022/05/03/the-shape-of-otters/

Reasonable Ontology Templates (OTTR) is a framework and language for representing ontology modelling patterns, and is designed to support interaction with OWL or RDF knowledge bases at a higher level of abstraction, using modelling patterns rather than OWL axioms or RDF triples. This includes:

• building knowledge bases by instantiating templates;
• communicating (presenting, transferring and visualising) the knowledge base as a set of template instances at different levels of abstraction; and
• securing and improving the quality and sustainability of the knowledge base via structural and semantic analysis of the templates used to construct the knowledge base.

OTTR templates and instances can be represented in stOTTR—a custom-built format similar to and based on RDF Turtle—or in RDF using the wOTTR vocabulary. Instances may also be generated from spreadsheets using tabOTTR or with mappings over various queryable sources using bOTTR. Our reference implementation Lutra supports these formats, and a web interface WebLutra is available for testing. See also the interactive examples below.

The project is in active development.

Template instances

The Pizza ontology is a well-known OWL tutorial ontology. The ontology models the domain of pizzas and contains many specific types of pizzas, such as Margherita. The Margherita pizza is modelled as subclass of NamedPizza, originating from Italy and having exactly the toppings Tomato and Mozzarella, here shown in Manchester syntax:

Class: Margherita

    SubClassOf: 
        NamedPizza,
        hasCountryOfOrigin some { Italy },
        hasTopping some Mozzarella,
        hasTopping some Tomato,
        hasTopping only 
            (Mozzarella or Tomato)

The ontology contains 22 such types of pizzas, all following the same modelling pattern as the Margherita pizza. Since this pattern is not represented as a pattern (as no such concept exists in OWL), tasks that are important for the efficient use and management of the ontology, such as finding pattern instances, verifying consistent use of the pattern, and updating the pattern, may require considerable repetitive and laborious effort.

Using OTTR, we can record the pattern as an OTTR template, called, o-pizza:NamedPizza, which takes 3 arguments: the name or IRI, an optional country of origin, and a list of toppings; and easily make multiple instances of the pattern. Click "Run" below to expand the instances using WebLutra.

o-pizza:NamedPizza(ex:Margherita, ex:Italy, (ex:Mozzarella, ex:Tomato)) . o-pizza:NamedPizza(ex:Hawaii, none, (ex:Cheese, ex:Ham, ex:Pineapple)) .

The design of the pattern, the OTTR template, is kept in a single location definition and can be updated without changing the instances of the templates (unless the input arguments must also be updated). In the above example the template definition is fetched from its IRI address when the instances are expanded.

This screen recording shows how the example is expanded with our reference implementation Lutra.

Lutra is our open source (LGPL licence) reference implementation of the OTTR language. Lutra can read and write OTTR templates and instances on different serialisation formats, and expand instances into regular RDF graphs. Lutra is written in Java and is available as a command line interface, and as feature limited version web application: https://weblutra.ottr.xyz/

• https://gitlab.com/ottr/
• Releases
• Source code
• Issues

java -jar lutra.jar --version
java -jar lutra.jar --help

0.6.19
Usage: lutra [-fhV] [--debugStackTrace] [--quiet] [--stdout] [-F=<fetchFormat>]
             [--haltOn=<haltOn>] [-I=<inputFormat>] [-L=<libraryFormat>]
             [-m=<mode>] [--messageLinePrefix=<linePrefix>] [-o=<out>]
             [-O=<outputFormat>] [-p=<prefixes>] [-e=<extensions>[,
             <extensions>...]]... [-E=<ignoreExtensions>[,
             <ignoreExtensions>...]]... [-l=<library>]... [<inputs>...]

DESCRIPTION:
Reference implementation for OTTR Templates. Use for expanding template
instances and template definitions, translating between different formats and
for checking the integrity of template libraries.

PARAMETERS:
      [<inputs>...]         Files of instances to which operations are to be
                              applied.

OPTIONS:
      --debugStackTrace     This enables printing a regular java stack trace
                              for error messages.Enabling this flag will not
                              deteriorate performance.
                            default: false)
  -e, --extension=<extensions>[,<extensions>...]
                            File extension of files to use as input to template
                              library.
                            (default: [])
  -E, --ignoreExtension=<ignoreExtensions>[,<ignoreExtensions>...]
                            File extensions of files to ignore as input to
                              template library.
                            (default: [])
  -f, --fetchMissing        Fetch missing template dependencies. It is here
                              assumed that templates' definitions are
                              accessible via their IRI, that is, the IRI is
                              either a path to a file, a URL, or similar.
                            (default: false)
  -F, --fetchFormat=<fetchFormat>
                            The input format of the templates fetched via the
                              -f flag (registered formats: wottr, stottr)
  -h, --help                Show this help message and exit.
      --haltOn=<haltOn>     Halt execution upon receiving messages with a
                              severity equal to or greater than this value.
                            (legal values: INFO, WARNING, ERROR, FATAL;
                              default: ERROR)
  -I, --inputFormat=<inputFormat>
                            Input format of instances.
                            (registered formats: wottr, stottr, tabottr, bottr
                              default: wottr)
  -l, --library=<library>   Folder containing templates to use as library. Can
                              be used multiple times for multiple libraries.
  -L, --libraryFormat=<libraryFormat>
                            The input format of the libraries. If omitted, all
                              available formats are attempted.
                            (registered formats: wottr, stottr)
  -m, --mode=<mode>         The mode of operation to be applied to input.
                            (legal values: expand, expandLibrary, format,
                              formatLibrary, lint, checkSyntax, docttrLibrary;
                              default: expand)
      --messageLinePrefix=<linePrefix>
                            Set line prefix for output messages (use e.g. '#'
                              to make output become comments).
                            (default: )
  -o, --output=<out>        Path for writing output.
  -O, --outputFormat=<outputFormat>
                            Output format of output of operation defined by the
                              mode.
                            (registered formats: wottr, stottr, tabottr, bottr;
                              default: wottr)
  -p, --prefixes=<prefixes> Path to RDF file containing prefix declarations to
                              be used when rendering output.    Any other data
                              in the file is read, but ignored.
      --quiet               Suppress all messages, including errors and
                              warnings.
                            (default: false)
      --stdout              Print system of operations to standard out.
                            (default: false)
  -V, --version             Print version information and exit.

LINKS:
Website:  https://ottr.xyz
Primers:  https://primer.ottr.xyz
Git repo: https://gitlab.com/ottr/lutra/lutra

The OTTR language is formally defined in a series of specifications listed below. For a more light-weight introduction to OTTR, visit the primer: https://primer.ottr.xyz

Concepts and Abstract Model for Reasonable Ontology Templates (mOTTR)

mOTTR defines the fundamentals of OTTR.

• Release: https://spec.ottr.xyz/mOTTR/0.1/
• Development: https://dev.spec.ottr.xyz/mOTTR/

Adapting Reasonable Ontology Templates to RDF (rOTTR)

rOTTR specifies how mOTTR is adapted to fit the RDF.

• Release: https://spec.ottr.xyz/rOTTR/0.2/
• Development: https://dev.spec.ottr.xyz/rOTTR/

Web Reasonable Ontology Templates (wOTTR)

wOTTR defines a RDF serialisation format for OTTR.

• Release: https://spec.ottr.xyz/wOTTR/0.4/
• Development: https://dev.spec.ottr.xyz/wOTTR/

Terse Syntax for Reasonable Ontology Templates (stOTTR)

stOTTR defines a compact serialisation format for OTTR, aimed to be easy to read and write.

• Release: https://spec.ottr.xyz/stOTTR/0.1/
• Development: https://dev.spec.ottr.xyz/stOTTR/

Tabular Reasonable Ontology Template Instances (tabOTTR)

tabOTTR defines a input format for bulk OTTR template instantiation for tabular file formats such as CSV, TSV and Excel spreadsheets.

• Release: https://spec.ottr.xyz/tabOTTR/0.3/
• Development: https://dev.spec.ottr.xyz/tabOTTR/

Batch Instantiation of OTTR templates (bOTTR)

An Extract-Transform-Load (ETL) mapping language for instantantiating OTTR templates from existing external sources.

• Release: https://spec.ottr.xyz/bOTTR/0.1/
• Development: https://dev.spec.ottr.xyz/bOTTR/

A library of published OTTR templates is available at tpl.ottr.xyz.

This library contains many templates that model common patterns for the W3C standards OWL, RDFS and RDF. The library also includes other more complex patterns that are useful for understanding how OTTR templates may be built and used.

Our intention is that this library will grow to contain OTTR templates for many useful patterns and for many prominent vocabularies. A set of guidelines for managing the library is under development.

Note: The library of templates in the "legacy" version of the wOTTR format is now outdated and no longer available through the service at library.ottr.xyz. However, they are still available at their IRI, and at the archived repositories https://gitlab.com/ottr/candidate/ and https://gitlab.com/ottr/draft/.

We have yet to properly specify and formally evaluate a tool-supported methodology for the development and maintenance of knowledge bases using OTTR templates. However, we believe the abstraction mechanism that OTTR templates provide can work in a similar manner as application programming interfaces (APIs) work for programming and software engineering. We anticipate the following roles for such a methodology:

Template library designer

This is the designer and maintainer of the basic and core template libraries. The job of the library designer is to construct well-designed interfaces, i.e., capture modelling patterns using OTTR templates, for basic RDF and OWL vocabularies, such as the RDF and OWL vocabularies themselves, but also other vocabularies like SKOS, Dublin Core, BFO, and possibly also special purpose vocabularies like Galen where ontological expertise is required to correctly understand the vocabulary. Hence, this role requires good insight into the underlying logical languages, i.e., RDF and OWL, and the OTTR language. There is currently no special-purpose editor for this role; we recommend that you use your favourite text-editor to create templates "by hand" in stOTTR syntax, and use Lutra to check the correctness of your templates.

Template programmer

The job of the template programmer is to bridge the abstractions over the logical vocabulary created by the template library designer with the conceptualisation of domain experts. The is achieved by creating user-facing templates that combine and restrict already existing templates available in template libraries, to create new templates that capture specific modelling patterns for given tasks. The programmer must have a firm grasp on the users' needs and task, but need "only" to understand the templates in the library and to lesser extent understand the formal logic that underlies these templates. This requires that the templates in the library are well-documented. The user-facing templates form the interface for data input (and possibly output) that is presented to the domain expert. There is currently no tool support for this role, other than what is available to the library designer. We have ideas for a standalone tool to support the template programmer.

Domain expert

The domain expert is equipped by the template programmer with a well-designed set of user-facing templates. However, for the domain expert these templates present themselves only in the form of structurally simple spreadsheet formats, i.e., tabular forms with column headers and explanations. We assume that it is possible to create such formats that lie close to the domain experts existing conceptualisation of the domain. This would make them easy to understand and use. "Using" means here 1) creating template instances by filling in data row in the tabular format, or 2) using the format as a query, in which the results of the query will be presented as data rows in the same format. The tabOTTR specification and Lutra provide support for this user role.

An input format prepared by the template programmer and filled with data by the domain expert can, using the template expansion mechanism, be consistently translated into a knowledge base using the vocabulary prescribed by the templates. The separation of responsibility between the roles allows a single template library designer to serve multiple template programmers, which in turn can serve multiple domain experts. This fits the skill and tools sets that information modelling projects typically have available, e.g., domain experts are used to working with spreadsheets and rarely have the competence required for working with ontology editors, while there are usually fewer people that have the required logical background and competence for building and maintaining semantic knowledge bases.

The technology surrounding and theory underlying OTTR is under active development, and the use of OTTR templates for construction of sustainable knowledge bases is gaining industrial interest.

All our publicly available development is available at GitLab: gitlab.com/ottr, where our work is organised into different subgroups and repositories:

• Lutra,
• specifications, and
• template library

Our future plans are to develop:

• new version of Lutra with increased performance and with a code-base that is better suited for template library analysis
• formal specification of OTTR serialisation formats
• better understanding of industrial requirements
• updated template library and library maintenance procedures and tools
• translating templates to SPARQL queries
• improved techniques for template library analysis
• specialised tools for designing templates
• visualisation and presentation tools for templates
• formalised methodology for constructing ontologies
• support for more input data formats

We have also done experimental work on:

• translating templates to SAWSDL annotated XSD format descriptions
• translating templates to XSLT transformations from XML on generated XSD formats to expanded RDF/XML

Different theoretical foundations for OTTR templates have been examined:

• OTTR templates as RDF macros [4]
• OTTR templates as parameterised description logic knowledge bases [8]

For the implemented version of OTTR templates, which is the version presented throughout these webpages, we consider OTTR templates as RDF macros: The OTTR template functionality is implemented as a recursive, non-cyclic macro mechanism for RDF statements, where OTTR template instances are unfolded into a regular RDF or RDF/OWL knowledge base by recursively replacing template instances with their definition. This process terminates with a set of base templates that directly represent a knowledge base on RDF or RDF/OWL format.

For more information, check out our Publications.

Tutorials and demos are kept on seperate pages:

• Pattern-based knowledge base construction at ISWC 2020

  Abstract

  A major barrier for the adoption of semantic web technologies in industry is the construction of sustainable knowledge bases; domain experts and end-users often find semantic web languages and tools difficult to use. Reasonable Ontology Templates (OTTR) is a language and framework that allows abstractions or modelling patterns over RDF/OWL to be succinctly represented and instantiated. It is designed to address the needs and expertise domain experts, ontology engineers, and data managers in the process of creating and maintaining high-quality, maintainable knowledge bases. The tutorial will give an introduction to the OTTR framework, discuss modelling best practices for sustainable knowledge bases using templates and demonstrate practical use templates. The tutorial is relevant for semantic web practitioners and ontology engineers who are eager to make efficient use of modelling patterns in their work, and for information managers from industry looking for possible ways to introduce ontology development into their enterprise.

• Scalable construction of sustainable knowledge bases at ISWC 2019

  Abstract

  A major barrier for the adoption of semantic web technologies in industry is the construction of sustainable knowledge bases; domain experts and end-users often find semantic web languages and tools difficult to use. Reasonable Ontology Templates (OTTR) is a language and framework that allows abstractions or modelling patterns over RDF/OWL to be succinctly represented and instantiated. It is designed to address the needs and expertise domain experts, ontology engineers, and data managers in the process of creating and maintaining high-quality, maintainable knowledge bases. The tutorial is relevant for semantic web practitioners and ontology engineers who are eager to make efficient use of modelling patterns in their work, and for information managers from industry looking for possible ways to introduce ontology development into their enterprise.

• Practical and Scalable Pattern-based Ontology Engineering with Reasonable Ontology Templates at ESWC 2019

  Abstract

  Learn how to build, maintain and interact with knowledge bases via higher level abstractions and modelling patterns using the OTTR templating framework.

• International Industrial Ontologies Foundery (IOF) Workshops 2019 Tutorial: Ontology patterns in practice

  Abstract

  A major bottleneck for the successful adoption of ontology-based information systems in industry is the construction and maintenance of large-scale ontologies. This tutorial will introduce Reasonable Ontology Templates (OTTR), a framework for ontology construction and maintenance based on efficient representation and instantiation of modelling patterns. The participants will learn how such ontology abstraction mechanisms can be beneficial for building, interacting with, and maintaining large-scale ontologies. The tutorial will consist of presentations, plenary and individual exercises using open source tooling. Participants that wish to take part in the individual exercises should bring a laptop with Java 8 installed.

• Online demo for ISWC 2018 demo paper + poster
• Companion text ISWC 2017 poster paper + poster

• OntoCommons Workshop on Ontology Engineering and Knowledge Graphs tool ecosystem 2022-08-31, Reasonable Ontology Templates, Martin G. Skjæveland.
• 3rd OTTR user forum 2022-05-11, OTTR team + invited talks.
• UiO/SIRIUS general assembly, Ontology Engineering Research Program + Reasonable Ontology Templates, Martin G. Skjæveland.
• 2nd OTTR user forum 2021-06-18, OTTR team + invited talks.
• 1st OTTR user forum 2021-01-28, OTTR team + invited talks.
• Presentation for Strategic Advisory Committee at the Faculty of Mathematics and Natural Sciences UiO 2019-11-28, OTTR Templates, Martin G. Skjæveland.
• OSDU workshop 2019-10-08, OTTR: Scalable construction of sustainable knowledge bases, Martin G. Skjæveland and Dag Hovland.
• UiO/SIRIUS General Assembly 2019-05-23, Ontology engineering for industrial applications using Reasonable Ontology Templates(OTTR), Martin G. Skjæveland.
• CapGemini semantics workshop 2019-04-26, Reasonable Ontology Templates, Martin G. Skjæveland.
• ISWC 2018 research track: Reasonable Ontology Templates, Martin G. Skjæveland.
• ISWC 2018 industry track: Semantic Material Master Data Management at Aibel, Anders Gjerver (Aibel) and Martin G. Skjæveland.
• UiO/SIRIUS Seminar 2018-08-27, Reasonable Ontology Templates, Martin G. Skjæveland, Leif Harald Karlsen and Daniel Lupp.
• UiO/SIRIUS workshop with University of Western Australia 2018-08-15, Reasonable Ontology Templates, Martin G. Skjæveland, Leif Harald Karlsen and Daniel Lupp.
• Bielefeld University visit 2018-06-05, Reasonable Ontology Templates, Martin G. Skjæveland, Leif Harald Karlsen and Daniel Lupp.
• Uni Bremen visit 2018-06-04, Reasonable Ontology Templates, Martin G. Skjæveland and Leif Harald Karlsen.
• SIRIUS' Industrial Ontology Colloquium 2018-04-13: Programming semantics: practical applications of OTTR, Leif Harald Karlsen.
• TU Wien visit 2017-11-30, Reasonable Ontology Templates—When macros are more than just macros, Daniel Lupp.
• Workshop on Ontology Design and Patterns 2017: Reasonable Ontology Templates, Martin G. Skjæveland.
• SIRIUS' Industrial Ontology Colloquium 2017-09-29: Reasonable Ontology Templates, Martin G. Skjæveland.
• SIRIUS' Industrial Ontology Colloquium 2017-03-03: Ontology Templates, Martin G. Skjæveland.

The OTTR logo is created by SHS. It comes in different variations:

OTTR

Lutra

mOTTR

rOTTR

wOTTR

stOTTR

stOTTR

bOTTR

tabOTTR

tutOTTR

demOTTR

pOTTR

lOTTR

docTTR

emacs-ottr-toolkit

OTTR-log

Alexander Kielland

2023-11-09

Grundfos' Industrial Ontology Engineering Platform uses OTTR. Read all about it in their ISWC 2023 industry paper: Building an Industrial Ontology Engineering Platform, and in https://medium.com/wallscope/developing-ontology-tools-with-grundfos-d84a961bd4cd.

2023-11-07

Moritz Blum et al. shares Insights from an OTTR-centric Ontology Engineering Methodology at WOP@ISWC2023.

2022-08-17

On 2022-08-31 we are giving a talk on OTTR at OntoCommons Workshop on Ontology Engineering and Knowledge Graphs tool ecosystem. Registration is free and open!

2022-08-15

Our paper on abbreviations for complex OWL expressions has been accepted at KGSum 2022.

2022-07-08

Our paper on syntactic modelling structures in ontologies [1] has been accepted at ISWC 2022.

2022-04-04

Please register for the 3nd OTTR user forum which will take place physically and co-located with the general assembly of SIRIUS.

2022-03-16

We are very happy to see that Veronika Heimsbakk, CapGemini is giving a tutorial on OTTR and a talk on the use of OTTR "Growing Your Graph With OTTR" at The Knowledge Graph Conference (https://www.knowledgegraph.tech/) More information here:

• https://www.knowledgegraph.tech/speakers/veronika-heimsbakk/
• https://veronahe.wordpress.com/2022/05/03/the-shape-of-otters/
• https://github.com/veleda/ottr-masterclass

2021-05-28

Join the 2nd OTTR user forum. Registration is free.

2021-05-10

Two new introductional videos about OTTR are published: one video lecture by Leif Harald Karlsen on the basic language constructs of OTTR, and one live coding session by Daniel Lupp on how to incrementally build a small template library using a top-down approach.

2020-12-11

Please join us at the 1st OTTR user forum for the latest news and discussions with OTTR users. Invited talk by Johan W. Klüwer. Registration is free.

2020-10-01

Our paper on the design principles, content and management of the core OTTR template library has been accepted for WOP2020. The paper will be part of the upcoming book: "Advances in Pattern-based Ontology Engineering".

2020-09-13

Our paper "Template Libraries for Industrial Asset Maintenance: A Methodology for Scalable and Maintainable Ontologies" [3] with Melinda Hodkiewicz has been accepted for SSWS 2020.

2020-05-20

Extended versions of our WOP17 and WOP18 papers " Pattern-Based Ontology Design and Instantiation with Reasonable Ontology Templates" [6] and "Making a Case for Formal Relations over Ontology Patterns" [3] will appear as chapters in the forthcoming book "Advances in Pattern-based Ontology Engineering" published by IOS Press.

2020-03-04

We will be giving a tutorial on OTTR templates at ISWC 2020 titled: Pattern-based knowledge base construction.

2019-10-24

The pOTTR OTTR Primer is released! See https://primer.ottr.xyz/

2019-02-14

We will be giving a tutorial on OTTR templates at ISWC 2019 titled: Scalable construction of sustainable knowledge bases.

2019-02-01

Lutra version 0.5.0-alpha-3 is released: https://gitlab.com/ottr/lutra/lutra/releases. Please test and give us feedback.

2018-12-03

We will be giving a tutorial on OTTR templates at ESWC 2019 titled: Practical and Scalable Pattern-based Ontology Engineering with Reasonable Ontology Templates.

2018-11-20

OTTR templates will be presented at the International Industrial Ontologies Workshops in Oslo February 2019: Ontology patterns in practice.

2018-10-10

Our ISWC research paper [4] is nominated for best paper award.

2018-06-27

Our short paper "Making a Case for Formal Relations over Ontology Patterns" [3] is accepted for the Workshop of Ontology Design Patterns (WOP2018)

2018-06-18

Our ISWC demo paper [5] demonstrating the results of our ISWC research paper [4] is accepted.

2018-05-28

Our paper "Practical Ontology Pattern Instantiation, Discovery, and Maintenance with Reasonable Ontology Templates" [4] is accepted for ISWC's research track.

If you have a question or technical issue with OTTR, please use our gitter forum: https://gitter.im/ottr-talk

Or, use one of these issue trackers:

• Lutra
• Template library
• Specifications: mOTTR, wOTTR, stOTTR, tabOTTR, bOTTR

Iff your inquiry does not suit the format of an issue, you can email the lead developer of OTTR, Martin G. Skjæveland [email protected].