“OWL is an important step for making data on the Web more machine processable and reusable across applications, ” said Tim Berners-Lee, W3C Director. “We’re encouraged to see OWL already being used as an open standard for deploying large scale ontologies on the Web.”

OWL is specified in 6 documents: The OWL Overview; OWL Semantics and Abstract Syntax; OWL Use Cases and Requirements; OWL Test Cases, OWL Guide, and the OWL Reference. Read the FAQ…

Source : http://goliath.ecnext.com/coms2/gi_0199-3205814/World-Wide-Web-Consortium-issues.html

Take for example the semantic web:

• “… a project that intends to create a universal medium for information exchange by putting documents with computer-processable meaning (semantics) on the World Wide Web”
• “… an evolving extension of the World Wide Web in which web content can be expressed not only in natural language, but also in a form that can be understood, interpreted and used by software agents, thus permitting them to find, share and integrate information more easily”

The original vision for this is credited to Sir Tim Berners-Lee as an extension to his original invention (the world wide web). You can find an outline of the concept penned by Tim himself here. Much has been done to establish this framework which is aimed at making web content more accessible and usable — especially by machines.”

Read the full article at Canada’s own Slaw.

Semantic Web techniques are used to resolve domain-specific similarities. For example, the concepts used in a given domain (such as retail industry, health-care industry, etc.) and the relationships among them are modeled as a domain ontology. The Web services are annotated using semantic annotations from the domain ontologies in Web Services Semantics (WSDL-S) format. Then the ontological similarity of the semantic annotations associated with Web service descriptions is derived by inferring the domain ontology.

Matches from the two approaches are combined to determine an overall similarity score to help assess the quality of a Web service match to a given request. In cases where single services do not match a given request, the system can compose multiple services by employing artificial intelligence (AI) planning algorithms in order to fulfill a given request.

The WSDL-S mechanism for annotating Web services with semantics is based on an approach developed jointly by IBM and the University of Georgia. This approach was submitted to W3C in 2005 and is now the basis for the work of the new Semantic Annotations for WSDL (SAWSDL) Working Group.

The Semantic Web is a vision for the future of the Web in which information is given explicit meaning, making it easier for machines to automatically process and integrate information available on the Web. The Semantic Web will build on XML’s ability to define customized tagging schemes and RDF’s flexible approach to representing data.

The next element required for the Semantic Web is the OWL Web ontology language (OWL), which can formally describe the semantics of classes and properties used in Web documents. For machines to perform useful reasoning tasks on these documents, the language must go beyond the basic semantics of RDF Schema. In this article, I’ll briefly review several use cases that show the need for the OWL.

OWL language
Ontologies are usually expressed in a logic-based language, so that detailed, accurate, consistent, sound, and meaningful distinctions can be made among the classes, properties, and relations. Some ontology tools can perform automated reasoning using the ontologies, and thus provide advanced services to intelligent applications such as conceptual/semantic search and retrieval, software agents, decision support, speech and natural language understanding, knowledge management, intelligent databases, and electronic commerce.

The OWL language provides three increasingly expressive sublanguages designed for use by specific communities of implementers and users:

• OWL Lite supports those users primarily needing a classification hierarchy and simple constraint features.
• OWL DL supports those users who want the maximum expressiveness without losing computational completeness (all entailments are guaranteed to be computed) and decidability (all computations will finish in finite time) of reasoning systems. OWL DL was designed to support the existing Description Logic business segment and has desirable computational properties for reasoning systems.
• OWL Full is meant for users who want maximum expressiveness and the syntactic freedom of RDF with no computational guarantees. OWL Full allowsan ontology to augment the meaning of the predefined RDF or OWL vocabulary.

Before you can use a set of terms, you need a precise indication of what specific vocabularies are being used. A standard initial component of an ontology includes a set of XML namespace declarations enclosed in an opening rdf:RDF tag:

<rdf:RDF
 xmlns     ="http://www.site.org/2003/ontology/drinks#"
 xmlns:drinks =" http://www.site.org/2003/ontology/drinks#"
 xmlns:owl ="http://www.w3.org/2002/07/owl#"
 xmlns:rdf ="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
 xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
 xmlns:xsd ="http://www.w3.org/2000/10/XMLSchema#">

Once namespaces are established, we normally include a collection of assertions about the ontology grouped under an owl:Ontology tag. These tags, shown below, support such critical housekeeping tasks as comments, version control, and inclusion of other ontologies:

<owl:Ontology rdf:about="">
 <rdfs:comment>OWL ontology of drinks at site.org</rdfs:comment>
 <owl:priorVersion rdf:resource="http://www.site.org/2003/ontology/drinks-prev.owl"/>
 <owl:imports rdf:resource=" http://www.site.org/2003/ontology/wines.owl "/>
 <rdfs:label>Drinks Ontology</rdfs:label>

The owl:Ontology element is the place to collect much of the OWL metadata for the document. The rdf:about attribute provides a name or reference for the ontology. Where the value of the attribute is empty (i.e., the standard case), the name of the ontology is the base URI of the owl:Ontology element.

Source : http://articles.techrepublic.com.com/5100-22-5060266.html

But this explanation of the Semantic Web causes problems when people start to build the Semantic Web based on this view. Typically, two questions are raised:

1. Who will hold the authority on the ultimate explanation of Web data?
2. Why should ordinary Web users contribute to a web of data? “

Each of those questions is linked to more information, giving this entire article a rare depth. Read the full article Abandon Babel, Welcome Society: The Philosophy Behind Semantic Web Approaches and learn more.

The Annotation Web services API is an implementation-neutral set of SOAP-based Web services calls intended as an industry standard to facilitate the interoperability of clients who wish to enable annotations and servers that store annotations and implement the API. The Web services Definition Language (WSDL) formally defines the syntax of the API. There are accompanying semantics in another document. This article explains the motivations behind the API’s design, as well as an overview of the API. You should consult the WSDL and accompanying semantic documentation for more information (see the Resources section below for links).

The word annotation has many different meanings depending upon the context and audience. Regardless of these differences, every annotation is essentially some metadata associated with some target data. The target data itself can vary from a table in a relational database, to a word processing document, or to the topic of what to cook for dinner tonight. The corresponding annotation might be an entry in another database table, a comment within the document, or a sticky note on the front of the refrigerator. Annotations are important when large amounts of data are created, shared, and examined. For example, the life sciences industry and the legal profession both make heavy use of annotations.

Everything but the refrigerator

Because of the substantial generality of annotations, the scope of the design must be narrowed in order to arrive at a useful and manageable Annotation Web services API. To accomplish this, the goals of a system must be enumerated based upon the Annotation Web services API and then derive the data model and API calls from those goals.

Annotate arbitrary digital data

The primary goal of the Annotation Web services API is to enable the annotation of any arbitrary digital data. Please note that the type, size, structure, or content of the data is arbitrary. For example, the same Annotation Web services API methods facilitate annotating both legal briefs and scientific experiment results.

Annotations stored out-of-band

The API should acknowledge the intrinsic existence and identity of data objects regardless of their names, locations, or any properties other than their contents. In other words, an annotation that you create on a memo on your local hard drive should be visible to your coworker with his or her own copy of the memo, despite potentially differing meta-information such as file name or timestamp. To accomplish this, the Annotation Web services API must encompass a model in which the annotations are stored separately from target data objects and in which data objects’ identities can be determined independently of file meta-information.

Structured annotations

Many applications include annotation functionality that follows the “sticky note” paradigm. Such annotations are better referred to as comments, as they consist only of free-form text entries. Even when centrally gathered, these unstructured comments are difficult to search or data-mine effectively and efficiently. Therefore, one goal of the Annotation Web services API design is the support of structured annotations — annotations containing information that conforms to a particular structure. Because a free-form text entry is simply one particular annotation structure, this design goal does not preclude unstructured annotations.

Other design goals

Several other goals also drove the design of the Annotation Web services API. Access control must be included to allow for private and semi-private annotations. The API must also facilitate bidirectional access between the annotations and the target data. The API also allows for maximum configuration, flexibility, and extensibility by implementors.

Source: IBM

What’s the rationale for such a system? Data that is geneally hidden away in HTML files is often useful in some contexts, but not in others. The problem with the majority of data on the Web that is in this form at the moment is that it is difficult to use on a large scale, because there is no global system for publishing data in such a way as it can be easily processed by anyone. For example, just think of information about local sports events, weather information, plane times, Major League Baseball statistics, and television guides… all of this information is presented by numerous sites, but all in HTML. The problem with that is that, is some contexts, it is difficult to use this data in the ways that one might want to do so.

So the Semantic Web can be seen as a huge engineering solution… but it is more than that. We will find that as it becomes easier to publish data in a repurposable form, so more people will want to pubish data, and there will be a knock-on or domino effect. We may find that a large number of Semantic Web applications can be used for a variety of different tasks, increasing the modularity of applications on the Web. But enough subjective reasoning… onto how this will be accomplished.

The Semantic Web is generally built on syntaxes which use URIs to represent data, usually in triples based structures: i.e. many triples of URI data that can be held in databases, or interchanged on the world Wide Web using a set of particular syntaxes developed especially for the task. These syntaxes are called “Resource Description Framework” syntaxes.
URI - Uniform Resource Identifier

A URI is simply a Web identifier: like the strings starting with “http:” or “ftp:” that you often find on the World Wide Web. Anyone can create a URI, and the ownership of them is clearly delegated, so they form an ideal base technology with which to build a global Web on top of. In fact, the World Wide Web is such a thing: anything that has a URI is considered to be “on the Web”.

The syntax of URIs is carefully governed by the IETF, who published RFC 2396 as the general URI specification. The W3C maintains a list of URI schemes.

DF - Resource Description Framework

A triple can simply be described as three URIs. A language which utilises three URIs in such a way is called RDF: the W3C have developed an XML serialization of RDF, the “Syntax” in the RDF Model and Syntax recommendation. RDF XML is considered to be the standard interchange format for RDF on the Semantic Web, although it is not the only format. For example, Notation3 (which we shall be going through later on in this article) is an excellent plain text alternative serialization.

Once information is in RDF form, it becomes easy to process it, since RDF is a generic format, which already has many parsers. XML RDF is quite a verbose specification, and it can take some getting used to (for example, to learn XML RDF properly, you need to understand a little about XML and namespaces beforehand…), but let’s take a quick look at an example of XML RDF right now:-

<rdf:RDF xmlns:rdf=”http://www.w3.org/1999/02/22-rdf-syntax-ns#”
xmlns:dc=”http://purl.org/dc/elements/1.1/”
xmlns:foaf=”http://xmlns.com/0.1/foaf/” >
<rdf:Description rdf:about=”">
<dc:creator rdf:parseType=”Resource”>
<foaf:name>Sean B. Palmer</foaf:name>
</dc:creator>
<dc:title>The Semantic Web: An Introduction</dc:title>
</rdf:Description>
</rdf:RDF>

This piece of RDF basically says that this article has the title “The Semantic Web: An Introduction”, and was written by someone whose name is “Sean B. Palmer”. Here are the triples that this RDF produces:-

<> <http://purl.org/dc/elements/1.1/creator> _:x0 .
this <http://purl.org/dc/elements/1.1/title> “The Semantic Web: An Introduction” .
_:x0 <http://xmlns.com/0.1/foaf/name> “Sean B. Palmer” .

This format is actually a plain text serialization of RDF called “Notation3″, which we shall be covering later on. Note that some people actually prefer using XML RDF to Notation3, but it is generally accepted that Notation3 is easier to use, and is of course convertable to XML RDF anyway.

Source: Infomesh

The SC was chartered to define use cases and requirements for managing semantic content within the ebXML Registry 4.0, seeking to establish a formal liaison with relevant groups within the Semantic Web Activity (SWA) at W3C. The requirements: must include the ability to utilize ontolgies for classifying RegistryObjects and to enable intelligent discovery using ontology based queries. The SCMSC was tasked to identify specific Semantic Web technologies (e.g. RDF, OWL) that are necessary to support the requirements identified for semantic content management. From the specification introduction: The ebXML Registry holds the metadata for the RegistryObjects and the documents pointed at by the RegistryObjects reside in an ebXML repository.

The basic semantic mechanisms of ebXML Registry are classification hierarchies (ClassificationScheme) consisting of ClassificationNodes and the Association Types among RegistryObjects. Furthermore, RegistryObjects can be assigned properties through a slot mechanism and RegistryObjects can be classified using instances of Classification, ClassificationScheme and ClassificationNodes.

Given these constructs, considerable amount of semantics can be defined in the registry. However, currently semantics is becoming a much broader issue than it used to be since several application domains are making use of ontologies to add knowledge to their data and applications. This document normatively defines the ebXML Registry profile for Web Ontology Language (OWL) Lite. More specifically, this document normatively specifies how OWL Lite constructs should be represented by ebXML RIM constructs without causing any changes in the core ebXML Registry specifications. Furthermore, this document normatively specifies the code to process some of the OWL semantics through parameterized stored procedures that should be made available from the ebXML Registry. Although this Profile is reIated to ebXML Registry specifications and not to any particular implementation, in order to be able to give concrete examples, the freebXML Registry implementation is used.

Source : ebXML.org

This morning, Amazon announced that their aStore product (part of the selling tools available to folks enrolled in the Amazon Associates program) would allow full customization of the look and feel via CSS. Currently, the interface only allows for approximately 8000 characters of custom CSS, but that level of control is allowed on several of the page types, including product descriptions and search results. On top of that, users can also share these custom “themes” with others.

Of course, the underlying markup of the aStore product leaves a bit to be desired: it is a strange blend of DIVs and TABLEs that offers little semantic value. It’s also not valid HTML, but the validation errors are not difficult to overcome: missing DOCTYPE, unencoded ampersands, etc. (it should be noted, however, that the missing DOCTYPE does throw the page rendering into Quirks Mode, so keep that in mind if you decide to customize an aStore).

Implementation issues aside, the real story here is that a major corporation, like Amazon, is willing to relinquish some control over look and feel of one of their products and that they are using actual CSS to do it rather than relying on a series of color and font pickers (although that is still an option).

What are your thoughts? Would you like to see more products allow this sort of control? What are they doing right? What are they doing wrong? What could be improved? Personally, I’d like to have the ability to customize the markup (microformats anyone?) and then axe the default styles altogether

Read original post on Webstandards.org and post you comments there!