Re: [SE ]First outline of new note

Hi Holger,
here are my comments as promised:

- structure
   1) Overview
   2) <Ontologies in the whole lifecycle of OO development>
      mention here that ontologies can be used for software
      specification (analysis phase of OO methodologies),
      for reasoning, debugging, testing, etc.
   3) Intro to the SW
    3.1) RDF and RDFS
    3.2) OWL
   4) <current section 4>
   5) <current section 5>

- Objective:
   - term "lightweight" might be inappropriate and misleading

- 1)
   - points "main idea" to "key languages" should be rather short
     otherwise it would be more than an overview

- 4)
   - Semantic Web apps or ontology-based apps? I would prefer the latter

- 5)
   - rdfreactor.ontoware.org might be relevant


- Misc
   - an example for what you mention in 1) (domain models have encoded ...)
     is the workshop paper I sent you recently
   - we should somewhere explicate the differences from OO to ontologies
     because everybody will be looking for that. Here's a snippet from my
     thesis:
     "In essence, ontologies are similar to existing conceptual
      modelling techniques, e.g., the Entity Relationship Model
      or UML.\footnote{In fact, we visualize
      ontologies by means of UML class diagrams throughout the
      document.} However, ontologies differ from existing methods and
      technologies in the following way: (i) the primary goal of
      ontologies is to enable agreement on the meaning of specific
      vocabulary terms and, thus, to facilitate information integration
      across individual applications; (ii) ontologies are
      formalized in logic-based representation languages. Their
      semantics are thus specified in an unambiguous way. (iii)
      The representation languages come with executable calculi enabling
      querying and reasoning at run time."
   - here's some material for the mentioned AIFB portal, Bibster, and
     some EU project portal that use the swrc.ontoware.org
     http://www.aifb.uni-karlsruhe.de/Publikationen/showPublikation?publ_id=1003
     http://www.aifb.uni-karlsruhe.de/about.html

Best,
  Daniel


Holger Knublauch wrote:
> Daniel, Evan, Phil,
> 
> sorry for the delay getting back to you.  As promised, here is a brief 
> overview of what we could write.  Please note that this is still high 
> level and I am of course open to completely change the focus.
> 
> How are such notes usually written... are they edited in HTML and 
> directly uploaded, and if yes, how do people add comments or contribute?
> 
> Also, when is the next telcon, and how will I get notified?
> 
> Cheers
> Holger
> 
> 
> ---
> 
> 
> Potential Titles:
> 
> A Semantic Web Primer for Object-Oriented Software Developers
> 
> or
> 
> Introduction to OWL and RDF for Object-Oriented Software Developers
> 
> 
> (suggested author list in alphabetical order)
> Holger Knublauch
> Daniel Oberle
> Phil Tetlow
> Evan Wallace
> ... open to additions
> 
> 
> 
> Some metadata about this note
> -----------------------------
> 
> Objective:
> 
> OWL could be very useful for mainstream developers, both from an MDA 
> point of view and as a light-weight modeling language for rather agile 
> approaches.  A lot of mature technology (APIs and tools, including 
> open-source stuff) is already out there, but OWL is not widely used yet. 
>  OWL is neither well-known outside of academia, nor well supported by 
> tutorials or articles in mainstream journals.  The available language 
> specifications are not on the right level of accessibility and not 
> geared for our target audience.  Most available documents don't exploit 
> the parallels between OWL and object-oriented languages (which most 
> developers are familiar with).  Our goal is to produce a primer that 
> takes object-oriented design as a starting point and explains the added 
> value and differences of OWL from there.  The primer should encourage 
> developers to explore OWL, including pointers to libraries and tools for 
> hands-on experience.  If more mainstream developers become interested, 
> they will produce more ontologies and thus contribute to the evolution 
> of the Semantic Web as a whole.
> 
> 
> Strategy Keywords:
> 
> - Make it easy to read (for programmers/analysts)
> - Make it application-oriented (give examples)
> - Use OO terminology to draw parallels
> - Work out important differences to avoid misunderstandings
> - Show added value of OWL over OO
> - Show that OWL is great for agile modeling (short cycles, customer 
> involvement)
> - Point to existing technology that is available for real-world projects
> 
> Out of Scope:
> 
> - Using UML as an ontology language
> - Using OWL in MDA together with UML (this is covered elsewhere)
> 
> 
> 
> 
> Outline
> -------
> 
> 1) Introduction to the Semantic Web
>   - Perhaps an introductory example scenario of where current technology 
> falls short.
>   - Model/View/Control architecture revisited: Wouldn't it be nice to 
> make the model and control parts richer and better to reuse?
>   - Main idea: Represent domain models in a Web-compliant language so 
> that intelligent software components and services can reuse and exploit 
> them.  Domain models can also be used to "annotate" other resources on 
> the Web, but our focus here is sharing models, independent from 
> low-level language.
>   - Domain models have encoded "semantics" that can be used to implement 
> useful reasoning services (classification, constraint violations, querying)
>   - Key languages: RDF, OWL (Rule and query languages exist as well, 
> just to mention them)
> 
> 2) RDF and RDF Schema  (based on comparisons with OO/UML)
>   - Resources and literals
>   - Classes and Properties (with range & domain)
>   - Individuals
>   - Namespaces (= packages)
>   - All this is quite similar to UML, except that properties are 
> top-level entities
>   - Domain modeling with tools like Protege -> Rapid prototyping
> 
> 3) OWL  (based on comparisons with OO/UML)
>   - Restrictions
>   - Defined vs. primitive classes
>   - Reasoning
>   - Disjoint classes, open world, unique name assumption
>   - Semantics as (JUnit) test cases
>   - Importing other models from the Web
> 
> 4) Programming with and for the Semantic Web
>   - Software architecture of Semantic Web applications
>   - Working with OWL models in (Java) applications, setting up 
> infrastructure
>   - Active object models using APIs such as Jena
>   - Code generation (Kazuki, Jastor, Protege-OWL API) to add methods to 
> classes etc
>   - Development process (domain modeling - coding - testing)
>   - Sharing ontologies online
> 
> 5) Where to go from here
>   - Links to APIs
>   - Links to tools and support infrastructure
>   - Links to further online documents
>   - Links to example ontologies
>   - Links to example SW applications (are there any?)

Received on Tuesday, 30 August 2005 19:13:45 UTC