Write by flyingFang (2006)

Software engineering

1  analyse -> UML -> discussion -> implemtation in varity langragues

   During this process, some special data structures would be used to
   implemente the ad hoc applications.Although from a same UML,
   different developers would develope different data structures.So
   interoperation and reusability both are difficult.Because any
   implementation will be adapt the special data structures.
   >>>>>    Model-Driven Architecture    <<<<<
            Model-View-Control Architecture

   ==>      Ontology Driven Architecture   (In an ideal world)

   That is,all applications that share overlapping ==domain models==
   would then have a certain degree of interoperability built in.

   RDF/RDF Schema and  OWL
 o  both are desined for the Semantic Web originally.
 o  Interestingly, however, it turns out they could also play a
           major role in software development in general.
        o  operate on similar structures to object-oriented languages,
           and therefore can be effectively integrated with traditional
           software components
        o  RDF/OWL properties are independent from particular classes,
           and can be used in multiple places

        O key benefits of RDF Schema and OWL compared to object-oriented languages are:
           * Reuse and interoperability:
  RDF and OWL models can be shared among applications and on the web
           * Flexibility:
                RDF and OWL models can operate in an open environment in which classes
                can be defined dynamically etc
           * Consistency and Quality Checking
  across models
           * Reasoning:
  OWL has rich expressivity supported by automated reasoning tools

   RDF/RDFS
        o RDF properties are stand-alone entities which can be defined independently
   from classes and used in multiple classes
        o This also makes it possible to reuse the same property across multiple files
 o Because the independence of the propertities from classed ,
          rdfs:domain statements are used for "attach" or "associate" a property with
   a class
        o a domain statement in RDF can be used to classify instances
        o all RDFS classes can overlap. Since individuals can have multiple types,
          this means that some instances may be shared among classes
        o instances can change their type during their life cycle
        o expressivity of RDF Schema alone is insufficient. For example,
          RDF Schema cannot express cardinality constraints so that
          each Product can only have one price
        

  
   OWL
        o being optimized to represent structural knowledge at a high level of abstraction
        o Domain models encoded in OWL can be uploaded on the Web and shared
          among multiple applications
        o supported by an unambiguous dialect of formal logic called Description Logics
          <[BHS 2003]>
         Description Logics. Baader, Franz, Horrocks, Ian, Objeand Sattler, Ulrike.  Volume Handbook on Ontologies in Information Systems of International Handbooks on Information Systems, chapter I: Ontology Representation and Reasoning, pages 3-31. Steffen Staab and Rudi Studer, Eds., Springer. 2003.>
        o Restriction: a kind of expression by OWL is called restriction.
          A restriction describes the class of all instances that fulfill a
          specific condition on a property.
          For example:
                      define the class of all things where the hasOrigin property
                      has the value Australia
        o Key power:  classes can be defined by combining multiple restrictions
                      and other classes
        o For the previous purpose, OWL provides logical operands to build
          intersections (and), unions (or) and complements (not) of other classes

   
   OWL reasoners :  a kind tool to hadle and analyze OWL models
        o OWL reasoners can be used to:
  > Reveal subclass/superclass relationships among classes
  > Determine the most specific types of individuals
  > Detect inconsistent class definitions

   OCL  == Object Constraint Language ==
 o part of the OMG's family of languages for Model-Driven Architecture
        o not been designed for the Web
        o optimized to represent constraints within rather closed data models
        o While "Semantic Web technology has been designed for an open world,
                 in which models are shared among multiple applications and groups."
   
   ODM  == Ontology Definition Metamodel ==
 o allow developers to use Semantic Web languages in tandem with(同...合作)
          other formats such as OCL
        o Ref<  ODM  http://www.omg.org/docs/ad/06-05-01.pdf>

2

   Domain models in any of these languages(Semantic Web langruages supportted by W3C)
   can be uploaded and linked into the Web just like you would publish an HTML page.
   Once an RDF or OWL file is online, other Web resources or applications can link to it.

   XML-based approachs    VS.  Semantic Web languages  (about interoperability)
        The latter have richer expressivity,eg:
 o possible to define subclasses and
        o generalizations of conceptes

   OO languages    VS.  Semantic Web languages
       
        o same/similiar
  > RDFS classes can be arranged in a subclass hierarchy
                  very similar to object-oriented systems
  >

        o differents
  > all RDFS classes can overlap
                  (Since individuals can have multiple types,
                   this means that some instances may be shared among classes. )
                > RDFS instances can change their type during their life cycle
                > individuals can be declared to have more than one direct type.
                  (while any object can only belongs to ont class in OO, flying)
                > Semantic Web is an open world, under the "open-world assumption"
                  while "classical" object-oriented systems or "traditional"
                  relational databases have finite domains
                > in the UML or Java attributes are attached to a single class only,
                  while RDF properties are stand-alone entities which can be defined
                  independently from classes and used in multiple classes

   
   Semantic Web Languages

        o  The extensibility of Semantic Web languages supports
           reusability on a global(全球的,flying) scale
        o  richer expressivity than XML-based approachs
        o  Web-based; URI
    each class, property or object in an RDF Schema or OWL file
           has a unique identifier (URI), so that it can be referenced from anywhere else
        o  highly reusable <= OWL is founded on formal logic
        o  In contrast to many object-oriented languages, individuals (of RDF)can be
           declared to have more than one direct type
      

   custom-fitting

        o when the domain models gotten from semantic web are not adapt a special application.
        o custom-fitting can be achieved by adding specific subclasses or instances

        
   namespace
  
        o Namespaces can be compared to packages in object-oriented languages
        o URIs are often split into namespace and local name
        o Namespaces can be abbreviated with a prefix notation
        o All resources declared in a namespace are public, so that
          all RDF files could directly refer to each other

(flying:此处原为表格，但是由于版面缩进不同，因此无法直接复制到此)
       

3 Programming with RDF Schema and OWL

   remember ontology languages: (key to understanding ontology-driven architectures)

    o  Properties are independent from specific classes
    o  Instances can have multiple types and change their type as a result of classification
    o  Classes can be defined dynamically, at runtime

   map RDF to OO:

    o  use 4 classes to express RDFS  to represent resources, classes,
       properties and individuals
    o  see figure in <http://www.w3.org/TR/2006/NOTE-sw-oosd-primer-20060309/>

   OWL object model:

    o  see firgure in <http://protege.stanford.edu/plugins/owl/api/ProtegeOWLModel.pdf>

   ontologies in use      >>>> Dynamic Object Model pattern  <<<<

    o Applications would load ontologies into such an object model
      (in "map RDF to OO" and "OWL object model"), and then
    o manipulate and query the objects at runtime.
    o every thing is object:
        > RDF Schema class
        > RDF property
        > individual
    o see detail of Dynamic Object Model pattern
      <Dynamic Object Model>
          Dirk Riehle, Michel Tilman, and Ralph Johnson.
          In Dragos Manolescu, Markus V&ouml;lter, James Noble (eds.)
          Pattern Languages of Program Design5. Reading, MA: Addison-Wesley, 2005
    o In particular, if generic components for reasoning and querying exist,
      then software designers should encode as much as possible in the RDF/OWL
      domain model, and thus raise the level of abstraction into the domain of
      generic services.

      == example == 某些订单是适用特殊优惠政策的:

        > implemented inside the body of a method such as isDutyFree() in the
          Java class PurchaseOrder.
          
          ==>impossible to exploit generic reasoners to classify a purchase
             order automatically.

        > Cleaner solution :
          define a subclass DutyFreePurchaseOrder in the OWL ontology,
          and supply it with Description Logic statements that define how
          duty free orders differ from other orders

4 disadvantages up to date

     reasoning engines:

        o many of them have scalability and performance problems  currently
        o limit the use of classifiers at runtime, because
          The classification of arbitrary OWL DL ontologies can be an
          extremely lengthy task
        o while performance is less critical when reasoners are used at
          ontology build time

     other porblems:

        o difficult to build truly domain independent and reusable ontologies
        o because very diffcult and expensive during building ontologies, maybe
          many sofuware companies would not just upload and share onpenly on the web

5 useful resources

*Links to APIs
  o Java
      Jena - Semantic Web Framework (http://jena.sourceforge.net/)
      WonderWeb OWL API (http://wonderweb.man.ac.uk/owl)
      Protege OWL API (http://protege.stanford.edu/plugins/owl/api)
  o C
      Redland - RDF Application Framework (http://librdf.org/)
  o PHP
      pOWL - Semantic Web Development Platform (http://powl.sourceforge.net/)
  o Code generators
      RDFReactor (http://rdfreactor.ontoware.org/)
      Kazuki (http://projects.semwebcentral.org/projects/kazuki/)
      Jastor (http://jastor.sourceforge.net/)

*Links to tools and support infrastructure
  O Protege-OWL Ontology Editor (http://protege.stanford.edu/plugins/owl)
  O OntoEdit/OntoStudio - Engineering Environment for Ontologies (http://ontoedit.com/)
  O SemanticWorks RDF/OWL Editor ( http://www.altova.com/products_semanticworks.html)
  O SMORE - OWL Markup for HTML Pages (http://www.mindswap.org/2005/SMORE/)
  O SWOOP - lightweight ontology editor (http://www.mindswap.org/2004/SWOOP/)
  O OntoMat Annotizer ( http://annotation.semanticweb.org/ontomat)

*Links to further online documents
  O Semantic Web Activity (Semantic Web Activity)
  O RDF Primer (http://www.w3.org/TR/rdf-primer/)
  O Tutorial on OWL (http://www.cs.man.ac.uk/~horrocks/ISWC2003/Tutorial/)

*Links to example ontologies
  O SchemaWeb - A comprehensive directory of RDF schemas and OWL ontologies (http://www.schemaweb.info/default.aspx)
  O DAML Ontology Library (http://www.daml.org/ontologies/)
  O Ontoware - Ontology repository ( http://www.ontoware.org)
  O Protege-OWL Ontology library (http://www.owl-ontologies.com/)

*Links to example SW applications
  O SWCLOS - A Semantic Web Processor on Common Lisp Object System (http://iswc2004.semanticweb.org/demos/32/)
  O Swoogle - A Semantic Web Search Engine (http://swoogle.umbc.edu/)
  O Bibster - A Semantics-Based Bibliographic Peer-to-Peer System (http://bibster.semanticweb.org/)
  O Ontoware - Semantic Web related Software Projects (http://www.ontoware.org/)      
      
     
flying: 由于表格不便展示，特将我写的带有表格的txt文件上传。