DAY 1 - Introduction

• Semantics and information systems – the relationship of semantic discipline, semantic technologies and semantic web standards to each other and to information systems.
• The Semantic Web – Step by step, what are the standards that make up the semantic web stack, including RDF and OWL, and how do they lead to a semantic infrastructure.
• Description Logics (DL)  and Open World Reasoning – Semantic inference is a major departure from constraint and template based environments such as relational and object oriented development environments.  In this unit we introduce and describe the differences in preparation for the afternoon where we get hands on with the differences.

DAY 1 - Building Blocks

• Ontologies and an Ontology Editor -  This begins the hands on portion of the class.  Students will learn how to navigate and create simple classes and instances in the SWOOP, open source, ontology editor. 
• Object and Data Properties – in DL Properties are first class objects, meaning they do not need to be attached to and dependent on classes.  We will jointly create several properties and attach instances to them.
• Classes and Subsumption – Subsumption (similar to subtyping or inheritance) will be covered as well as the set theory behind it that really distinguishes this approach from inheritance as it is practiced in Object Oriented approaches. 

DAY 2 - Queries and Open World Reasoning

• RDQL and SPARQL – we demonstrate two of the more popular query languages for RDF and OWL ontologies. 
• Complex classes – we demonstrate and define and have students build union, intersection and complement classes, and show how they are used in the construction of a complex ontology
• Disjoint and Equivalence – we introduce the concepts of disjointness and equivalence at the instance and class level.  Students add them to their ontologies and then query them to find result.

Asserted instances – we build a number of asserted instances, and show through query how they show up in each of the defined queries.

DAY 2 - Inference

• Restriction classes – we show how to build a restriction class, and what the various qualifiers mean (someValuesFrom, allValuesFrom etc)
• Pellet reasoner – we show how a reasoner, in this case the pellet reasoner works, and how it classifies instances into restriction classes.
• Remaining concepts – we cover the rest of the OWL spec, including OneOf, versioning and commenting

DAY 3 - Designing an Ontology, starting with Taxonomies

• Recap on inference – we’ve found that students often appreciate a recap at this point to reflect on the differences between DL and other systems, and open world and closed world differences.
• Taxonomies in Ontologies – One of the key design patterns found in semantic based systems is the formal taxonomy.  We distinguish formal from navigational taxonomies, and show several patterns for their use.  Students then watch a real world video and design a taxonomy from it.

DAY 3 - Classes and Instances in the Real World

• Instance taxonomies --- we show why and how you may need to build taxonomies out of instances rather than classes, and what sort of patterns to apply to that process.
• Faceted taxonomies – one of the most powerful patterns in ontological design is disentangling facets, or dimensions in the solution.  In this exercise we will describe this and work another example.
• Partonomy and Mereology – another very common use of ontologies is in the building of partOf hierarchies, or partonomies.  The study of relations between parts and wholes is called Mereology, and we will touch on this study briefly.

DAY 4 - Federating Ontologies

• Federation and Import – we describe federation of ontologies in general, and the use of the OWL import feature to accomplish this specifically. 
• Topology of a federation – we work through an exercise of including several ontologies, including some pre-existing geographical ontologies into a total solution, in particular working through design tradeoffs as to where to place “bridges” and where to import directly.
• Enterprise ontology – we outline the process of building an enterprise ontology and the benefits of doing so.

DAY 4 - The Bigger Picture

• Limits of OWL and DL – this session will outline what you can’t do in a description language.
• Rules and inference systems – the W3C are working on standardizing the production rules part of the semantic web stack.  We outline the progress to date, how rules will fit in with an inference based architecture, and what companies can do now to incorporate rules into their systems, especially with an eye toward future standards compliance.
• Architectural concerns – how does an inference engine fit in with a broader architecture, in particular how does it fit with SOA and Web services, how do people incorporate unstructured data and entity extraction.