A VOCABULARY FOR THE MODELLING OF IMAGE SEARCH

MICROSERVICES

Jos

e Ignacio Fern

andez-Villamor, Carlos A. Iglesias and Mercedes Garijo

Departamento de Ingenier

ıa de Sistemas Telem

aticos, Universidad Polit

ecnica de Madrid, Madrid, Spain

Keywords:

Service description, Mashups, Semantic web, Web applications, REST.

Abstract:

In order to take advantage of the services that are available on the Web, several approaches that allow describ-

ing services have been proposed. With them, developers can publish service descriptions, allowing services to

be automatically executed and composed. However, in most cases, the service description task is not carried

out, partly because it is a time-consuming task. This has caused initiatives such as WSMO lite, SA-REST,

hRESTS or Microservices, that try to reduce complexity in services, to appear.

Also, an increasing number of web applications have followed the Linked Data initiative and publish infor-

mation that is machine processable thanks to Semantic Web technologies such as RDF. However, sometimes

direct access to information requires the usage of search forms and, in other cases, spidering techniques such

as focused crawling in order to aggregate and ﬁlter data. Automatic execution of search services would im-

prove access to information in the web by enabling agents to automatically aggregate, ﬁlter and directly access

data.

In this paper, it is presented how the Microservices framework can provide a feature-based vocabulary for the

description of image search services. Microservices framework is a lightweight service description framework

that take feature-oriented and aspect-oriented programming ideas to service description. The article illustrates

how this vocabulary can characterise a set of popular search services, such as Google Images or Flickr. In

addition, the article describes how this vocabulary can be used for the development of new services, such as a

metasearcher that aggregates results from various search services.

1 INTRODUCTION

In the current open Internet, several services are

available in web applications, following the Service-

Oriented Architecture (Erl, 2005) through either Web

Services architecture (McIlraith et al., 2001) or REST

architectural style (Fielding, 2000). This view sug-

gests services being publicly accessible to make the

Web a global software library, with software services

and components ready for their use by developers.

In order to make services machine processable,

Semantic Web Services (Zhou et al., 2006) standards

such as OWL-S (World Wide Web Consortium, 2004)

or WSMO (Roman et al., 2005) allow building se-

mantic service descriptions. Machine agents can au-

tomatically process service descriptions to perform

execution, discovery and composition operations in

an automated way.

Web Services architecture misses integration with

REST architectural style (Wilde and Gaedke, 2008),

resulting in the use of the Web as a platform and

thus adding unnecessary complexity to the protocol

stack. In order to improve the integration of the ser-

vice architecture with the REST architectural style of

the Web, initiatives such as WADL (Hadley, 2006)

try to enable Semantic Web Services approach with

a RESTful design in mind.

Anyway, both WS-based and REST-based seman-

tic web services approaches share the common tar-

get of deﬁning semantically rich service descriptions

in order to enable agents to perform automatic tasks

such as service discovery, execution, and composi-

tion. Unfortunately, Semantic Web Services have

not reached wide adoption yet (Murphy et al., 2008),

partly because building service descriptions is a very

time-consuming task. This has originated research

in lightweight semantic service descriptions with ini-

tiatives like WSMO lite (Vitvar et al., 2007), or

RESTful approaches such as SA-REST (Sheth et al.,

2007), hRESTS (Wright State University, 2008), or

Microservices (Fern

andez-Villamor et al., 2010).

Also, semantic technologies such as RDFa (Adida

199

Ignacio Fernández-Villamor J., A. Iglesias C. and Garijo M. (2010).

A VOCABULARY FOR THE MODELLING OF IMAGE SEARCH MICROSERVICES.

In Proceedings of the Fifth International Conference on Evaluation of Novel Approaches to Software Engineering, pages 199-206

DOI: 10.5220/0003001101990206

 SciTePress

and Birbeck, 2008) allow annotating web resources

and publishing Linked Data (Berners-Lee, 2006),

which makes information machine processable. Still,

there are pieces of information which are either hid-

den behind search services (or, in general, any HTML

form) or hardly accessible, so long as information dis-

covery in the Web is performed through web spider-

ing. This makes that tasks such as getting a particu-

lar archive of posts in a web log is a tough task that

requires spidering techniques such as focused crawl-

ing (Chakrabarti et al., 1999). Therefore, by describ-

ing search services semantically, access to informa-

tion would be improved.

This paper attempts to reduce the effort of build-

ing service descriptions of image search services

through the use of lightweight semantics. We

deﬁne a vocabulary for the description of image

search services by using Microservices framework, a

lightweight approach to service description inspired

in aspect-oriented and feature-oriented programming

paradigms. Microservices enable automatic discov-

ery of service descriptions, as well as reusing feature

descriptions among different services. A vocabulary

for deﬁning descriptions for image search services has

been deﬁned and applied on a case study of building a

metasearcher that aggregates search results from dif-

ferent search services.

The article is structured as follows. First, the

fundamentals of the Microservices framework is pre-

sented in section 2. Then, section 3 presents a vocab-

ulary for describing image search services, obtained

from the analysis of popular image search services.

Section 4 describes how this vocabulary has been ap-

plied on a case study for building a metasearcher that

aggregates search results from different search ser-

vices. Then, section 5 describes related work. Finally,

section 6 draws out the main conclusions and future

work derived from this research.

2 MICROSERVICES

FRAMEWORK

We will use Microservices framework (Fern

andez-

Villamor et al., 2010), a lightweight RESTful feature-

oriented service description framework for describing

services in RESTful web applications. Microservices

framework attempts to simplify the process of deﬁn-

ing service descriptions to favour automatic service

consumption in the Semantic Web. In this section, an

introduction of the motivation behind this framework

is given, followed by a description of it.

2.1 Feature-orientation

Microservices framework apply ideas inspired in mix-

ins, aspect-oriented and feature-oriented program-

ming paradigms to semantic service description.

These paradigms extend object-oriented program-

ming by allowing the modelling of secondary con-

cerns in an isolated way. Feature-Oriented Program-

ming (FOP) (Prehofer, 1997) is a composition model

that allows reﬁning classes through the deﬁnition of

features, i.e., subclasses with core functionality. Mix-

ins (Bracha and Cook, 1990), or abstract subclasses,

are separate groups of methods that can be inserted

into a class to override the original behaviour, but

which cannot be instantiated on their own. There-

fore, mixins serve to implement features in FOP (Apel

et al., 2006). FOP can be seen as a generalization of

traditional class inheritance in Object-Oriented Pro-

gramming, and is used to develop the so-called soft-

ware product lines, i.e. programs that provide differ-

ent combinations of features (Lopez-Herrejon, 2005).

Aspect-Oriented Programming (AOP) (Elrad

et al., 2001) similarly proposes separating concerns

that cross-cut various classes or methods, with the

logging aspect as the most popular example of a

cross-cutting concern. Code from aspects is injected

into speciﬁed join points in classes. This way, by us-

ing AOP, logging commands can be inserted into ap-

propriate join points in a class without changing the

original code of the class.

AOP and FOP are different paradigms despite the

existing similarity between them, as pointed out in

(Lopez-Herrejon, 2005), so long as they propose dif-

ferent methods to combine code (code weaving vs.

modiﬁcation of inheritance chains). Some efforts try

to combine the two approaches by introducing new

concepts such as Multi Mixins, Aspectual Mixins,

and Aspectual Mixin Layers (Apel et al., 2005).

Feature and aspect orientation have inspired

other modelling approaches, such as Feature-Oriented

Model Driven Development (Trujillo et al., 2007),

in which models are created by composing features.

Similarly, Role-oriented programming (Steimann,

2000) or Subject-oriented programming (Harrison

and Ossher, 1993) regard separation of object roles

and the so-called subjective perceptions, respectively.

In Microservices framework, the idea of sepa-

rating features and concerns is employed to enable

feature-oriented service modelling. A service de-

scription is a composition of features, allowing the

reuse of feature descriptions in a similar way as fea-

tures, aspects and abstract classes are reused in the

previously mentioned paradigms. This modelling ap-

proach is described in the following section.

ENASE 2010 - International Conference on Evaluation of Novel Approaches to Software Engineering

200

Figure 1: Feature-oriented description framework.

2.2 Modelling Approach

Microservices framework follows a feature-oriented

description framework, as shown in ﬁgure 1. This

framework allows to describe services semantically

in terms of their features in order to allow reusing de-

scriptions at a feature level.

In Microservices framework, a service is modelled

as a set of features f

, f

, ..., f

that it has. In web

applications, some examples of service features are

“performing a retrieval operation”, “requiring user

authentication”, “performing a storage operation”,

“handling images”, or “outputting a set of resources”.

In order to provide a mapping between a service’s

feature set and a service’s formal description, Mi-

croservices framework includes feature deﬁnitions. A

feature deﬁnition F is a rule that maps a set of fea-

tures f

, ..., f

to a set of conditions. It is activated

when the set of features is present in the service’s

feature-oriented description, and produces a formal

description. By aggregating all descriptions from the

activated feature deﬁnitions, a service formal descrip-

tion can be obtained.

For example, given a microservice description F

and features f

(“outputting a set of resources”) and

(“handling images”), some feature deﬁnitions can

be the following:

∈ F ⇒ |Out put| > 1 (1)

∈ F ∧ f

∈ F ⇒ ∀x(x ∈ Out put → image(x)) (2)

Feature deﬁnition 1 formalizes feature f

by stat-

ing that the service’s output cardinality has to be

higher than one. Meanwhile, feature deﬁnition 2 for-

malizes that all output resources are images, and is ap-

plicable for services that (i) output a set of resources

(as of feature f

) and (ii) handle images (feature f

Therefore, the formal description of a service that is

feature-oriented-described by f

and f

would be:

(|Out put| > 1) ∧ ∀x(x ∈ Out put → image(x)) (3)

It can be observed that feature deﬁnition 1 is ac-

tivated by the presence of one feature in the feature-

oriented description. Therefore, that deﬁnition serves

to formalize one feature. However, feature deﬁnition

2 is activated by the presence of two features in the

feature-oriented description.

Allowing deﬁnitions that are activated upon the

presence of more than one feature might be regarded

as unnecessary complexity. However, this versatility

is justiﬁed. Consider feature f

as “The service stores

a resource that is provided as input”. When using f

with f

, a postcondition should be set (i.e. “multiple

images will be returned”), but when used with fea-

ture f

, a precondition should be set (i.e. “an image

has to be provided as input”). This can be achieved

by setting one deﬁnition for f

and f

(as shown in

deﬁnition 2), and another deﬁnition for f

and f

, as

shown next:

∈ F ∧ f

∈ F ⇒ ∀x(x ∈ Input → image(x)) (4)

This serves to resolve the issue of feature interac-

tion, already identiﬁed in feature-oriented program-

ming (Prehofer, 1997). By describing features se-

mantically, feature descriptions can be combined to

produce a semantic service description.

Microservices framework has a vocabulary of

terms that can be extended, with each term represent-

ing a feature. As the framework follows the REST

architectural style, terms for HTTP GET, POST, PUT

or DELETE requests are already part of the vocabu-

lary.

As a feature-oriented description framework, the

microservice approach has the following advantages:

(i) it allows the reuse of feature descriptions among

different services, and (ii) it reduces the description

task to selecting a set of features that describes the

considered service, given a vocabulary of terms.

3 A VOCABULARY FOR SEARCH

MICROSERVICES

In this paper, we deﬁne a vocabulary for describing of

services that perform retrieval operations, i.e. search

services. In order to narrow the modelling task, we

will only consider image search services. These kinds

of services attempt to fulﬁl the user’s goal of ﬁnding

a particular kind of image.

In order to perform this task, we will follow the

next steps:

1. Identify popular image search services.

2. Collect features across the considered services.

3. Model features through feature deﬁnitions.

4. Adapt services to ﬁt the modelled interface.

A VOCABULARY FOR THE MODELLING OF IMAGE SEARCH MICROSERVICES

201

3.1 Service Modelling

We will consider Google Images, Panoramio, Bing

Images and Flickr search as search services that will

be analyzed and modelled. Many more image search

services are available, but we have based our decision

on the fact that:

1. Flickr offers capabilities that are not present on

the other services, such as tag search.

2. Panoramio offers additional capabilities that are

not present on the rest of services, such as search

by location.

3. Google Images and Bing Images have similar ca-

pabilities, but offer a different interface. This fact

could impact on the vocabulary.

After identifying the services that are considered

for the modelling task, we will collect raw features

from these services. By observing each of these ser-

vices, we can see that some features deﬁne the obvi-

ous behaviour of a search service and are enabled by

default, while others require additional conﬁguration

in the service, often accessible through an “advanced

search” option. Therefore, for this task, we accessed

“advanced search” and help pages of the services in

order to discover their capabilities.

It is immediate to identify raw features such as

“the service returns a set of images as search re-

sult”. However, this raw feature can be split into ﬁner-

grained features, such as “returning a set of results”,

“returning an image” and “performing a retrieval op-

eration”. The combination of these three features

would produce the ﬁrstly identiﬁed raw feature. By

splitting raw features into ﬁner-grained features, more

feature combinations are possible.

Table 1 summarizes the features that we have

identiﬁed in the considered services. The ﬁrst col-

umn shows raw features that were identiﬁed in the

services, while the next column represents the spe-

ciﬁc ﬁner-grain features that are produced. The third

column is a shorthand term that represents the feature

and, ﬁnally, the last four columns indicate the pres-

ence of these features in each service. As anticipated,

Google Images and Bing Images share the same ca-

pabilities, while Flickr and Panoramio services serve

to enrich the vocabulary in order to cover a wider set

of features.

The next step is modelling the features, so that a

service description can be produced out of a list of

features. In Microservices framework, this is done by

deﬁning feature deﬁnitions, i.e., sets of logical pre-

conditions and postconditions that are activated on the

presence of a speciﬁc set of features. An example is

the fact of outputting images: feature image and fea-

ture get should set the postcondition that the service’s

output has to be an image, which, more formally, is:

image ∧ get ⇒ ∀x(x ∈ Out put → image(x))

This feature deﬁnition solves the feature interaction

between image and get.

Therefore, for each of the identiﬁed features, a

set of feature deﬁnitions have been built that con-

sider the possible feature interactions. The identi-

ﬁed feature deﬁnitions are shown in table 2. The ﬁrst

column shows the features that are involved in each

deﬁnition, and the next two columns show the pre-

conditions and postconditions. Microservices frame-

work uses Javascript notation to express conditions,

but we have used Mathematical notation for this pur-

pose. Also, although Microservices framework also

allows deﬁning a textual description for each feature

deﬁnition that enables documenting of the service, we

have omitted these textual descriptions in table 2 for

clarity purposes.

These feature deﬁnitions allow producing a for-

mal service description, deﬁned by a set of precon-

ditions and postconditions. This service description

can be processed to perform operations such as au-

tomatic validation (validating preconditions and post-

conditions), automatic discovery of the semantics of

inputs, or automatic user interface generation, as will

be seen in section 4.

Microservices framework allow wrapping exist-

ing services into services that ﬁt a speciﬁc interface.

In our case, we have deﬁned a vocabulary of terms

that allow describing, at least, the considered services.

However, in our model we have made assumptions

such as resource attributes’ names or input parame-

ters’ names. In order for the services to ﬁt this in-

terface, an adaptation has to be performed. For each

service, we have deﬁned an adapter, i.e. a piece of

code that adapts input parameters, and a data extrac-

tor, i.e. a collection of XML selectors that trans-

forms HTML’s unstructured information into struc-

tured data. This lets using the existing services with

the interface that has been deﬁned in the vocabulary.

3.2 Discussion

The considered services have been adapted for the de-

ﬁned interface and are available online

. Each service

can be executed through a user interface that is gener-

ated automatically by analysing the services’ feature

deﬁnitions. Also, a documentation of the service can

be obtained by combining the feature deﬁnitions. Ad-

ditionally, when executing the service adapters, the

preconditions and postconditions are checked, which

http://lab.gsi.dit.upm.es/microservices/proxies

ENASE 2010 - International Conference on Evaluation of Novel Approaches to Software Engineering

202

Table 1: Analysis of detailed features in the considered services.

Raw feature Feature Term

Google

Bing

Flickr

Panoramio

A set of images is returned to

the user as search result

Retrieval operation performed get X X X X

Multiple resources involved multiple X X X X

Service deals with images image X X X X

Images are ﬁltered according to

a location

Resource is ﬁltered by location location-filtered 7 7 7 X

Images are indexed from any-

where in the web

Resource cannot belong to another do-

main

local 7 7 X X

Images are summarized and

have a thumbnail

Resource is summarized summarized X X X X

Resource has a title titled 7 7 X X

Images can be searched by key-

words

Resource is ﬁltered by given keywords keyword-filtered X X X 7

Images can be searched by tags Resource is ﬁltered by given tags tag-filtered 7 7 X X

Images can be searched by di-

mensions

Resource is ﬁltered by dimensions size-filtered X X X 7

Images can be searched by

creation or taking date

Resource is ﬁltered by creation date creation-filtered 7 7 X 7

Resource is ﬁltered by publishing date publishing-filtered 7 7 X 7

Images can be selected by li-

cense

Resource is ﬁltered by license license-filtered 7 7 X 7

Images can be searched by

colour and content

Resource is ﬁltered by colour colour-filtered X X 7 7

Resource is ﬁltered by content content-filtered X X 7 7

allows automatic validation of the services. Also,

microservices descriptions are published as Linked

Data, as well as the services’ output.

Some additional aspects of the approach are worth

mentioning. For example, both Bing and Google

Images allow ﬁltering images by content. Bing al-

lows image ﬁltering by photographies, illustrations

and content ﬁltering by face or face and shoulders.

Instead, Google supports ‘clip art’ ﬁltering, as well

as photos, illustrations and face ﬁltering, but not face

and shoulders ﬁltering. Therefore, although both of

them have the capability of ﬁltering images by content

type, the speciﬁc feature is slightly different in each of

them. In order to reduce complexity, we will assume

that both services share the content-filtered fea-

ture, and adapt the input appropriately at the services’

adapters. This means, however, that the speciﬁc fea-

ture of this ﬁltering capability for each service cannot

be discovered from the service description.

Finally, the feature-oriented approach allows

reusing features across different services, even in the

case that they belong to different domains. Many of

the modelled features can be combined to describe

services that do not target image retrieval, but re-

source retrieval in general. A video search service

would only need to introduce a new feature (“deal-

ing with videos”) and deﬁne a few feature deﬁnitions.

Similarly, a document search service is simply a sub-

set of the deﬁned vocabulary (i.e. to deﬁne a web page

search service, the image feature should be left out).

Storage services (i.e. those performed with the HTTP

POST and PUT methods) would require more feature

deﬁnitions, as most deﬁnitions interact with get fea-

ture.

4 CASE STUDY: METASEARCH

SERVICE

A metasearch service

has been implemented as

a case study for the deﬁned vocabulary. This

metasearcher aggregates results from the described

services (i.e. Google Images, Bing Images, Flickr and

Panoramio). As these services have heterogeneous

features, the problem is not trivial.

The metasearcher works as follows. First, it con-

siders a microservice description that includes all the

features shown in table 1. Then, by analizing the con-

ditions that result from combining feature deﬁnitions,

it identiﬁes required inputs and their types. With this

set of inputs, it builds a user interface that allows ex-

ecuting the service.

However, as can be observed in table 1, no ser-

vice has all the mentioned features. The metasearcher

will then select matching services according to the

features that are used in each query. In order to do

so, the metasearcher validates preconditions for each

feature. If the precondition is not valid, the feature is

http://lab.gsi.dit.upm.es/microservices/metasearch

A VOCABULARY FOR THE MODELLING OF IMAGE SEARCH MICROSERVICES

203

Table 2: Speciﬁcation of features.

Features Preconditions Postconditions

get method(service) = get status(service) = 500

image get - ∀x(x ∈ Out put → image(x))

multiple get - |Out put| > 1

summarized get - ∀x(x ∈ Out put → ∃y(uri(x, y)))

keyword-filtered get ∃i(i ∈ Input ∧ name(i, “keywords”)) ∀x(x ∈ Out put → keywords(x) ⊆ i)

tag-filtered get ∃i(i ∈ Input ∧ name(i, “tags”)) ∀x(x ∈ Out put → tags(x) ⊆ i)

local get - ∀x(x ∈ Out put → domain(x) =

domain(service))

titled get - ∀x(x ∈ Out put → ∃y(title(x, y))

size-filtered image get ∃i(name(i, “size”) ∧ i ∈ Input ∩

{small, medium, big})

∀x(x ∈ Out put → size(x, i))

creation-filtered get ∃i(i ∈ Input ∩ Dates ∧

name(i, “creation”))

∀x(x ∈ Out put → creation(x) < i)

publishing-filtered get ∃i(i ∈ Input ∩ Dates ∧

name(i, “publication”))

∀x(x ∈ Out put → publication(x) < i)

license-filtered get ∃i(name(i, “license”) ∧ i ∈ Input ∩

{attribution, modi f iable, commercial})

∀x(x ∈ Out put → license(x, i))

location-filtered get ∃lat, lng, r(lat, lng, r ∈ Input ∩ R) ∀x(x ∈ Out put → ||x − (lat, lng)|| < r)

content-filtered get ∃i(name(i, “content”) ∧ i ∈ Input ∧ i ⊆

{ f ace, shoulders, clipart, illustration})

∀x(x ∈ Out put → content(x, i))

colour-filtered get ∃i(name(i, “colour”) ∧ i ∈ Input ∩

{bw, r, g, b})

∀x(x ∈ Out put → color(x, i))

considered inactive. Only active features will be con-

sidered when ﬁltering services. Then, the matching

services are executed and their results are aggregated.

For example, let’s consider that a user interacts

with the metasearcher by providing some keywords,

picking an image size, and clicking the submit

button. Then, location-filtered, tag-filtered,

creation-filtered, publishing-filtered,

license-filtered, coloured-filtered and

content-filtered features will be deactivated, as

long as their preconditions are not satisﬁed (as long

as their required inputs are not provided).

It is remarkable that the process of detecting the

features to deactivate is not immediate. An insatis-

ﬁed condition belongs to a feature deﬁnition, which

can involve many features. For example, if no key-

words are passed to the metasearcher, it has to de-

cide whether to deactivate feature get or feature

keyword-filtered, as both are involved in the def-

inition that requires keywords as input. We consider

that the number of feature interactions is an indica-

tor of the importance of a feature. Therefore, the

employed criteria has been to perform the minimum

number of deactivations of deﬁnitions (and thus the

minimum number of deactivation of feature interac-

tions), and an algorithm has been implemented for

this purpose.

Also, the activation state of certain features can-

not be identiﬁed automatically. This is the case of the

local feature and titled feature, which are present

only in Flickr and Panoramio, and do not set precon-

ditions. These features are thus not considered by the

metasearcher for service matching, as their inclusion

would make that only Flickr and Panoramio are able

to match the required features.

The metasearcher has been implemented as a

generic microservice aggregator, in which a set of fea-

tures are selected for service matching and aggrega-

tion. This means that this implementation is indepen-

dent of the considered features, as the user interface

is built by analyzing a microservice description, and

the features are selected according to the satisfaction

of their preconditions. We have also experimented

on aggregating plain search services with same satis-

factory results, allowing to aggregate image results as

well as document results. This makes this implemen-

tation an interesting foundation for the deﬁnition of

an abstract microservice aggregator based on sets of

required features, which however is out of the scope

of this paper.

5 RELATED WORK

In our paper, we have addressed the issue of de-

scribing search services using lightweight semantics.

WADL (Hadley, 2006) deﬁnes a format for build-

ing and publishing RESTful semantic service descrip-

tions which can be discovered and processed by auto-

matic agentes. Other similar RESTful approaches are

SA-REST (Sheth et al., 2007) and hRESTS (Wright

State University, 2008), which allow building seman-

ENASE 2010 - International Conference on Evaluation of Novel Approaches to Software Engineering

204

tic service descriptions by annotating textual descrip-

tions of services’ APIs with RDFa and Microformats

(Microformats community, 2008), respectively. Also,

RDForms (Baker, 2005) attempts to “add to the Se-

mantic Web capabilities similar to HTML forms”.

In this approach, schemas for indexable, container

and settable operations are deﬁned, which represent

HTTP GET, POST, and PUT methods, respectively.

All these approaches focus on facilitating service de-

scription, but do not consider reuse of features across

different services, as they are not feature-oriented.

Also, a vocabulary for the description of search ser-

vices in these approaches is missing.

On the speciﬁc topic os search services,

OpenSearch (A9.com, inc., 2005) is an approach to

the description of search services. By creating an

OpenSearch description document, a search service

is published. The description document enumer-

ates the services’ capabilities and conﬁgurations.

OpenSearch delegates to service providers to build an

appropriate RESTful interface that can be described

using OpenSearch. Some services might require

adaptation in order to be described by an OpenSearch

description, but this issue is not addressed. Finally, as

OpenSearch is limited to search services, it considers

ﬁne-grain aspects such as content encoding. In our

case, these details are missing, as complexity is

moved to service adaptation on behalf of a simpler

description framework.

6 CONCLUSIONS AND FUTURE

WORK

In this paper, we have reviewed the current state of

the art in semantic service description and discussed

how access to Linked Data could be improved by au-

tomating the execution of search services.

We have used Microservices framework to build

a vocabulary that can be employed to build seman-

tic service descriptions for image search services in

the web. The solution is a small set of terms that il-

lustrates the feature-oriented approach of the frame-

work and highlights the versatility of lightweight se-

mantics. The feature-oriented approach has provided

a solution that generalizes well to other search ser-

vices while it is speciﬁc to the targete domain. The

vocabulary has been used to semantically describe a

set of services that are aggregated on a metasearcher

as a case study.

Future works regard automatic creation of user in-

terfaces and services, and automatic detection of fea-

tures through pre and postconditions. Preliminary ap-

proaches have been shown in the case study, where

appropriate user interface controls are shown for each

search option, based on the semantics of each input

parameter, and where appropriate feature sets are se-

lected according to the provided inputs.

ACKNOWLEDGEMENTS

This research project is funded by the European Com-

mission under the R&D project ROMULUS (FP7-

ICT-2007-1) and by the Spanish Government under

the R&D project Java sobre Ruedas (FIT-350401-

2007-8).

REFERENCES

A9.com, inc. (2005). OpenSearch speciﬁca-

tion. http://www.opensearch.org/Speciﬁcations/

OpenSearch/1.1.

Adida, B. and Birbeck, M. (2008). RDFa Primer

- Bridging the Human and Data Webs.

http://www.w3.org/TR/xhtml-rdfa-primer/.

Apel, S., Leich, T., Rosenmller, M., and Saake, G. (2005).

Combining feature-oriented and aspect-oriented pro-

gramming to support software evolution. In In

AMSE05, at ECOOP05.

Apel, S., Leich, T., and Saake, G. (2006). Aspectual mixin

layers: aspects and features in concert. In Proceed-

ings of the 28th international conference on Software

engineering, page 131. ACM.

Baker, M. (2005). RDF Forms. http://www.markbaker.ca/

2003/05/RDF-Forms/.

Berners-Lee, T. (2006). Linked data. Retrieved April,

12:2008.

Bracha, G. and Cook, W. (1990). Mixin-based inheri-

tance. In Proceedings of the European conference

on object-oriented programming on Object-oriented

programming systems, languages, and applications,

pages 303–311. ACM New York, NY, USA.

Chakrabarti, S., Van den Berg, M., and Dom, B. (1999).

Focused crawling: a new approach to topic-speciﬁc

web resource discovery. Computer Networks, 31(11-

16):1623–1640.

Elrad, T., Filman, R. E., and Bader, A. (2001). Aspect-

oriented programming: Introduction. Commun. ACM,

44(10):29–32.

Erl, T. (2005). Service-oriented architecture: concepts,

technology, and design. Prentice Hall PTR Upper Sad-

dle River, NJ, USA.

Fern

andez-Villamor, J. I., Iglesias, C., and Garijo, M.

(2010). Microservices: Lightweight service descrip-

tions for REST architectural style. In Proceedings of

the 2nd International Conference on Agents and Arti-

ﬁcial Intelligence.

A VOCABULARY FOR THE MODELLING OF IMAGE SEARCH MICROSERVICES

205

Fielding, R. T. (2000). Architectural Styles and the Design

of Network-based Software Architectures. PhD thesis,

University of California.

Hadley, M. J. (2006). Web application description language.

https://wadl.dev.java.net/wadl20061109.pdf.

Harrison, W. and Ossher, H. (1993). Subject-oriented pro-

gramming: a critique of pure objects. ACM Sigplan

Notices, 28(10):411–428.

Lopez-Herrejon, R. (2005). Understanding feature mod-

ularity in feature oriented programming and its im-

plications to aspect oriented programming. In

ECOOP2005 PhDOOS Workshop and Doctoral Sym-

posium, Glasgow, Scotland.

McIlraith, S. A., Son, T. C., and Zeng, H. (2001). Semantic

Web Services. IEEE Intelligent Systems.

Microformats community (2008). Microformats.

http://microformats.org/.

Murphy, M., Dick, M., Fischer, T., Fraunhofer, I., and

Stuttgart, G. (2008). Towards the” Semantic Grid”: A

state of the art survey of Semantic Web services and

their applicability to collaborative design, engineer-

ing, and procurement. Communications of the IIMA,

8(3):11–24.

Prehofer, C. (1997). Feature-oriented programming: A

fresh look at objects. Lecture Notes in Computer Sci-

ence, 1241:419–443.

Roman, D., Keller, U., Lausen, H., de Bruijn, J., Lara, R.,

Stollberg, M., Polleres, A., Feier, C., Bussler, C., and

Fensel, D. (2005). Web Service Modeling Ontology,

Applied Ontology. IOS Press.

Sheth, A. P., Gomadam, K., and Lathem, J. (2007). SA-

REST: Semantically Interoperable and Easier-to-Use

Services and Mashups. In IEEE Computer Society.

Steimann, F. (2000). On the representation of roles in

object-oriented and conceptual modelling. Data &

Knowledge Engineering, 35(1):83–106.

Trujillo, S., Batory, D., and Diaz, O. (2007). Feature ori-

ented model driven development: A case study for

portlets. In Proceedings of the 29th international con-

ference on Software Engineering, pages 44–53. IEEE

Computer Society.

Vitvar, T., Kopecky, J., and Fensel, D. (2007). Wsmo-lite:

Lightweight semantic descriptions for services on the

web. In Proceedings of the Fifth European Conference

on Web Services, pages 77–86. Citeseer.

Wilde, E. and Gaedke, M. (2008). Web Engineering Re-

visited. In Proceedings of the 2008 British Computer

Society (BCS) Conference on Visions of Computer Sci-

ence, London, UK (September 2008).

World Wide Web Consortium (2004). OWL-S: Semantic

Markup for Web Services. http://www.w3.org/Sub-

mission/ OWL-S/.

Wright State University (2008). HTML Microfor-

mat for Describing RESTful Web Services and

APIs. http://knoesis.wright.edu/research/srl/projects/

hRESTs/#hRESTs.

Zhou, J., Koivisto, J.-P., and Niemela, E. (2006). A survey

on semantic web services and a case study. In Com-

puter Supported Cooperative Work in Design, 2006.

CSCWD ’06. 10th International Conference on, pages

1–7.

ENASE 2010 - International Conference on Evaluation of Novel Approaches to Software Engineering

206