# 13.2: Project Assignment

The project assignment aims to let you explore in more detail a specific subtopic within ontology engineering. There is enough variation in the list of topics below to choose either a software development project, literature review, experimentation, and occasionally a bit of research. The two subsections below could be used as is or function as a template for one’s own specification of constraints and more or less project topics.

## Suggested Set-Up of the Assignment

The aim of this assignment is to work in a small group (2-4 students) and to investigate a specific theme of ontology engineering. The topics are such that either you can demonstrate the integration of various aspects of ontologies and knowledge bases or going into quite some detail on a single topic, and it can be either theory-based, implementation-focused, or a bit of both.

Possible topics to choose from will be communicated in week x, and has to be chosen and communicated to me (topic $$+$$ group members) no later than in week x+1, else you will be assigned a topic and a group.

1. Form a group of 2-4 people and choose a topic, or vv.: choose a topic and find other people to work with. It should be mentioned in the material you will hand in who did what.
2. Carry out the project.
3. Write about 4-6 pages (excluding figures or screenshots) summarizing your work. The page limit is flexible, but it surely has to be $$<$$ 15 pages in total.
4. Give a presentation of your work during the last lecture (10 minutes presentation, $$±$$5 minutes discussion). Everyone must attend this lecture.

### Material to Hand in

You have to upload/email the following items:

1. The write up.
2. Additional material: this depends on the chosen topic. If it is not purely paper-based, then the additional files have to be uploaded on the system (e.g., software, test data).
3. Slides of the presentation, if any.

Note that the deadline is after the last lecture so that you have the option to update your material for the mini-project with any feedback received during the presentation and discussion in class.

### Assessment

1. Concerning the write up: a synthesis is expected, not a diary. For instance, “We explored a, b, and c, and b was deemed to be most effective because blabla” would be fine, but not “We tried a, but that didn’t work out, then we had a go at b, which went well, then we came across c, tried it out of curiosity, but that was a dead end, so we went back to b.”. In short: try to go beyond the ‘knowledge telling’ and work towards the so-called knowledge transformation.
2. Concerning the write up: use proper referencing when you use something from someone else, be it an ontology, other reused online resources (including uncommon software), textbooks, articles etc. Not doing so amounts to plagiarism, which has a minimum penalty of obtaining a grade of 0 (zero) for the assignment (for all group members, or, if thanks to the declaration of contribution the individual can be identified, then only that individual), and you will be recorded on the departmental plagiarism list, if you are not already on it, and further steps may be taken.
3. The presentation: respect the time limit, coherence of the presentation, capability to answer questions.
4. Concerning any additional material (if applicable): if the software works as intended with the given input, presentability of the code.
5. Marks will be deducted if the presentation or the write-up is too long.

### Notes

Things you may want to take into consideration (listed in random order):

1. $$\LaTeX$$ is a useful typesetting system (including beamer for presentation slides), has a range of standard layouts as well as bibliography style files to save you the trouble of wasting time on making the write up presentable, and generates a pdf file that is portable2.This is much less so with MS Word; if you use MS Word nevertheless, please also include a pdf version of the document.
2. Regarding the bibliography: have complete entries. Examples of referencing material (for conference proceedings, books and book chapters, and journal articles) can be found in the scientific papers included in the lecture notes’ bibliography, scientific literature you consult, or $$\LaTeX$$ documentation.
3. Spell checkers tend to be rather useful tools.
4. One or more of the domain ontologies developed in the previous assignment may be suitable for reuse in your chosen topic.
5. Some of the mini-projects lend themselves well for extension into an Honors/Masters project, hence, could give you a head-start.

## Topics

You can select one of the following topics, or propose one of your own. If the latter, you first will have to obtain approval from you lecturer (if you are doing this assignment as part of a course).

The topics are listed in random order, have different flavors or emphases; e.g., more of a literature review project, or programming, or theory, or experimentation. The notes contain pointers to some more information, as does the corresponding section in the book.

Some descriptions may seem vague in that it still offers several possibilities with more or less work and/or more or less challenging activities; this is done on purpose. You should narrow it down as you see fit—bearing in mind the aims of the mini-project and the number of people in your group—and be able to justify why if asked to do so. If you choose a topic that involves processing OWL files, then try to use either the OWL API (for Java-based applications) or Owlready (Python), the Jena Toolkit (or similar), or OWLink, rather than spending time reinventing the wheel.

You probably will find out it’s not as easy as it looked like initially, which may make it tempting wishing to change, but that also holds for the other topics, and by changing topic you very likely have lost too much time to bring the other one to passable completion.

Some topics can be done by more than one group simultaneously, after which it can be interesting to compare what came out of it. Based on my experience of previous years, these include topic numbers 5, 7, 14, 16, and 19.

1. Consider the Lemon model for monolingual and multilingual ontologies [MdCB+12, MAdCB+12]. Apply it to an ontology you developed for the practical assignment. You can choose any natural language, as long as it is a different one from the one the ontology is developed in or requires some redesign to bring it in line with best practices on the ontology-language interface.
2. There are some 15 working automated reasoners for various Description Logics (e.g., HermiT, FaCT$$++$$, TrOWL, Pellet, Racer, ELK, MoRE, Quonto, Quest). Conduct a comparison with a sensible subset, including their performance on a set of ontologies you select or create artificially, and possibly also along the direction of examining the effect of the use of different features in the ontology. Some ideas may be gleaned from the “short report” in the proceedings of the Ontology Reasoner Evaluation workshop3.
3. Write a literature review about ontology-driven NLP or ontology-enhanced digital libraries (minimum amount of references to consider depends on group size and whether this is an undergraduate or postgraduate course).
4. Set up an OBDA system (that is not one of the samples of the Ontop website). You are advised to either reuse your ontology from the practical assignment or take an existing one. Regarding data, you may want to have a look at the GitHub list of publicly available data sets4, or you can create a mock database.
5. There are various ways to verbalize an ontology (e.g., $$\forall$$ as ‘each...’ or ‘for all ...’, using the opposite, etc.). Write a web-based or stand-alone application that verbalizes an ontology in a natural language of choice, where users will be able to choose their verbalization. Some of the examples you may want to check out are the Attempto project5, the discussion in [SKC+08], results with isiZulu [KK17a] or Afrikaans [STK16] in case you’re in South Africa, or either of the review articles [BACW14, SD17].
6. Create a decision diagram for BFO or GFO, alike the D3 of FORZA, and validate it (e.g., by checking whether extant ontologies linked to BFO or GFO were linked correctly).
7. There are many works on criteria to evaluate the quality of an ontology or an ontology module (e.g., [McD17, PVSFGP12, Vra09]). Provide an overview and apply it to several of your classmates’ ontologies developed in the practical assignment and/or ontologies taken from online repositories. In a larger group, this may also include evaluating the evaluation strategies themselves.
8. Take a thesaurus represented in SKOS6 and convert that into a real ontology (i.e., not simply only converting into OWL). There are manual and semiautomated approaches.
9. Compare and contrast tools for ontology visualization (i.e., their graphical renderings in, e.g., Ontograf, OWLGrEd, SOVA, and so on).
10. OWL (and DL) is claimed to provide a ‘unifying paradigm’ for several knowledge representation languages. Evaluate this claim, taking into consideration Common Logic as alternative ontology language that makes the same claim.
11. Conduct a literature review on, and, where possible, test, several so-called ‘non-standard reasoning’ reasoners. Among others, you could consult one of the least-common subsumer papers [PT11], and/or reasoner-mediated ontology authoring tools [FR12, Fer16], among others.
12. Write a plugin for Semantic MediaWiki such that an ontology can be used during the page editing stage; e.g., to have the hierarchy with terms (classes, object/data properties) on the left-hand side of the screen, and easily pick one of them, adding the annotation to the text automatically. Another idea for a semwiki plugin you may have may be considered (but check out first which ones are already there).
13. Compare and contrast the two OntoClean implementations [GRV10, Wel06], including experimental assessment.
14. Translational Research and the Semantic Web. Students should study and analyze the ‘old’ paper “Advancing translational research with the Semantic Web” [RCB+07]. For the report, you can envision yourself as a consultant to the authors (from W3C’s HCLS IG7) and suggest them improvements to what they did, given that a lot of new material has been developed over the past 12 years.
15. Consider bottom-up ontology development starting from a conceptual data model (e.g., UML class diagrams, EER). Find a way to generate an OWL file from it such that it provides candidate classes, object properties, and constraints for an actual ontology. You may want to take one of the freely available conceptual modeling tools (e.g., ArgoUML) and use that serialization for the transformations. There are a few tools around that try this already, but they have incomplete coverage (at best).
16. Compare and contrast ontology editors in a meaningful way; e.g., the Protégé stand-alone tool, WebProtégé, MoKI, NeON toolkit, etc.
17. Implement the RBox reasoning service and demonstrate correctness of implementation in the software.
18. OWL does not consider time and temporal aspects. To address this shortcoming, several ‘workarounds’ as well as temporal description logics have been proposed. Compare and contrast them on language features and modeling problems and reasoning.
19. Develop a Protégé plugin that will show in the interface not the Manchester syntax with “some” and “not” etc, but the DL axiom components (e.g., alike it was in its v3.x), or with the corresponding keywords in a natural language other than English.
20. Provide a state of the art on research into competency questions.
21. Represent DOLCE—or another ontology that has indicated to be needing more than OWL expressiveness—in DOL on OntoHub; e.g., by adding those axioms in a module and link them to the OWL file into a network of ontologies.

## Footnotes

2in case you are not convinced: check http://openwetware.org/wiki/Word_vs._LaTeX or http://ricardo.ecn.wfu.edu/~cottrell/wp.html

3http://ceur-ws.org/Vol-1015/, and there have been subsequent editions of the ORE workshops.

6see, e.g., the list at http://code.google.com/p/lucene-skos...i/SKOSThesauri, but there are others you may wish to consider