| Version 20 (modified by rvos, 16 years ago) |
|---|
Semantic Web Services Objectives
- Mark Wilkinson
- Create a list of datatypes representing the core datatypes for the WABI services
- Create OWL Classes representing these datatypes
- Documentation of SADI (This should include movies of the demo's so that people can see it in-action)
- Luke McCarthy
- re-code core SADI code such that services add predicates, rather than client
- Study Paul Gordon's WSDL-2-Moby tool and map some WABI services to BioMoby? for practice
- tweak Paul's WSDL-2-Moby tool to be a WSDL-2-SADI tool
- create some WABI-SADI services
DECISIONS MADE
SADI API Decisions
- Service provider will "decorate" input by adding a new predicate/object to the incoming data; this is no longer a client-side task
- Client must semantically-type their input data according to the OWL document describing the service provider's input
- this allows the service to find the input nodes based on their rdf:type rather than having to reason-over the incoming data.
- service provider will strip this rdf:type tag off of the data before sending it back to the client.
- Service providers must semantically-type their output data according to the OWL document describing their output such that the client can recognize the nodes that have been decorated by the service. Clients may chose (probably will want to) strip the rdf:type tag off of the returning data.
Web Services to Wrap
- We decided that WABI services cannot be efficiently wrapped en masse because many (most?) of them output non-standardized, tab-delimited flatfiles; adding semantics into these files would require us to write a special parser for each service... BZZZZT! We suggest that, at a minimum, WABI services should output XML such that we can use generic parsers and generic tools (e.g. XSLT) to add semantics into these services.
- TOGO services are nicer, but don't have a WSDL (because they are RESTful). As such, there is no way for us to wrap them other than one-by-one... BZZZZZZT!
- We have asked Oswaldo to suggest which WABI services he thinks are most interesting/useful for his integration with the Spanish INB, and we will wrap these services during the hackathon as SADI and/or Moby services.
Subgroup summary
Why semantic web services
The holy grail of web service interoperability is hampered along three axes: syntax, semantics and interface. In terms of core data syntax, bioinformatics tools consume and produce data in many different formats, some of which are loosely defined syntactically (e.g. legacy flat file formats). In addition, the semantics of what we are trying to do with data, and what we mean by encoding data in a certain way, are often loosely defined. Many file formats are abused and overloaded to add semantics to fields that weren't intended for that (e.g. in comments, definition lines, key/value fields). Lastly, there is a proliferation of interfaces, each of which probably make sense on their own (e.g. RESTful APIs) but they all aren't interoperable in a way that a machine can make sense of by itself. By adopting common standards to define syntax, semantics and interface, different service providers will be able to promote interoperability. Hence, this subgroup consists of people discussing the application of such technologies as WSDL, SAWSDL, OWL, RDF/XML (and other XML tools, i.e. XML schema, transforms). In addition to these technical arguments, there are also good philosophical arguments for formalizing our conception of the world. For example, as a researcher, this provides a formal way of sharing your knowledge with other people, thereby promoting reproducibility.
State of the practice
RDF
RDF assumes that anything in the world can be described in triples, i.e. statements consisting of subject, predicate, object. RDF/XML is just one serialization of the concept of triples (other ways are M3, JSON, RDFa etc.). An RDF/XML document imports at least two namespaces: rdf and rdfs.
- Simple example: rdf:Description element defines the subject, rdf:about attribute defines a resource that is the subject. rdfs:label, for example, attaches a human readable label to a subject.
- Example with more namespaces: subject is now defined on element foaf:Person (again by rdf:about), subject has multiple predicates: foaf:name (his name), foaf:page (which in turn encloses another triple: foaf:Document => dc:title => literal)
- Real example: a set of triples describing Tim Berners-Lee using foaf ( Friend of a Friend), dc ( Dublin core), rss ( Really Simple Syndication), rdfs.
- Biological example: a UniProt record
OWL
While RDF just defines triples, OWL (Web Ontology Language) allows for defining classes of things, as opposed to opaque resources, for subjects (class), predicates (property) and objects (class). The previous examples that included things such as foaf:Person were using instances of classes from OWL ontologies.
- Simple example: an OWL ontology that describes a single class defined by duck-typing - anything belongs to CaffeineMetabolismParticipant if its value for isParticipantIn is the KEGG pathway for caffeine metabolism.
SAWSDL
Web services interfaces are described using web service description language ( WSDL). In WSDL documents, semantic web services want to define the semantics of their inputs, outputs and services. This is done using SAWSDL, which provides for the attributes modelReference (which defines the OWL class), liftingSchema (which links to an xslt that lifts the xml syntax into rdf) and loweringSchema (which links to an xslt that converts the rdf back to xml).
SPARQL
SPARQL is a query language for triples (SQL for triples).
State of the art
Who
Current
- SADI
- EvoInfo
