Boxee is a media center based on XMBC media center with plugin architecture for custom apps. The embedded video below shows such an app for the Czech TV’s iVysilani.

The book is now available at Amazon or Springer.

See my citation spreadsheet and the related atom feed for more details. In case you want to have your own, just create a copy of the spreahsheet (File/Make a Copy), change the value of the name field or change the Google Scholar URL as you like (on the input sheet), and share the citations sheet as Atom feed (Share/Publish as a Web Page and then select the citations sheet and the ATOM format). After that just add the feed as a new subscription in your favorite feed reader. Note that the feed gets updated every 5 minutes (this is what you cannot influence).

UPDATE: I am now displaying the citations of my papers on citations tab in my publications page. I only parsed the XML atom feed in JavaScript and rendered it in HTML. However, due to the current XHR cross-domain restrictions I had to create a proxy in Apache serving my vitvar.com domain to access the atom feed URL on google domain.

It is nice to see that apart from our contribution, there is also a chapter from my former collegues from DERI Galway, John Breslin et al., on The Future of Social Websites: Sharing Data and Trusted Applications with Semantics.

The use of such ontology is then quite obvious:

Let’s imagine our search software is responding to a query on pets, but we find articles on dogs and cats, but without the word pets. This database of relationships would let Google know that the article is probably about pets because there are multiple instances of a subcategory of “pet.” The database would enable much better search and better language translation because there’d be a better understanding of the meaning of the words.

From this interview it is clear that Google recognizes the importance of semantics for search, however, the major challenge is in construction of ontologies describing a huge and a dynamic environment on which such intelligent search would reliably operate.

• Formal Model for Semantic-Driven Service Execution, International Semantic Web Conference (Karlsruhe, Germany, 2008) (se my talk and my previous post)
  
• WSMX Middleware for Dynamic Discovery in B2B Integration (demo), IEEE International Conference on Semantic Computing (Santa Clara, USA, 2008),
• WSMX: a Solution for B2B Mediaion and Discovery Scenarios (demo), European Semantic Web Conference (Teneriffe, Spain, 2008),
  
• Execution Model for Heterogenoues Web Services, IEEE Congress on Services (Honolulu, Hawaii, USA, 2008),
• Towards Constraint-Based Composition With Incomplete Service Descriptions, Workshop on Service Composition at the IEEE International Conferences on Web Intelligence (San Francisco, 2007, USA),
• Towards Optimized Data Fetching for Service Discovery, IEEE European Conference on Web Services (Halle, Germany, 2007),
• Towards Semantic Interoperability: In-depth Comparison of Two Approaches to Solving Semantic Web Service Challenge Mediation Tasks, Conference on Enterprise Information Systems (Madeira, Portugal, 2007),
  
• SESA: Emerging Technology for Service-Centric Environments, IEEE Software magazine (2007),
• Semantically-enabled Service Oriented Architecture : Concepts, Technology and Application, Service Oriented Computing and Applications Journal (2007),
• Semantic SOA to Promote Integration of Heterogeneous B2B Services, IEEE Conference on Enterprise Computing (Tokyo, Japan, 2007),
• Dynamic Service Discovery through Meta-Interatctions with Service Providers, European Semantic Web Conference (Innsbruck, Austria, 2007),
• WSMX: a Semantic Service Oriented Middleware for B2B Integration, International Conference on Service Oriented Computing (Chicago, USA, 2006),

My collaboration with Maciej Zaremba, co-architect and software engineer of the solution, turned out to be very successful: we managed not only to build the working solution for the B2B challenge scenarios but also publish the significant number of articles in very competitive research environments (acceptance rates  usually range from 15 to 20 percent).

Fortunately, a very simple solution came into my mind (currently only works on Firefox). First, I create a custom variable in the Firefox configuration settings called general.useragent.extra.private and set its value to “my_agent” (please use your own unique identification, type about:config in your browser’s address bar to create and set such variable). This will add the “my_agent” string to the browser’s agent identification that you can read from within the javascript in the browser by userAgent property of the navigator object (navigator.userAgent). After that you can just add a simple condition to your page’s javascript code that calls Google Analytics methods to track your page’s traffic. The script could look like:

<script type="text/javascript">
    if (navigator.userAgent.indexOf('my_agent') == -1) {
        var pageTracker = _gat._getTracker("UA-xxx");
        pageTracker._trackPageview();
    }
</script>

Update: In Safari, you can set a custom user agent string by enabling Develop menu (goto "Preferences->Advanced->Show Develop Menu in Menu Bar") and in the develop menu "User Agent->Other..." set the user agent string.    

The value of today’s Web applications is no longer only in providing content to consumers but also in exposing functionality through public APIs designed for machine consumption. Typically, both Web applications and APIs today follow the Web architecture style called REST, and public APIs on the Web are often called “RESTful Web services”. The major problem with today’s RESTful APIs is that they are usually only described in a plain, unstructured HTML documentation useful only to a human developer. From this reason, finding suitable services, composing them (“mashing them up”), mediating between different data formats etc. are currently completely manual tasks.

hRESTS is a microformat for machine-readable descriptions of Web APIs, backed by a simple service model. In general, a microformat is an approach for annotating human-oriented Web pages so that key information is machine-readable. On top of microformats, GRDDL is a mechanism for extracting RDF information from Web pages, particularly suitable for processing microformats. There are already microformats for contact information, geographic coordinates, calendar events, etc.

Figure above depicts the model that the hRESTS uses for HTML annotation. It is derived from the fact that every web application using hyperlinks for linking application’s pages can be seen as a service. Obviously, not every web application can be considered as a RESTful service as it does not necessarily follow the REST architecture style. There are a lot of examples of badly designed RESTful architectures, such as here. We use RDF to represent the model that can be further extended with additional information such as WSMO-Lite service ontology (see my previous post and our paper about WSMO-Lite). In its basic form, the hRESTS annotation for a hotel service is shown below.

In order to extract the meta-data from the annotated HTML document using hRESTS, one needs to know the hRESTS annotation mechanism. For this purpose and in accordance with GRDDL we also provide a XSLT stylesheet that extracts the meta-data in RDF from XHTML pages. You can download the XSLT stylesheet here.

Once the hRESTS is used by RESTful service providers, one can easily build a focused search engine for RESTful services, for example by using Yahoo! BOSS web search in analogical way like BOSS web search can be used for e.g. searching LinkedIn public profiles annotated with hResume microformat. We further plan to submit the hRESTS microformat to microformats.org as well as build extenisions towards semantic annotations which we call MicroWSMO.

In this work we define a model and an algorithm for execution of services which interfaces are modeled using Abstract State Machines (ASM) that use ontological concepts for their vocabularies (we call this description a choreography). Ontologically-enhanced ASM allows to model services’ interfaces with more descriptive information (as opposed to e.g. interfaces in WSDL only defining a set of operations with input and output messages and message exchange patterns for those operations). In this work we build additional layer of ASM descriptions on top of WSDL descriptions (XML Schema and Interface) and show how a conversation between two services can be executed.

The important aspect of service execution is to maintain services’ interoperability at the data and process levels. Data interoperability needs to be ensured when services use different information models used to define services’ input and output messages, and process interoperability needs to be ensured when one service expects to exchange messages in an order that is not directly matching the order of the other service. We illustrate the usage of the execution model on the case scenario implemented on our WSMO, WSML, and WSMX technologies as the figure below depicts.

The scenario describes a mediation problem defined by the SWS Challenge initiative. In the scenario, a trading company, called Moon, uses a Customer Relationship Management system (CRM) and an Order Management System (OMS) to manage its order processing. Moon has signed agreements to exchange Purchase Order (PO) messages with a company called Blue using the RosettaNet standard PIP3A4. There are two interoperability problems in the scenario: At the data level, the Blue uses PIP3A4 to define the PO request and confirmation messages while Moon uses a proprietary XML Schema for its OMS and CRM systems. At the process level, the Blue follows PIP3A4 Partner Interface Protocol (PIP), i.e. it sends out a PIP3A4 PO message, including all items to be ordered, and expects to receive a PIP3A4 PO confirmation message. On the other hand, various interactions with the CRM and OMS systems must be performed in Moon in order to process the order, i.e. get the internal ID for the customer from the CRM system, create the order in the OMS system, add line items into the order, close the order, and send back the PO confirmation.

By using ASMs and ontologies we automatically adjust the order of messages conforming to both services’ descriptions while at the same time we resolve data interoperability conflicts by using ontology alignments between services’ information models. The following Figure depicts the model in a form of a state diagram.

In our paper we describe in detail the algorithm for services execution operating according to the model depicted in the figure above. The input for the algorithm are two services both having defined their choreographies as ontologized ASMs over WSDL interface operations (in addition, a grounding between ASM rules and underlying WSDL interface operations is also defined), and ontology alignments between both services’ ontologies. In a nuthshell, when a message is available from one service, the algorithm process the message, that is, it transforms the message to the others service’s ontology and places the message for evaluation by its choreography.

It is important to note, that our algorithm works well in cases when the two choreographies are compatible, that is, interoperability can be achieved by adjusting the order of messages. The algorithm in its current form will not work when there is a message requested by one service that the other service never sends. In such cases, the message would have to be created on the fly based on some background knowledge that the algorithm should posses while at the same time solutions for such problems would need to build on a concrete semantics of messages. For example, the algorithm should know that a message is an acknowledgment message, etc. These questions remain open for our future research.