Pierre Châtel
email: pierre.chatel@thalesgroup.com

Jacques Malenfant
email: jacques.malenfant@lip6.fr

LCP-Nets: A Linguistic Approach for Non-functional Preferences in a Semantic SOA Environment

Keywords: preference modelling, fuzzy linguistic approach, CP-nets, Web service filtering Category: H.3, J.0

This paper addresses the problem of expressing preferences among nonfunctional properties of services in a Web service architecture. In such a context, semantic and non-functional annotations are required on service declarations and business process calls to services in order to select the best available service for each invocation. To cope with these multi-criteria decision problems, conditional and unconditional preferences are managed using a new variant of conditional preference networks (CPnets), taking into account uncertainty related to the preferences to achieve a better satisfaction rate. This variant, called LCP-nets, uses fuzzy linguistic information inside the whole process, from preference elicitation to outcome query computation, a qualitative approach that is more suitable to business process programmers. Indeed, in LCP-nets, preference variables and utilities take linguistic values while conditional preference tables are considered as fuzzy rules which interdependencies may be complex. The expressiveness of the graphical model underlying CP-nets provides for solutions to gather all the preferences under uncertainty and to tackle interdependency problems. LCP-nets are applied to the problem of selecting the best service among a set of offers, given their dynamic non-functional properties. The implementation of LCP-nets is presented step-by-step through a real world example.

Introduction

Service-oriented architectures (SOA) deal with the growing need for distributed applications capable of evolving continuously over their execution. In the context of the Web, atomic feature producers are called Web services, and consumers Web processes. These Web services can appear and disappear at runtime, thus requiring a loose coupling between service providers and consumers. We adopt an SSOA (Semantic Service-Oriented Architecture) approach where usual service offers are enhanced with high level business concepts extracted from ontologies as well as non-functional commitments, and are published in dedicated service registries. Based on this information, a loose coupling is implemented at runtime by the late-binding of an abstract service request (originating from the orchestration of a Web process) to a concrete service offer.

This paper focuses on the various steps involved in the implementation of the ultimate part of this matchmaking process: the dynamic selection of Web services based on non-functional consumer preferences and up-to-date QoS (Quality of Service) values of monitored services. In this multi-criteria decision making context, to obtain a total order over services and make specific binding decisions between consumers and producers, we propose a solution based on preferences established among the various non-functional properties of required services. Given the subjective nature of these preferences, they are elicited by business process programmers before running them in the SSOA framework.

The idea is to imagine an approach to elicit and exploit consumers preferences expressed qualitatively, i.e. with linguistic concepts.

In the rest of the paper, first the conceptual and technical framework is introduced, then we briefly describe a set of tools for representing and reasoning with conditional preference statements: the "*CP-nets"1 . Section 3 introduces our proposal of using a fuzzy linguistic variant of CP-nets in modeling preferences, Section 4 gives a proof-of-concept example, while Section 5 points out conclusions and future work.

Background and Related Work

This work takes place in the SSOA and Web services environments that are introduced below. We then briefly detail the related work concerning the fuzzy linguistic approach and the formalism of *CP-nets.

SSOA and non-functional properties

SOA and Web services have recently gained broad industry acceptance as established standards. They provide for greater interoperability and some protection from lock-in to proprietary vendor software. However an SOA can be implemented using any kind of service-based technology.

In our framework, two distinct roles are identified. Service providers implement (generic) functionalities made available to applications as Web services, thanks to SOA standards like, e.g., service registries. Service consumers request and use services available on the network according to their specific requirements through service invocations made by business processes.

To cope with the dynamism of the Web, the binding of Web services (from providers) to business processes (of consumers) is established on the fly, at runtime. To achieve this, and to provide for high interoperability among heterogeneous service offers and requests, we make this binding go much further than the traditional syntactic approach by first using semantic annotations on service offers and requests to identify offers that match each request. This higher level of abstraction is complementary to the usual syntactic definition.

In our approach, semantics encompasses not only functional (what services do and processes need) but also non-functional properties (QoS and related properties). Functionality of service offers concerns the core business work provided by each Web service. We strive to semantically describe the main features of the service: its end goal and the ontological concepts associated to its input and output parameters. We use SAWSDL [START_REF] Lausen | Semantic Annotations for WSDL and XML Schema[END_REF], an extension to the WSDL service interface definition language that introduces semantic annotations, to annotate otherwise syntax-based service offers with classes (i.e. concepts) from domain ontologies. Service requests express similarly their semantic requirements for the completion of their task. Non-functionality, on the other hand, concerns the level of QoS guaranteed by Web services and required by business processes. For each service call, functionally matching offers from registries are further filtered to keep only the ones which non-functional commitments fulfill the requirements of the calling business process.

But we also strive to build Quality of Service (QoS) awareness into the runtime SSOA platform to dynamically select the best service(s) available to fulfill each request. Indeed, after filtering with functional and non-functional constraints, we use non-functional information again to further seek the best offer(s) just prior invoking the service. Hence, at runtime, non-functional requirements become preferences applied to currently measured QoS values associated to the statically filtered services. These concepts are being implemented in the SemEUsE2 ANR project, as seen in Figure 1, where the various components involved in service filtering and selection are shown alongside a simple example: five available services from the registry are filtered then the remaining ones (S1 and S3 ) are dynamically selected upon given their current QoS values and statically defined preferences.

A major issue when dealing with QoS is the large number of different dimensions (e.g. latency, precision, etc.) of importance. Because one rarely gets an offer that is the best for every different QoS dimension, we need consumer preferences to rank offers given their relative strength on the different dimen- sions. Preference elicitation and expression have received attention in past years and several formalisms to do so have been proposed. In the context of SOA, a good formalism must obey several requirements, among which usability by nonspecialists, like business process programmers, is of primary importance. To this end, we propose a new formalism based on the combination of CP-nets and the fuzzy linguistic approach [Zadeh, 1975] to qualitatively specify the preferences of Web consumers over the different non-functional properties of offers.

Fuzzy Linguistic Approach

The fuzzy linguistic approach represents qualitative aspects as linguistic values by means of linguistic variables [Zadeh, 1975]. Appropriate linguistic descriptors must be chosen to form the term set as well as their semantics. The universe of the discourse over which the term set is defined can be arbitrary. In this paper, we shall use the interval [0, 1]. Odd cardinality term sets, typically 5, 7 or 9, are preferred [Delgado et al., 1993, Herrera and[START_REF] Herrera | [END_REF], representing the mid term by an assessment of "approximately 0.5", other terms being placed symmetrically around it. For example, a set of five terms T , could be given as: T = {s 0 : very low , s 1 : low , s 2 : medium, s 3 : high, s 4 : very high}. It is also required that there exist negation Neg, max and min operators defined over this set [START_REF] Herrera | A 2-tuple fuzzy linguistic representation model for computing with words[END_REF]]: (i) a negation operator Neg(s i ) = s j such that j = g -i (g +1 is the cardinality), (ii) a max operator: max(s i , s j ) = s i if s i ≥ s j , (iii) a min operator: min(s i , s j ) = s i if s i ≤ s j .

s 4 s 3 s 2 s 1 s 0 α = -0.3 Figure 2: Lateral displacement of a linguistic label ⇒ (s 2 , -0.3) 2-tuple.
The semantics of the terms is given by membership functions. Linear trapezoidal (even triangular) functions are often considered good enough to capture the vagueness of those linguistic assessments. The use of linguistic variables implies the processes of computing with words for their fusion, aggregation, comparison, etc. To perform these computations, different models have been used such as the semantic [START_REF] Degani | The Problem of Linguistic Approximation in Clinical Decision Making[END_REF], the symbolic [Delgado et al., 1993, Truck and[START_REF] Truck | [END_REF] or the 2-tuple [START_REF] Herrera | A 2-tuple fuzzy linguistic representation model for computing with words[END_REF] representation models. Given a linguistic term, the 2-tuple formalism provides for a pair (fuzzy set, symbolic translation) = (s i , α i ) with α i ∈ [-0.5, 0.5) as can be seen in Figure 2 where the obtained 2-tuple is (s 2 , -0.3). The computational model based on linguistic 2-tuples carries out processes of computing with words easily and without loss of information.

*CP-nets

*CP-nets designate a family of well-known graphical formalisms used for the expression of user preferences and naturally suited when preferences are easily approximable by lexicographic rules. We have chosen to ground our nonfunctional preference modeling on these formalisms since they exhibit specific benefits like ease of use for the preference modeler, relatively low computation cost, are strongly structured and could be easily extended to support additional properties needed in our context. Other formalisms exist in the literature such as GAI (Generalized Additive Independence) networks [START_REF] Gonzales | GAI-Networks: Optimization, Ranking and Collective Choice in Combinatorial Domains[END_REF]] but these approaches are not really suitable because of the elicitation effort they imply. Indeed they are useful when discriminating among a huge quantity of possibilities, which is not the case here.

A CP-net (conditional preference network) is a compact graphical representation of qualitative user preferences [START_REF] Boutilier | CP-nets: A tool for representing and reasoning with conditional Ceteris Paribus Preference Statements[END_REF]. It is relatively intuitive. Its main elements are: nodes representing the problem variables, arcs denoting preferences among these variables for given values, and conditional preference tables or CPTs. CPTs express the preferences over values taken by variables, defining in extension the binary relationship between them. CP-nets allow for the preference modeling of statements such as "I prefer the V 1 value for property X over V 2 if properties Y equals V Y and Z equals V Z ". In fact, this graphical representation allows one to express the dependency between connected CPTs. Hence preferences can be expressed conditionally to the values taken by their parent nodes in the graph, but regardless of the values taken by the other nodes (this is the ceteris paribus property, central to CP-nets, meaning "all other things being equals"). There is also a notion of relative preference between the preferences themselves: a CPT associated with a specific node has a higher priority than the CPTs of its offspring. This notion of relative preference is taken into account when globally comparing complete assignments (tuples of values binding all of the preference variables). Most of the inference computations and logic reasoning that can be made on a CP-net are practicable from an algorithmic complexity point of view when this CP-net obeys some restrictions. The major restrictions pertaining to this framework are the generalized use of acyclic graphs, the limited use of the indifference relationship modeling preferences (neither explicitly better nor worse) among variables, and therefore the systematic definition of total pre-orders in the CPTs for each distinct parent node [START_REF] Boutilier | CP-nets: A tool for representing and reasoning with conditional Ceteris Paribus Preference Statements[END_REF].

Utility CP-nets, or UCP-nets [START_REF] Boutilier | UCP-Networks: A directed graphical representation of conditional utilities[END_REF], differ from CP-nets by replacing the definition in extension of the binary relationship between node values in CPTs by numerical utility factors. Doing so, node values may retain their qualitative form: only preferences are quantified with utility values. This shift is motivated by the fact that the precision of a utility function (as opposed to a preference ordering) is often needed in decision making contexts where uncertainty is a factor. It is also motivated by the fact that a CP-net does not allow for the comparison or the ordering of all its alternatives. This limitation is also solved by the quantification of the preferences [START_REF] Boubekeur | Recherche d'information flexible basée CP-Nets[END_REF]. A utility factor is a real number associated to an assignment of a node X from the network, given a specific assignment of its parent nodes. Utility factors express preference degrees for the different assignments. In UCP-nets, preference modelers use CPT utility factors to deliver their preferences local to the variables of this CPT, but rely on the UCP-net semantics to compute the global utility of each complete assignment to enable their comparison.

Another extension of CP-nets, named Tradeoffs-enhanced CP-nets, or TCPnets [START_REF] Brafman | Introducing variable importance tradeoffs into CP-nets[END_REF], allows one to express preferences of the form: "A better assignment for X is more important than a better assignment for Y ". These are called relative importance statements. TCP-nets also generalize this class of preferences in order to accept conditional relative importance statements. With these, it becomes possible to express preferences of the form: "A better assignment for X is more important than a better assignment for Y given that Z = z". This formalism introduces a new kind of preference tables, the "Conditional Importance Tables" (or CIT), as well as two new types of arcs between nodes: i-arcs and ci-arcs. These arcs allow, respectively, for the modeling of basic and conditional relative importance statements. Basically, TCP-nets empower users to express the tradeoffs they are willing to concede between various preference criterions, given the current assignment to preference variables. The notion of conditional relative importance complements the one of conditional ceteris paribus independence in order to provide for a richer conceptual framework to model and reason about user preferences.

The idea of mixing CP-nets and non-functional properties has already been addressed by Schröpfer et al. [START_REF] Schröpfer | Introducing preferences over NFPs into service selection in SOA[END_REF]: the authors define preferences through CP-nets to select the best service in an SOA. But they don't consider qualitative preferences nor continuous domains of variables. They only tack on the CP-nets formalism to their preference modeling.

3 Fuzzy Linguistic Approach and CP-nets *CP-nets exhibit two important limitations to express preferences in a QoS setting. Many QoS dimensions are defined on continuous domains, but *CP-nets only deal with finite domain variables. We propose to discretize continuous domains using fuzzy linguistic terms [Zadeh, 1975] instead of crisp sets. In a context where users have to express preferences among values of continous domains, e.g. latencies, the qualitative nature of fuzzy sets with smooth transitions proved to better capture users intention. Hence, this shall allow for a better service selection when two services have properties like "latency" that have more or less similar values, by avoiding to artificially put large differences in preferences between otherwise nearby domain values. Another problem is that precise utility values are hard to get from non-specialist users. Indeed, giving numbers to express a perception (or a preference in our case) is not always feasible. Facing this, current *CP-net models provide for only two alternatives. On the one hand, the original CP-net model expresses preferences through a simpler and more intuitive order relation (without precise utility values) but suffers from lower performance when comparing two assignments. On the other hand, UCPnets allow for such a comparison to be performed quite efficiently but with much harder-to-get precise numerical utility values.

Another proposition in this paper is to express utility values qualitatively, i.e. using words translated into fuzzy sets. As in UCP-nets with numerical utility values, comparisons between assignments use the global utility of these assignments, but it will be computed using fuzzy logic and aggregation tools.

Linguistic CP-nets (LCP-nets)

In [START_REF] Châtel | A linguistic approach for non-functional preferences in a semantic SOA environment[END_REF] we have proposed a new variant of CP-nets, called LCPnets (Linguistic Conditional Preference networks), to get the advantage of the fuzzy linguistic approach into a marriage of UCP-nets and TCP-nets. Compared to the previous *CP-nets, this new formalism allows for the preference modeling of more qualitative statements such as "I prefer the more or less V 1 value for property X over exactly V 2 if properties Y equals approximately V Y and Z equals a bit more than V Z ". Moreover, these statements that resemble elaborated fuzzy rules are interpreted in a context where the overall preference on X shall take into account every such preference statement that applies, to some degree, to the value of Y .

The following constraints and properties from the SSOA context had to be taken into account:

preferences must be easy to define since business process programmers can't rely on preference-modeling experts, nor do they have much resources to allocate for their elicitation. It implies that some imprecision must be tolerated in preference models,

typical problems to be dealt with use few variables (commonly in the order of 10 variables),

computation time for decision-making based on preferences can be seen as relatively small compared to the subsequent service invocation over the network.

It leads to the following sought-after properties of the preference formalism: it is graphical to ease their definition without overly compromising computation, since LCP-net models are much easier to establish than writing several sets of fuzzy rules that can be interdependent, and they are qualitative to deal with user or QoS sensor imprecision.

Due to the latter, linguistic variables [Zadeh, 1975] have been incorporated into LCP-nets, the semantic of each linguistic term being given by a fuzzy set. Thus, preference modelers can easily manipulate pre-existing linguistic terms during elicitation. Also, as in other graphical models, LCP-nets have nodes corresponding to problem variables which continuous domains are discretized as linguistic term sets. In the SSOA context, these variables refer to non-functional properties of services.

To sum up, LCP-nets allow users to express tradeoffs among variables using i-arcs or ci-arcs from TCP-nets and have CPTs similar to the ones of UCP-nets, but express utilities with linguistic terms rather than numerical values. With LCP-nets, it is possible to: -elicit preferred assignments for a specific QoS domain (or interdependent ones), using CPTs similar to the ones of UCPnets [START_REF] Boutilier | UCP-Networks: A directed graphical representation of conditional utilities[END_REF],

-reveal relative importance of non-functional properties, using arcs from CP-nets,

-indicate tradeoffs between non-functional properties, using i-arcs from TCP-nets [START_REF] Brafman | Introducing variable importance tradeoffs into CP-nets[END_REF].

The aforementioned properties are illustrated in Figure 3, where user preference on the selection of an Imaging Web service (e.g. a security camera) is detailed. The overall goal of the user is to get images as fast as possible. This goal is translated into preferences according to three of its QoS properties: security (S), bandwidth (B) and image resolution (R). The user always prefers bandwidth over security, and if the bandwidth is low, she prefers low-resolution images to get them as fast as possible. More details on this preference model will be given in Section 4.

While our last paper [START_REF] Châtel | A linguistic approach for non-functional preferences in a semantic SOA environment[END_REF] stressed only the formalism (and the framework) of LCP-nets, we focus in this study on their underpinnings, i.e. the inference process behind the formalism.

LCP-nets framework: from elicited preferences to service selection

In the context of SSOA, the following conceptual steps are executed sequentially in order to implement the matchmaking process: a dynamic selection of Web services based on non-functional consumer preferences and up-to-date QoS values of monitored services. In particular, the preference representation and evaluation steps have been implemented in Java (using the jfuzzylogic 3 library for the fuzzy part) as an LCP-net support framework. Indeed, one of the key aspects of LCP-nets lies in the representation and evaluation of its models. While the formalism itself has been inspired by *CP-nets, its tooling introduces another approach to the *CP-nets family, more specifically a mapping from a graphical model to a representation through multiple Fuzzy Inference Systems (or FIS) at compile-time. Evaluation of an LCP-net model is then based on its associated FIS, using the fuzzy-logic theoretical setting. The main idea behind this representation system translation is to gain the same level of flexibility at evaluation time than during preference elicitation: for instance, inputs of an LCP-net model can be crisp or fuzzy values over the defined domains, despite the strict use of linguistic terms in the Conditional Preference Tables.

Preference elicitation

As previously indicated, preference retrieval is conducted before runtime. But LCP-net preferences tell how to select services given their run-time QoS, allowing users to easily tailor Web process executions to each deployment scenario.

For example, in order to implement a pre-existing well-know process in the fire-fighting domain, dynamic service selection can be adjusted according to two of the possible deployment contexts: usual civil fire or crisis-management (where short intervention delays could be preferred over equipment capacities if the scene is distant).

Preference model translation

Backed by fuzzy logic, it is possible to translate preference models to an efficient decision-making representation used at runtime. In the process, each utility table in a preference model will be mapped to a single fuzzy rule set, as in fuzzy control [START_REF] Driankov | An introduction to fuzzy control[END_REF], to become a local FIS.

The inputs of these node-bound FIS can be crisp or fuzzily measured values obtained from monitored Web services.

Preference model evaluation

In the following, the preference model evaluation process is broken down into four key steps for selection of the best-suited service at runtime. First, during QoS value injection, multiple QoS values are retrieved from a monitoring component of the SSOA framework or directly from the Web services themselves. These values can be of two kinds: crisp QoS values seen as "singleton" fuzzy sets of the considered QoS domain, or fuzzy QoS values that may need to be "adjusted" by a domain normalization on the [0,1] scale.

After QoS values have been retrieved, local utility value inference is launched. This inference of local node-bound utility values is made using Zadeh's Generalized Modus Ponens.

Currently, the fuzzy inference mechanisms are set once and for all in the implementation of LCP-nets, but some control could be given to the user over these, with the caveat that a good knowledge of fuzzy inference is needed to perform an enlightened choice. Another variant would call for an end-to-end linguistic treatment of this fuzzy inference; an approach that could better match user's intentions in expressing her preferences. Indeed 2-tuples that have been introduced in section 2.2 deal with linguistic statements without loss of information. Considering the preferences and the values for properties as 2-tuples, an ad hoc inference process [START_REF] Alcalá | Genetic learning of accurate and compact fuzzy rule based systems based on the 2-tuples linguistic representation[END_REF] should then be used instead of Zadeh's Generalized Modus Ponens.

Finally, during global utility value computation, aggregation of previously inferred local utilities is made. But, during aggregation, we have to take into account the fact that arcs in preference models give the relative importance to their nodes and attached local utilities. For instance in the previously mentioned preference model (see Figure 3), bandwidth is more important than both security and resolution, these last two being of equal importance.

In UCP-nets, the numerical nature of utility values allows the user to express this relative importance by tuning the order of magnitude of utility values among the different tables. With linguistic terms, the user no longer has this possibility. In order to get this implicit relative importance back in LCP-nets when computing the global utility value, weights are associated to each node in the preference graph by a weight computation process correlated to their depth in the graph. The global utility of an assignment is then computed by aggregating local utilities according to a weighted averaging operator ∆, using the previously computed weights. The weights are values in [0,1] and their distribution is given by a decreasing depth in the graph: weight function defined over a specific interval (the lower the depth is, the higher the weight will be in the preference model), its outputs being subsequently normalized in order for them to sum to 1. Note that the weight distribution function might be a BUM (basic unit-interval monotonic) function [Yager, 2007]. A deeper study of this choice will be discussed in the future.

Such a weighted mean of local utilities works hand-in-hand with crisp local utilities. While local node utilities are computed as crisp values, the aggregated global utility, also crisp at first, can then be converted into a 2-tuple instance in order to offer a linguistic assessment while still preserving the precision of the original crisp value. If we switch to an end-to-end linguistic treatment, local utility values could be computed as linguistic terms, such as 2-tuples, using an ad hoc inference process, and then several linguistic aggregation operators [Xu, 2008], based on Yager's OWA operators [Yager, 1988], may be used to compute a linguistic global utility value. The choice of an appropriate aggregation operator proved to depend upon the application and shall be the point of a dedicated study. This choice could then be given to the user.

Service comparison and selection

The last step consists in comparing the different outcomes according to their global utility value to select one as the result of the overall decision process. Service comparison in order to make a binding choice between a consumer and producer are meant to be made automatically. In a fully automatic case using our LCP-net evaluation framework, crisp global utility values are used for comparison. But in other LCP-net application contexts, such a selection may rely on human intervention. In such a scenario, a fully linguistic approach, backed up by fuzzy 2-tuples, would take its full meaning, by providing the decision-maker with the qualitative assessment of linguistic terms but without loss of precision.

Case study

The following case study goes through the previously introduced steps focusing on a specific part of the imaging service preference model presented earlier in Figure 3.

Preference elicitation

In this model, security can be either none or full, given utilities very low and very high respectively. The preference of bandwidth over security is accounted for by an i-arc from B to S (an arc with a middle black triangle). The bandwidth is discretized using three linguistic variables B L (low), B M (medium) and B H (high). Preferences among these values are given by the CPT beside B, expressing a very low preference for a low bandwidth, a medium one for the medium bandwidth and a very high one for a high bandwidth.

Image resolution is also discretized using two linguistic terms: R L (low) and R H (high). The preferences among these values are conditional to the bandwidth. If the bandwidth is low (B L ), a low resolution (R L ) has higher preference (very high), but if the bandwidth is high (B H ), a high resolution (R H ) is preferred (very high). When the bandwidth is medium (B M ), a low resolution image is preferred, but with less intensity (high).

The semantic of the linguistic terms used in the preference tables over bandwidth, resolution and utility is given beforehand by the fuzzy partitioning shown in Figure 4. After elicitation, the preference model previously shown in Figure 3 is fully obtained. In this particular model, bandwidth is always preferred over security, and if the bandwidth is low, low-resolution images are preferred because we need images as fast as possible.

Preference model translation

This section focuses uniquely on node R and its associated CPT, since the same process can be applied as-is to the other nodes. Given the CPT for node R, linked to node B in the preference model, and the previously mentioned fuzzy partitioning of bandwidth and resolution, we obtain after translation the following FIS specific to this node (see Figure 5) and defined here using the FCL language4 used internally by our LCP-net evaluation framework.

As what has been previously said, input and output variables for this FIS (B, R and Utility) are declared as real (crisp value only). If a fuzzy value needs to be input, it first needs to be defuzzified, also output could afterward be translated to a linguistic representation.

Preference model evaluation

Still focusing on node R, the value of node B needs to be taken into account during evaluation. This is due to the fact that there is an arc between B and R in the preference model, and that the CPT attached to node R uses values taken by B as input.

During QoS value injection a bandwidth value of 30 kb/s is measured, then normalized over [0,1] to B ′ = 0.30, and finally fuzzified as a singleton, as seen in Figure 6. A fuzzy value for resolution is obtained and needs to be "adjusted" by a domain normalization on the [0,1] scale, as seen in Figure 7.

In any case, since B and R are declared in Figure 5 as real input variables, a fuzzy input will first need to be defuzzified before FIS evaluation.

Focusing on the local utility value inference for node B, only the previously normalized singleton bandwidth value is needed to compute its utility since it does not depend on any other node of the preference model. A visual output of the inference process for node B is given in Figure 8 using classical operators like Mamdani's fuzzy implication and Zadeh's T-Norm.

This figure shows that the fuzzy output of the inference process is defuzzified using a Center Of Gravity (COG) approach in order to obtain a local utility value for node B of 0.35 on the [0,1] utility domain. The same process will also be applied to node R and S in order to compute their respective local utilities.

In the node weight computation step, the weight distribution function used in this case study is given by the following formula defined over [1,100]: Given this function (see its overall shape in Figure 9), we obtain the following (depth, weight ) pairs after normalization: (1, 0.529), (2, 0.235). These pairs are then associated to each node in the preference model as seen in Figure 10.

Finally, the process goes on with the global utility value computation for this preference model, given the following QoS value snapshot (B ′ , S full , R ′ ), where B ′ =0.30, and the previously infered local utility values for each node: localUtility(B ′ ) = 0.35 (as was demonstrated earlier), localUtility(S full ) = 1 and localUtility(B ′ ,R ′ ) = 0.20.

The ∆ operator is then applied according to the previously computed weights:

∆(B ′ , S full , R ′ ) = 0.529 × 0.35 + 0.235 × 1 + 0.235 × 0.20 ≈ 0.47
The global utility corresponding to the non-functional service offering (B ′ , S full , R ′ ) is approximately 0.47 on a scale from 0 to 1.

Case study summary

Potential improvements

Based on the process summarized in Figure 11, some of the improvements expected from an end-to-end linguistic treatment discussed in the previous sections could be implemented as follows:

the domain(s) fuzzy partitioning including the utility domain of Step 1 would provide for linguistic term sets of 2-tuples, i.e. pairs (s i , α) with α = 0. For example, the bandwidth would be represented as {(low,0); (medium,0); (high,0)}, -in Step 2, the linguistic preference tables would also contain 2-tuples (e.g. (very low,0) or (very low,-0.2)) instead of simple linguistic terms (e.g. very low ). Indeed the user expresses her preferences graphically, that is why a lateral displacement of the original linguistic term may appear. Thus the rules could be represented with 2-tuples: e.g. "If the resolution is (low,0) and the bandwidth is (high,0) then the utility is (very low,-0.2)",

-
Step 3a would compile preferences through the fuzzy inference system (FIS) 2-tuples, as proposed and discussed in [START_REF] Alcalá | Genetic learning of accurate and compact fuzzy rule based systems based on the 2-tuples linguistic representation[END_REF], and Step 6 would aggregate weighted 2-tuples [START_REF] Herrera | A 2-tuple fuzzy linguistic representation model for computing with words[END_REF] in order to provide for a global utility expressed by means of a 2-tuple.

-
Note that using fuzzy 2-tuples shall also be very convenient in the case where the user afterwards would like to modify the domain variable partitioning: it shall be relevant to offer her the possibility to change the CPTs automatically (adding or deleting a column/line), i.e. the system would compute new utilities that could be expressed as (very high,-0.1)) for instance even if the user had first defined utilities only with (s i , 0) 2-tuples. Actually, as soon as we want to reconfigure the LCP-net automatically, we need to change the domain granularity and the 2tuples appear a tool of choice for that, allowing the system to keep a relationship to the original user term set.

Conclusions

In this paper, we have adressed the problem of coping with the dynamism of Semantic Service-Oriented Architectures by proposing a new form of late-binding of services to calls in business processes based on the current values of candidate services QoS properties. This form of late-binding improves the capability of business processes to sustain their own QoS guarantees and implements a form of fault-tolerance by keeping a set of candidate services for each call as late as the execution of invocations at run-time.

Figure 1 :

 1 Figure 1: SemEUsE service selection architecture.

Figure 3 :

 3 Figure 3: The imaging Web service QoS preferences example using LCP-nets.

Figure 4 :

 4 Figure 4: Fuzzy partitionings over bandwidth, resolution and utility.

Figure 5 :

 5 Figure 5: FIS for node R CPT.

Figure 6 :Figure 7 :

 67 Figure 6: Singleton corresponding to measured bandwidth value.

Figure 11 Figure 8 :Figure 9 :

 1189 Figure11summarizes the steps undertaken by users for preference modeling before runtime and by our framework for setting-up service comparison and

Figure 10 :

 10 Figure 10: From node depths to node weights.

  Step 4 would inject current QoS values converted into 2-tuples as well, -meanwhile Step 3b wouldn't change, -Step 5 would yield a local utility expressed by means of a 2-tuple,

By *CP-nets we mean any kind of Conditional Preference Networks (the asterisk substitutes as the wildcard), i.e. CP-nets, TCP-nets, UCP-nets, etc.

http://www.semeuse.org

http://jfuzzylogic.sourceforge.net

FCL stands for "Fuzzy Control Language", which is a standard for Fuzzy Control Programming published by the International Electrotechnical Commission[IEC, 2001].

Acknowledgements

The research was partly funded by the French National Research Agency (ANR) via the SemEUsE project (ANR-07-TLOG-018). We would like to thank Thales Communications France for their constant support.

To enable the selection of services in such a multi-criteria decision making process, preferences among their non-functional QoS properties must be expressed to get a total order among the candidates. To this end, the main contribution of this paper is to propose a new variant of CP-nets, called Linguistic CP-nets (LCP-nets), combining features of UCP-nets and TCP-nets with the advantages of a fuzzy linguistic approach to discretize continuous domain variables, and to express the utilities of assignments to variables in conditional preference tables. LCP-nets prove to be well suited for semantic SOA, as they allow users to effectively discretize continuous domain QoS with appropriate linguistic terms, and to express utility of assignments in a qualitative manner rather than an often contrived numerical one.

We have assumed for the time being that utilities are always expressed using the same linguistic term set, but this restriction could easily be removed in a fully linguistic approach based on 2-tuples by using a multigranular approach when computing the global utility function [START_REF] Herrera | Fusion of Multigranular Linguistic Information based on the 2-tuple Fuzzy Linguistic Representation Model[END_REF]. Similarly, the assumption on the linguistic sets as being centered on 0.5 with terms being equidistant could also be removed using approaches to cope with unbalanced term sets [START_REF] Herrera | A Hierarchical Ordinal Model for Managing Unbalanced Linguistic Term Sets Based on the Linguistic 2-Tuple Model[END_REF].

It shall be further stressed that although originally established for the specific SSOA context as target, the LCP-net formalism and its inference and computational framework are domain agnostic and could be easily applied to other similarly constrained contexts.

As future works, the next step is to implement the improvements discussed in section 4.5 but also to formalize the definition of LCP-nets as a variant of CPnets. In particular, we shall prove that, in borderline cases -where there is no imprecision -the service ranking with fully linguistic LCP-nets is exactly the same than the ranking with *CP-nets but making preferences easier to express.


Pierre Châtel
email: pierre.chatel@thalesgroup.com

Jacques Malenfant
email: jacques.malenfant@lip6.fr

Isis Truck
email: truck@ai.univ-paris8.fr

QoS-based Late-Binding of Service Invocations in Adaptive Business Processes

Computing has reached the time of distributed applications everywhere. Service-oriented architectures are more and more used to organize such complex and highly dynamic applications into business processes calling services discovered in registries at load-time. In this context, Quality of Service (QoS) and agility in business processes become key issues. Instead of binding business processes to services at load-time, this paper proposes to monitor sets of candidate services for their current QoS and to choose among them at call-time. This new form of late-binding paves the way to more agile and robust applications called adaptive business processes. Besides the conceptual background and implementation of this late-binding in an industrial-strength web service platform, this paper presents the LCP-net formalism introduced to provide programmers with a mean to express qualitatively their preferences among the different QoS properties of services, hence tackling the multicriteria decision making arising from the run-time choice among candidate services given several unrelated QoS properties.

"Broadly speaking, the history of software development is the history of ever later binding times. . .

I. INTRODUCTION

Service-oriented architectures (SOA) deal with the growing need for open distributed applications capable of evolving and adapting continuously over their execution. To deal with the high dynamicity of the Web and the large variations in the QoS, the key proposal of this paper is to delay the choice of services to the run-time and to use up-to-date QoS information to perform this selection. To this end, usual service offers are enhanced with QoS commitments, but instead of dealing with this information statically, a loose coupling is implemented at run-time by the late-binding of abstract service requests (of Web processes) to concrete service offers. Central to this approach is the assumption that QoS commitments from the service providers express the QoS properties that users are entitled to monitor at run-time to judge the current performance of the service.

This paper focuses on the various steps involved in the implementation of this novel calling process. After filtering candidate services for each service call from registries upon Work partly funded by the French ANR project SemEUsE (07-TLOG-018).

their QoS commitments, a connection is established with their monitoring interfaces. During the whole execution of the business process, up-to-date QoS values are received asynchronously through a monitoring middleware. When the business process calls a service, it gathers all of the current QoS levels from all candidate services for that call and selects the one to be called upon these.

The dynamic selection of Web services then leverages user preferences to maximize the expected QoS from each call. In this multi-criteria decision making context, to make the best possible binding decisions between consumers and producers, preferences must be established among the various nonfunctional properties of required services. Given the subjective nature of these preferences, they are elicited by business process programmers before running them. This paper recalls the LCP-net formalism [START_REF] Châtel | A linguistic approach for nonfunctional preferences in a semantic SOA environment[END_REF] to elicit and express user preferences in a business-oriented qualitative way.

The rest of the paper is organized as follows. Section II presents the conceptual background and related work. Section III describes the different concepts and programming abstractions adopted to implement the new kind of late-binding of service calls in business process languages. Section IV presents in more detail the LCP-net formalism, the cornerstone of the approach since it enables programmers to express their preferences in the service selection process, and its integration into the preceding programming abstractions. Section V describes the current implementation. A conclusion ends the paper, including a discussion of perspectives to this work.

II. BACKGROUND AND RELATED WORK

The section briefly details the related work concerning QoSawareness in SOA as well as preference modeling formalisms.

A. SOA and non-functional properties

SOA and Web services have recently gained broad industry acceptance. However, current standards do not meet the dynamicity of the Web, where services appear, disappear and exhibit large variations in their QoS even over a business process execution. To tackle these, QoS-awareness must be built into the run-time SOA platform to dynamically select the best service available to fulfill each request.

Indeed, besides filtering services using non-functional constraints, most works on QoS-awareness have been done to compose web services so to fulfill QoS commitments of the business process [START_REF] Zeng | QoS-aware middleware for web services composition[END_REF], [START_REF] Canfora | Service composition (re) binding driven by application-specific qos[END_REF], [START_REF] Chafle | Adaptation in web service composition and execution[END_REF], [START_REF] Colombo | SCENE: A Service Composition Execution Environment Supporting Dynamic Changes Disciplined Through Rules[END_REF], [START_REF] Chiu | A Dynamic Approach toward QoS-Aware Service Workflow Composition[END_REF]. However, this form of composition implies a selection of a service for each call, which is currently done at design-or load-time. In this paper, dynamically measured non-functional levels are used to further seek for the best offer just prior invoking the service; completing a static filtering of candidate services with the runtime selection of the one to be called among these.

B. Binding and binding times

First explored in the context of programming languages, binding times and late-binding relates to the conceptual framework which organizes the how and, more importantly, the when decisions are made to bind identifiers of entities (procedures, libraries, etc.) to their physical realizations to be used at run-time. Besides the well-known and explored late-binding of method calls in OOP, late-binding of remote calls in distributed programming is the ability to choose the remote application just prior to the call itself. Doing so provides not only for more agility, but also for more robustness in the context of failures. In this paper, we consider a new form of late-binding, where decisions are made upon the current QoS of providers. In SOA, this approach deals with the more competitive nature of the service paradigms where numerous equivalent services are competing in a highly dynamic environment.

In the context of SOA, work has been done to add dynamicity in service selection. Mosincat and Binder [START_REF] Mosincat | Transparent Runtime Adaptability for BPEL Processes[END_REF] implement a binding manager that runs in background to rebind failed services according to blackbox service selectors specifically developed to work with the binding manager. Scene [START_REF] Colombo | SCENE: A Service Composition Execution Environment Supporting Dynamic Changes Disciplined Through Rules[END_REF] proposes similar ideas, but relies on user-defined rules to trigger rebindings. The rules include user preferences but, as other works [START_REF] Siljee | DySOA: Making Service Systems Self-adaptive[END_REF], [START_REF] Canfora | Service composition (re) binding driven by application-specific qos[END_REF], do not address conflicting preferences among QoS properties. The originality of this paper proposal lies in the extension of the BPEL language allowing programmers to provide for dynamicity at the business process language level, instead of lower level libraries/middleware, and in the LCP-net formalism providing programmers with an intuitive tool to express their preferences among services through their different QoS properties monitored at run-time.

C. Fuzzy Linguistic Approach and *CP-nets

Indeed, a major issue when dealing with QoS is the large number of different dimensions (e.g. latency, precision, etc.). Because offers are rarely the best for every QoS dimension, preferences are needed to rank them given their relative strength on the different dimensions. Preference elicitation and expression have received attention in past years; several formalisms have been proposed. For SOA, a good formalism must obey several requirements, among which usability by nonspecialists business process programmers, is of primary importance. To this end, we have proposed a new formalism [START_REF] Châtel | A linguistic approach for nonfunctional preferences in a semantic SOA environment[END_REF] based on the combination of CP-nets and the fuzzy linguistic approach [START_REF] Zadeh | The Concept of a Linguistic Variable and Its Applications to Approximate Reasoning[END_REF] to qualitatively specify user preferences over the different non-functional properties of offers.

Introduced by Zadeh [START_REF] Zadeh | The Concept of a Linguistic Variable and Its Applications to Approximate Reasoning[END_REF], the linguistic variable concept represents the qualitative aspect of a value, e.g. low, tall, etc. Zadeh associates fuzzy sets to the variables, i.e. a temperature value can be expressed by a fuzzy set whose membership function is a mapping from [10 • C,30 • C] to [0,1]. Several other representation models have been proposed, such as the semantic [START_REF] Degani | The Problem of Linguistic Approximation in Clinical Decision Making[END_REF], the symbolic [START_REF] Truck | A Tool for Aggregation with Words[END_REF] or the 2-tuple [START_REF] Herrera | A 2-tuple fuzzy linguistic representation model for computing with words[END_REF] ones.

Among the different models used to express the user preferences, we have chosen what we call the *CP-nets ("wildcard" Conditional Preference Networks) family. *CP-nets are graphical formalisms with several benefits such as ease of use for the preference modeler, relatively low computation cost, and easily extendable to support additional properties. In a CPnet, the main elements are the nodes representing the problem variables, the arcs denoting preferences among these variables for given values, and the conditional preference tables (CPTs) attached to nodes [START_REF] Boutilier | CP-nets: A tool for representing and reasoning with conditional Ceteris Paribus Preference Statements[END_REF]. CPTs indicate the preferences depending on the other variable values (the linked nodes). CPnets allow for the preference modeling of statements such as "I prefer the V 1 value for property X over V 2 if properties Y = V Y and Z = V Z ". They assume the ceteris paribus (all else being equal) property. The highest node in the graph has the highest preference. UCP-nets (Utility CP-nets) [START_REF] Boutilier | UCP-Networks: A directed graphical representation of conditional utilities[END_REF] replace the binary relationships between node values by utility factors. Thus, in this formalism, CPTs contain precise numerical values instead of binary order relations. As for the TCPnets (Tradeoffs-enhanced CP-nets) [START_REF] Brafman | Introducing variable importance tradeoffs into CP-nets[END_REF], they implement the conditional relative preference: "A better assignment for X is more important than a better assignment for Y given that Z = V z ". New kinds of tables and arcs are introduced thereby managing these tradeoffs.

The modeling of non-functional properties by *CP-nets has been proposed in [START_REF] Schröpfer | Introducing preferences over NFPs into service selection in SOA[END_REF] and [START_REF] Santhanam | TCP -Compose* -A TCP-Net Based Algorithm for Efficient Composition of Web Services Using Qualitative Preferences[END_REF] but in the context of a static composition of services and without considering qualitative preferences nor continuous value domains.

III. LATE-BINDING OF SERVICE CALLS

While as late as possible service-process binding decisions are sought, care must be taken not to overly compromise performance. In a current QoS oriented decision, service discovery and QoS values gathering could be done as late as the service call-time, but this would result in very high costs (delays). A traditional approach to mitigate the effects of late-binding is to do preprocessing in order to avoid inconvenient delays at call-time. Preprocessing can be done as early as process design-time, or later on, at process loadtime. In both cases, this is static since it takes place before process execution; be fully aware though that there is no sharp separation between static and dynamic, but rather a smooth transition between both ends of the spectrum, as shown in Figure 1. This whole spectrum can be used to tune the overall performance of the late-binding by keeping static the most time-consuming operations (filtering and data adaptation generation) while making dynamic the necessary ones (QoSbased selection and binding of the service to be called).

While this new form of late-binding paves the way to more agile and more robust applications, we need to tackle issues raised by its implementation. In order to do so, we focus on the following sequential sub-steps (summarized in figure 2).

Current

A. Service filtering

Sets of candidate services are obtained by filtering them from the registry upon their functional and non-functional properties. Rather than waiting until call-time, this can be done for each call site either at process design-or load-time. Considering computing and network-related bottlenecks, such as the unavoidable delays to call the registry or the execution times of the service matchmaking algorithms, static filtering can minimize the impact of service discovery on the latebinding process as a whole.

Data-adaptation is also impacted. Indeed, Moreau et al. [START_REF] Moreau | Data Flow Repair in Web Service Orchestration at Runtime[END_REF] have shown that design-time filtering provides for enough time to compute elaborate data-adaptation schemes between services requirements and selected offers sets. On the other hand, the load-time approach forces to use simpler schemes, but is particularly well suited when numerous functionally equivalent services are competing in a highly dynamic environment. In this paper, as a compromise, the setting up of the sets is postponed to process load-time where the pool of available services is more up-to-date. The counterpart is that data-adaptation adopts a more basic approach [START_REF] Châtel | Toward a Semantic Web service discovery and dynamic orchestration based on the formal specification of functional domain knowledge[END_REF] to meet the performance constraints. Indeed, unless requiring a very long execution time, the business process should not wait much for data-adaptation schemes to be computed.

Returning to the service filtering process itself, strict nonfunctional requirements are injected to elect the final set of candidate services to monitor, rejecting at the same time all the non-conforming services upon the QoS offers they previously registered. Another result of this filtering is to consider that the information necessary for QoS monitoring setup is provided as an output of the selection process. More precisely, the current implementation uses negotiated SLA between processes and services to carry this information to the business process.

B. Current QoS monitoring

Central to our approach is the assumption that nonfunctional commitments from service offers express the QoS properties that users are entitled to monitor at run-time, through a specific service monitoring interface, in order to judge the current performance of the service. After service filtering, monitoring probes from these interfaces are identified based on the information put in the SLA negotiated between the business process and the candidate services. The goal is to subscribe to the monitoring interfaces of every candidate service for each call in the business process. Then, during the whole execution, up-to-date QoS values will be received, allowing for fast on-the-fly decision making.

As said earlier, QoS values could be tardily retrieved at service call-time, but then the service call would be delayed by the latency induced by the network for this remote query. Indeed, a push-mode is preferable for QoS value transmission. With carefully chosen publish frequencies, the business process can have immediately accessible "fresh" QoS values for all candidate services to enable a fast decision at service call-time. Optimizing this monitoring and providing for the required quality of information (precision, freshness, coherency, ...) is dealt with by a dedicated framework [START_REF] Duc | Non-functional Data Collection for Adaptive Business Process and Decision Making[END_REF] C. Non-functional service selection and invocation At service call-time, five steps are required: QoS levels gathering for candidate services, service selection, data adaptation for the parameters, service invocation, and finally data adaptation of the result. QoS value gathering is done by calling the montoring middleware, which provides them without delay, thanks to the push-mode and asynchronous collection of these data discussed above. Data adaptation amounts to applying preprocessed transformations computed at service filtering time, while the service call itself use standard business process interpreters mechanisms.

Service selection requires to compare candidates services upon several different QoS dimensions which comparisons can contradict each other. As a multi-criteria decision problem, it requires preferences, tailored before process execution to its context, and applied to currently measured QoS values. These non-functional preferences, fundamental to our approach and which formalism is exposed in section IV, strive to maximize the expected QoS from each call by enabling the consumer to better specify its needs in an machine-interpretable way. They are also very useful to deal with contradictory requirements since they are established between the various QoS properties: a total order over services can now be obtained at run-time, and the final binding decisions made.

IV. LCP-NETS AND USER PREFERENCES

Selection upon non-functional properties is a multicriteria decision making problem which is better dealt with in a qualitative framework, as the LCP-nets presented in this section.

A. Preference elicitation with LCP-nets

LCP-nets [START_REF] Châtel | A linguistic approach for nonfunctional preferences in a semantic SOA environment[END_REF] uses qualitative assessments to allow for the preference modeling of statements such as "I prefer the more or less V 1 value for X over exactly V 2 if Y is approximately V Y and Z is a bit more than V Z ". LCP-nets allow users to express preferences, relative importance and tradeoffs among non functional properties quite easily with a graphical tool using linguistic terms.

Figure 3 shows an LCP-net for an imaging service (e.g. a security camera) where QoS properties are: security (S), bandwidth (B) and image resolution (R). As the overall goal is to get images as fast as possible, the user always prefers bandwidth over security, and if the bandwidth is low, prefers low-resolution images to get them as fast as possible. As this example shows, the elicitation of the preferred assignments for a specific QoS domain (or interdependent ones) is performed using CPTs and assigning weights to the nodes, depending on their position in the graph. Specifically, for each node, a CPT expresses the qualitative utility of QoS values for this dimension (e.g. very high, low, etc.), given the QoS values of graph-related dimensions which influence this node utilities.

The semantic of the linguistic terms used to constrict QoS values in a particular CPT is given by a prior fuzzy partitioning of the pertaining domains normalized over [0,1], as is also the one of the linguistic terms used to express utilities in the tables. Figure 4 shows the discretization for the bandwidth domain.

B. Service selection led by LCP-nets and current QoS levels

With preferences elicited and expressed into an LCP-net, several steps are required to evaluate the preference network at run-time. Considering a service with current QoS values over S, B and R, the focus is on the computation of its global utility by injecting these values into the LCP-net. With multiple services involved, the ultimate goal is indeed to select the service offering the best utility.

As a preprocessing step of LCP-net evaluation, CPTs are translated and mapped to fuzzy rules (e.g. in Figure 3: "if R = R L and B = B L then preference is very high"), then aggregated into corresponding Fuzzy Inference Systems (FIS) for each table. At service call-time, QoS values are injected in the evaluation process after normalization and fuzzification (e.g. a 0.3 singleton fuzzy subset for a crisp 30Kb/s bandwidth value, as shown in figure 4). For each preference table, the corresponding FIS allows for the computation of the local node utility. Utilities are obtained as crisp or fuzzy values.

Nodes have weights capturing their importance (position) in the graph, which are distributed (summing to 1) according to a decreasing function (see [START_REF] Châtel | A linguistic approach for nonfunctional preferences in a semantic SOA environment[END_REF] for details). In the example, they are: (B, 0.529), (S, 0.235) and (R, 0.235). The global utility value is then the weighted aggregation of the local utility values. After applying this process to every considered service, the one offering the largest global utility is selected and passed-on to the late-binding framework for invocation.

C. A new feature: incremental definition of LCP-nets

Pragmatically, programmers often have similar preferences applying to several service call sites, with eventually slight changes to cope with the specifics of each call. Instead of repeating most of the preference network each time, a nice feature is to be able to factor common preferences into a shared base LCP-net, and to locally add the specific preferences. To this end, we introduce LCP-net fragments, constructs, built over an existing LCP-net, describing unambiguously additions, deletions (with anti-fragments) or modifications (with modifier fragments) to any base LCP-net element. The general form of a fragment follows the same pattern and graphical nature of a classic LCP-net construct, each base LCP-net construct (nodes, arcs and tables) having a corresponding derived fragment type.

Possible integrations of this new feature of the LCP-net formalism can be envisioned for BPEL, where LCP-nets and fragments could be attached to specific activities and their lexical scope exploited to link fragments to the base LCP-net. It should therefore optimize preference usage by reducing repetitions, the direct consequence being savings on development costs by fostering reusability across the board, as highlighted by the SOA philosophy.

To illustrate the incremental definition process, we compose the previous LCP-net ImagingPref with a fragment ImagingPref frag to obtain a new LCP-net NewImagingPref . This fragment removes the preference on resolution (R) and replaces it by ones on a newly introduced zoom (Z) QoS property. It also changes the type of arc between B and Z, and the utility values from the bandwidth (B) CPT table. Finally, the NewImagingPref preference resulting from its application is given in its graphical form in Figure 6. The parallel between SemEUsE architecture and abstract concepts such as service filtering, selection and invocation is illustrated in Figure 7 through a simple abstract example. Multiple services from a registry, ranging from S1 to S5, are funneled through each implemented logical step until one service (S1) selected upon its current QoS values and statically defined LCP-net preferences, is invoked. In SemEUsE, functional and non-functional service filtering is being taking care of by the service registry, while non-functional service selection and invocation is implemented by the late-Binding component alongside dynamic orchestration.

A. LCP-net preferences definition

The LCP-net model, including all its core constructs, has been defined using the Eclipse Modeling Framework (EMF), an Eclipse-based modeling and code generation facility for building tools based on a structured data model. Our ular model is an ecore file serialized under the XMI OMG standard, which should ensure its sustainability and provides the foundation for interoperability with other modeling tools.

This model specification produces a set of corresponding Java classes and a set of adapter classes that enable viewing and command-based editing of the model. As such, LCP-net can be constructed programmatically by an external software component. However, in our context, LCP-nets are manually defined before run-time. As a result, building over this set of Java classes, a basic graphical editor has been implemented to ease both preference elicitation and definition. Its GUI is reproduced in a compact way by figure 8: the monitoring_preferences.lcpnet file is editable as a tree, each constitutive element being selectable to edit its properties (e.g. name, linked elements, etc.) in a dedicated Properties panel. The next logical step will be to enable a "real" graphical representation for each core LCP-net construct in the editor, using the Graphical Modeling Framework (GMF).

Listing 1. Imaging service LCP-Net -XML excerpt <LCPnet:LCPnet name="Imaging_Service" (...)> <nodes xsi:type="LCPnet:LNode" name="bandwidth" outArcs="(...)"> <domain xsi:type="LCPnet:LNodeValue" name=" Bandwidth_Low" linguisticValue="(...)"/> <domain xsi:type="LCPnet:LNodeValue" name=" Bandwidth_Medium" linguisticValue="(...)"/> <domain xsi:type="LCPnet:LNodeValue" name=" Bandwidth_High" linguisticValue="(...)"/> <domain xsi:type="LCPnet:CNodeValue" name=" Bandwidth_measured_value" crispValue="1.0"/> <linguisticTable> ... </linguisticTable> </nodes> <nodes xsi:type="LCPnet:LNode" name="resolution" inArcs="(...)"> <domain xsi:type="LCPnet:LNodeValue" name="

Resolution_Low" linguisticValue="(...)"/> <domain xsi:type="LCPnet:LNodeValue" name="

Resolution_High" linguisticValue="(...)"/> <domain xsi:type="LCPnet:CNodeValue" name="

Resolution_measured_value" crispValue ="0.51"/> <linguisticTable> ... </linguisticTable> </nodes> <arcs xsi:type="LCPnet:IArc" name="BtoS" startNode ="//@nodes.1" endNode="//@nodes.0"/> <arcs name="BtoR" startNode="//@nodes.1" endNode ="//@nodes.2"/> <valueDomains name="Bandwidth"> <subsets name="Bandwidth_Low"> <fuzzySubset y="1.0"/> <fuzzySubset x="0.5"/> </subsets> (...) </valueDomains> (...) </LCPnet:LCPnet> In any event, there is no need from a preference modeler perspective to directly manipulate an XML document: serialization is handled by the editor and EMF support framework. Should this be required anyway later on, it is currently possible to directly write or modify a LCP-net instance at the XML level, by the same fairly simple syntax used for automatic serialization: listing 1 provides an excerpt of the XML document for the imaging service LCP-net.

Listing 2. Imaging service LCP-net fragment -XML excerpt <fragments:LCPnetFragment (...) fragmentName="imaging_service_fragment"> <baseLCPnet href="imaging_service.lcpnet#/"/> <nodes xsi:type="fragments:LNodeFragment" name="" fragmentName="R_antifragment" antiFragment="true"> <baseLNode href="monitoring_preferences.lcpnet#// @nodes.2"/> </nodes> <nodes xsi:type="LCPnet:LNode" name="Z" inArcs ="//@arcs.1" valueDomain="//@valueDomains.0"> <domain xsi:type="LCPnet:LNodeValue" name="Zoom_Low" linguisticValue=(...)/> <domain xsi:type="LCPnet:LNodeValue" name="Zoom_Medium" linguisticValue=(...)/> <domain xsi:type="LCPnet:LNodeValue" name="Zoom_High" linguisticValue=(...)/> <linguisticTable name="zoom_cpt"> (...) </linguisticTable> </nodes> <arcs xsi:type="LCPnet:IArc" name="BtoZ" startNode ="//@nodes.2" endNode="//@nodes.1"/> (...) </fragments:LCPnetFragment>

The new fragment construct also benefits from an EMF specification and implementation. The same tools used for LCP-net elicitation are used for fragment definition. As such, an excerpt from the XML definition of the previously introduced ImagingPref frag , as in section IV-C, is given in listing 2, putting an emphasis on:

Fig. 1 .

 1 Fig. 1. From static to dynamic task execution.

Fig. 2 .

 2 Fig. 2. Services funneled through late-binding conceptual layers.

Fig. 3 .

 3 Fig. 3. The imaging service QoS preferences with LCP-nets.

Fig. 4 .

 4 Fig. 4. Bandwidth QoS domain fuzzy partitioning.

Fig. 5 .

 5 Fig. 5. Imaging service preference fragment.

Fig. 6 .

 6 Fig. 6. Modified imaging service QoS preferences.. V. IMPLEMENTATION QoS-based late-binding has been implemented in the threeyear SemEUsE project funded by the French National Agency for Research. Started in 2008, it brings together several academic and industrial partners (Thales, Orange Labs, EBM Websourcing, LIP6, INSA, INRIA, INT) with the goal of fostering a "Semantic Middleware" that allows for the implementation of "pervasive, flexible and reliable applications".The parallel between SemEUsE architecture and abstract concepts such as service filtering, selection and invocation is illustrated in Figure7through a simple abstract example. Multiple services from a registry, ranging from S1 to S5, are funneled through each implemented logical step until one service (S1) selected upon its current QoS values and statically defined LCP-net preferences, is invoked. In SemEUsE, functional and non-functional service filtering is being taking care of by the service registry, while non-functional service selection and invocation is implemented by the late-Binding component alongside dynamic orchestration.

3 Fig. 7 .

 37 Fig. 7. SemEUsE architecture overview.

Fig. 8 .

 8 Fig. 8. LCP-net editor GUI.

• the initial import of the imaging_service.lcpnet base LCP-net (that would be deduced automatically from the lexical scope in our envisioned BPEL integration); • the deletion of the node R and its attached CPT, through a node anti-fragment.

• the introduction of a new Z node and BtoZ arc by the definition of their fragments; • the use of XPath expressions to refer to any elements from imaging_service.lcpnet. Our LCP-nets framework is now available as a free download under the GPLv3 license at Google Code http://code.google.com/p/lcp-nets/.

B. Service filtering: from abstract to extended BPEL business process

In SemEUsE, a UDDI [START_REF] Curbera | Unraveling the Web Services Web: an introduction to SOAP, WSDL, and UDDI[END_REF] like service registry has been implemented. It supports both functional and non-functional service requests at the syntactic and semantic levels. Filtering is driven by a matchmaking algorithm using the relationships between the various ontological concepts used to annotate the more common syntactic information (method or operation names, data types and QoS properties). OWL-DL [START_REF] Mcguinness | OWL web ontology language overview[END_REF] has been chosen to define the related ontologies since it gives some guarantees on the outcome of the reasoning process.

Functional service requests (and offers) are provided to the registry as SAWSDL [START_REF] Kopeckỳ | SAWSDL: Semantic annotations for WSDL and XML schema[END_REF] specifications, while non-functional ones are given by WS-agreements [START_REF] Andrieux | Web services agreement specification (WS-Agreement)[END_REF]. Final negotiated WSagreements computed by the registry for each filtered service contain all the necessary information for monitoring probe deployment, and defines, inside an inline QML-based specification [START_REF] Frølund | QML: A Language for Quality of Service Specification[END_REF], all the QoS constraints fulfilled by the service.

The registry is queried, and services filtered, when abstract business processes are translated into extended BPEL processes. In SemEUsE, this translation is made at abstract processes load-time. In these abstract processes, service binding parts have been left out, since available services are not known at design-time. They are filled in with information provided by the registry, and then a runnable extended BPEL process is obtained and can be evaluated. Listing 3. Resulting extended BPEL process excerpt <process name="semeuse" (...) > <!--(...) Import client WSDL, define partner links , define variables --> <sequence name="main"> <extensionActivity> <semeuse:lateBindingConfigure invocationID=" invocation1" preference="prefs.lcpnet"> <semeuse:candidateServices> <semeuse:service EPR="service1" portType=" service1PT" operation="getVideo" contract="wsag1.xml"/> <semeuse:service EPR="service3" portType=" service3PT" operation="getVideo" contract="wsag3.xml"/> </semeuse:candidateServices> </semeuse:lateBindingConfigure> </extensionActivity> <extensionActivity> <semeuse:monitoring state="start" /> </extensionActivity> <!--(...) Receive input from requester. --> <extensionActivity> <semeuse:lateBindingInvoke invocationID=" invocation1" inputVariable="invoke_in" outputVariable="invoke_out" preference="prefs.lcpnet"/> </extensionActivity> <!--(...) Generate reply to request --> <extensionActivity> <semeuse:monitoring state="stop" /> </extensionActivity> </sequence> </process>

In this extended BPEL process, three new late-binding centric extended activities can be found: lateBindingConfigure, responsible for setting up monitoring; monitoring, for launching and controlling it; and finally lateBindingInvoke, for initiating service selection and invocation. The BPEL process excerpt given in listing 3 integrates these activities in the previous imaging service scenario. Since its is obtained after selection, only candidate services are mentioned (service1 and service3, as in figure 7).

In SemEUsE, Orchestra has been chosen as the business process orchestration engine and Petals as its service bus. The engine, which provides an accomplished implementation of the BPEL extension mechanism, allows us to write three dedicated classes to process these required activities when encountered during process execution. These classes act as proxies to the LCP-net decision engine and monitoring framework: they retrieve the necessary configuration arguments, pass them on, and trigger the corresponding actions (monitoring configuration, launch, and service invocation) in these modules.

The Java classes are extensions of the abstract class org. ow2.orchestra.definition.activity.AutomaticActivity which itself inherits from AbstractActivity. This method allows for the implementation of advanced business logic alongside the usual BPEL workflow, with a certain level of visibility and interaction over the execution context made possible through a org.ow2.orchestra.runtime. BpelExecution variable.

C. Current QoS monitoring with the M4ABP middleware

Probes and monitoring interfaces are provided by an external middleware designed with adaptive business processes and decision making in mind: M4ABP (Monitoring for Adaptive Business Process) [START_REF] Duc | Non-functional Data Collection for Adaptive Business Process and Decision Making[END_REF]. Configuration of M4ABP is made with the information contained in lateBindingConfigure activities, as can be seen in Listing 3, where needed technical (such as the End Point Reference, Port Type or operation name) and non-functional information (LCP-net preferences and WSagreements URLs) is provided. At this point, the LCP-net preference file is only used to determine which QoS properties should be monitored; most of the related technical information needed for probe deployment is contained in the negociated WS-agreements (wsag1.xml and wsag3.xml). An excerpt of the second one is given in Listing 4.

Listing 4. WS-agreement excerpt for service3 <agreement:Agreement (...) > <name>wsag3</name><agreementId>id</agreementId> <context/> <terms><all> <serviceDescriptionTerm name="getVideo" serviceName="getVideo" /> <serviceProperties name="getVideo" serviceName=" getVideo"> <variableSet> <variable name="resolution"> <location xsi:type="semeuse:WSBinding" mode="pull" type="ws" epr="http://localhost:8080/services/Camera3" operation="getResolution" /> </variable> <variable name="bandwidth"> <location xsi:type="semeuse:WSBinding" mode="pull" type="ws" epr="http://localhost:8080/services/Camera3" operation="getBandwidth" /> </variable> (...) </variableSet> </serviceProperties> </all></terms> </agreement:Agreement> Following directly, monitoring of services is launched by the monitoring extended activity with the start argument. Since both the lateBindingConfigure and monitoring activities are placed at the very beginning of the BPEL process, current QoS monitoring effectively starts before the evaluation of the BPEL process "business" body, at load-time.

D. Late-binding in Orchestra

The lateBindingInvoke activity implements the run-time service selection over candidate service sets, using the current QoS values being provided by M4ABP and the LCP-net specified preferences. Indeed, the binding decisions between processes and services are made upon service utilities through the LCP-net evaluation process explained in section IV.

The LCP-net engine, which is the component responsible for outputting the global utility for each considered service, has also logically been implemented in Java, to maximize its integration with the whole framework. At its core, the jFuzzy-Logic library processes QoS levels inputs through computed Fuzzy Inference Systems in order to obtain local utilities for each monitored QoS dimensions. Indeed, it implements the standardized Fuzzy control language (FCL) specification (EC 61131-7) under which our FISs are serialized.

After selection, the remote invocation of the bound service is passed on to the underlying Orchestra and Petals support infrastructure, leaving only data adaptation concerns on services inputs and outputs to be solved. Since service filtering has been made at process load-time, the necessary data adaptation schemes have also been computed at the same time, leaving only their application at invocation-time. As indicated earlier, generating data adaptation at load-time forces to use simpler matching schemes than the ones used offline, which are too computationally involving. The objection that fewer services can then be matched is largely offset by the vast offering of functionally-equivalent services promoted by Semantic SOAs giving more choices for matching.

VI. CONCLUSION

In this paper, a new programming abstraction, QoS-based late-binding of service invocations, has been proposed to provide for more agility to business process execution. Based on current QoS values of a set of services and user preferences expressed in a qualitative way, the service selection elects and calls the current best offer among equivalent concrete candidate services capable of answering a call to an abstract service functionality. A new formalism, called LCP-nets [START_REF] Châtel | A linguistic approach for nonfunctional preferences in a semantic SOA environment[END_REF], is used to allow non-specialist programmers to qualitatively express their preferences among values of the different QoS properties in this multi-criteria decision making process.

This new programming abstraction has been implemented as BPEL extended activities for the Orchestra engine. These extended activities use an implementation of LCP-nets in EMF providing for both the creation of LCP-nets by programmers and their use at run-time in the decision making. QoS data are gathered by a monitoring middleware [START_REF] Duc | Non-functional Data Collection for Adaptive Business Process and Decision Making[END_REF], which organizes and optimizes the regular flow of data from services to the business process and provides for their buffering for immediate access and gathering when the late-binding decisions must be made upon them. This data mediation layer also provides some means to ensure the temporal coherence of the monitoring data bundled for each late-binding decision, a key dimension in the quality of information for such middleware.

Perspectives and future work are numerous. More experiments and performance measurements are needed to fine tune the current implementation. Currently, the incremental definition of LCP-nets is limited to two levels, and it is implemented in a statically scoped way in BPEL. Allowing more levels and providing them as first-class entities would provide for even more flexibility to programmers in order to share common preferences among decision sites in complex business processes. The monitoring shall be extended to cope with more quality of information properties for monitoring data, such as its freshness, its precision, etc.


Pierre Ch Âtel
email: pierre.chatel@fr.thalesgroup.com

Jacques Malenfant
email: jacques.malenfant@lip6.fr

A linguistic approach for non-functional constraints in a semantic SOA environment

Keywords: preference modelling, fuzzy linguistic approach, CP-Nets, Web service filtering .e. CP-Nets, TCP-Nets, UCP-Nets, etc

This contribution addresses the problem of expressing preferences among nonfunctional properties in a Web Service architecture. In such a context, semantic annotations are needed and added on service declaration and business process in order to select the best available service. These conditional and unconditional preferences are managed using Conditional Preference-Networks (CP-Nets). But in several cases, uncertainty related to the preferences has to be taken into account to achieve a better satisfaction rate. We propose the use of fuzzy linguistic information inside the whole process when it will be necessary.

Introduction

Service-oriented architectures (SOA) deal with the growing need for distributed applications capable of evolving continuously over their execution. In the context of the web, services can appear and disappear at runtime, thus requiring a loose coupling between service providers and consumers. To get this loose coupling, we adopt the late-binding of calls to services, by deciding at runtime which service will be called to satisfy each con-sumers' request. We use consumers' preferences over the functional and non-functional characteristics to choose among candidate services.

We concur with Schröpfer et al. [START_REF] Schröpfer | Introducing preferences over NFPs into service selection in SOA[END_REF] to use a CP-Nets approach to elicit and exploit consumers preferences in a Semantic Service Oriented Architecture (SSOA). But we use the fuzzy linguistic approach [START_REF] Zadeh | The Concept of a Linguistic Variable and Its Applications to Approximate Reasoning[END_REF] to model nonfunctional preferences for the dynamic selection of Web services. These preferences express complex requirements, defined inside Web processes, that are related to the different non-functional characteristics of the services that will be needed to guarantee the application's execution (an SOA application is a set of Web processes and dynamically discovered Web services).

In the rest of the paper, we first introduce our technical framework, then we briefly describe "*CP-Nets" * . Section 4 introduces our proposal of using fuzzy linguistic in modeling preferences, Section 5 provides a proofof-concept example, while Section 6 points out conclusions and future work.

Technical Framework

SOA and Web Services

In the SOA framework, two distinct roles are identified. Service providers implement (generic) functionalities made available to applications, thanks to SOA standards like, e.g., service directories, as Web services. Service consumers request and use services available on the network according to their specific requirements through service calls made by Web processes.

To cope with the dynamism of the Web, the binding of Web services (from providers) to Web processes (of consumers) is established on the fly, at runtime. To achieve this, and to provide for high interoperability among heterogeneous service offers and requests, we make this binding go much farther than the traditional syntactic approach by using semantic annotations on service offers and requests to identify offers that match each request. In our approach, semantics encompasses both functional (what services do and processes need) and non-functional properties (QoS and related properties guaranteed by Web services and required by Web processes).

Functional and Non-Functional Constraints

Functionality of service offers concerns the core business work provided by each Web services. We strive to semantically describe the main features of the service: its end goal and the ontological concepts associated to its input and output parameters. We use SAWSDL [START_REF] Lausen | Semantic Annotations for WSDL and XML Schema[END_REF] to annotate otherwise syntax-based service offers with classes (i.e. concepts) from domain ontologies. Service requests express similarly their semantic requirements for the completion of their task.

But we also strive to build Quality of Service (QoS) awareness into the above SSOA platform to select at runtime the best service(s) available to fulfill each request. Indeed, after filtering with functional constraints, we also use non-functional information to further seek the best service(s). Non-functional requirements are constraints and preferences applied to both statically published and instantaneously measured QoS values associated to the functionally filtered services.

A major issue when dealing with QoS is the large number of different dimensions (e.g. latency, precision, etc.) of importance. Because one rarely gets an offer that is the best for every different QoS dimension, we need consumer preferences to rank offers given their relative strength on the different dimensions. To this end, we propose a new formalism based on the combination of CP-Nets 1 and the fuzzy linguistic approach [START_REF] Zadeh | The Concept of a Linguistic Variable and Its Applications to Approximate Reasoning[END_REF] to specify the preferences of web processes over the different QoS properties of offers.

Modelling Preferences Through *CP-Nets

CP-Nets

A CP-Net (Conditional Preference-Network) is a compact graphical representation of qualitative user preferences. [START_REF] Boutilier | CPnets: A tool for representing and reasoning with conditional Ceteris Paribus Preference Statements[END_REF] It is relatively intuitive. Its main elements are: nodes representing the problem variables (properties), arcs denoting preferences among these variables for given values, and the "Conditional Preference Tables" or CPT. CPTs express the preference over values taken by nodes, using binary relationship between them.

CP-Nets allow for the preference modeling of statements such as "I prefer the V 1 value for property X over V 2 if properties Y equals V Y and Z equals V Z ". In fact, this graphical representation allows us to express the dependency between connected CPTs. There is also a notion of relative preference between the preferences themselves: a CPT associated with a specific node has a higher priority than the CPTs of its offspring.

Common CP-Nets variants

Utility CP-Nets, or UCP-Nets, differ from CP-Nets by replacing the binary relationship between node values in CPTs by utility factors. [START_REF] Boutilier | UCP-Networks: A directed graphical representation of conditional utilities[END_REF] A utility factor is a real number associated to the value assigned to a node X from the network, given a specific assignment to its parent nodes P a(X). Utility factors express preference degrees for the different assignments.

Another extension, named Tradeoffs-enhanced CP-Nets, or TCP-Nets, allows one to express preferences of the form: "A better assignment for X is more important than a better assignment for Y ". These are called relative importance statements. [START_REF] Brafman | Introducing variable importance tradeoffs into CP-nets[END_REF] Using a new kind of preference tables and a new specific arc, TCP-Nets generalize this class of preferences in order to accept conditional relative importance statements. With these, it becomes possible to express preferences of the form: "A better assignment for X is more important than a better assignment for Y given that Z = z".

Our idea to use the TCP-and UCP-Nets formalisms for service selection in an SOA framework has already been proposed 11 but we go further by following a fuzzy linguistic approach alongside *CP-Nets.

Fuzzy Linguistic Approach and CP-Nets

*CP-Nets exhibit two important limitations to express preferences in a QoS settings. Many QoS dimensions are defined by continuous domain variables, but *CP-Nets do not handle continuous variables. We propose to discretize continuous domains using fuzzy linguistic terms 12 instead of crisp subsets. Another problem is that precise utility values, such as those used in UCP-Nets, are hard to get from the customers. We propose to express the utility factors with qualitative data, i.e. words translated into fuzzy subsets, later on represented as fuzzy 2-tuples 8 to compute global utility functions.

Fuzzy Linguistic Approach

The fuzzy linguistic approach represents qualitative aspects as linguistic values by means of linguistic variables. [START_REF] Zadeh | The Concept of a Linguistic Variable and Its Applications to Approximate Reasoning[END_REF] Appropriate linguistic descriptors must be chosen to form the term set as well as their semantics. The universe of the discourse over which the term set is defined can be arbitrary. In this paper, we shall use the interval [0, 1]. Odd cardinality term sets, typically 7 or 9, are preferred, [START_REF] Delgado | On Aggregation Operations of Linguistic Labels[END_REF][START_REF] Herrera | A 2-tuple fuzzy linguistic representation model for computing with words[END_REF] representing the mid term by an assessment of "approximately 0.5", other terms being placed symmetrically around it. For example, a set of five terms S, could be given as: S = {s 0 : very low, s 1 : low, s 2 : medium, s 3 : high, s 4 : very high}. It is also required that there exist negation Neg, a max and min operators defined over this set. [START_REF] Herrera | A 2-tuple fuzzy linguistic representation model for computing with words[END_REF] The use of linguistic variables implies the processes of computing with words for their fusion, aggregation, comparison, etc. To perform these computations, different models have been used such as the semantic, 5 the symbolic 6 or the 2-tuple 8 representation models.

Linguistic CP-Nets (LCP-Nets)

We propose a new variant of CP-Nets, called LCP-Nets, to get the advantage of the fuzzy linguistic approach into a marriage of UCP-Nets and TCP-Nets. LCP-Nets have nodes corresponding to problem variables which continuous domains are discretized as linguistic term sets. LCP-Nets allow users to express tradeoffs among variables using i-arcs from TCP-Nets. Finally, LCP-Nets have CPTs similar to the ones of UCP-Nets, but express utilities with linguistic terms rather than numerical values.

Those linguistic terms are represented as 2-tuples to allow for the computation of the aggregated global utility function of the LCP-Net from its different CPTs. To perform this aggregation, we use a weighted average operator where the weights are in [0,1], sum to 1 and are decreasing from more important variables (high in the LCP-Net) to less important ones.

Example

Consider an imaging web service which QoS is defined using three dimensions: security (S), bandwidth (B) and image resolution (R). The user always prefers bandwidth over security, and if the bandwidth is low, he prefers low-resolution images because he simply needs images as fast as possible. Figure 1 gives the corresponding LCP-Net.

Security can be either none or full, given utilities very low and very high respectively. The preference of bandwidth over security is accounted for by an i-arc from B to S (an arc with a middle triangle). The bandwidth is discretized using three linguistic variables B L (low), B M (medium) and B H (high). Preferences among these values are given by the CPT beside B, expressing a very low preference for a low bandwidth, a medium one for the medium bandwidth and a very high one for a high bandwidth.

Image resolution is also discretized using two linguistic terms: R L (low) and R H (high). The preferences among these values are conditional to the bandwidth. If the bandwidth is low (B L ), a low resolution (R L ) has higher preference (very high), but if the bandwidth is high (B H ), a high resolution (R H ) is prefered (very high). When the bandwidth is medium (B m ), a low resolution image is prefered, but with less intensity (high).

Using weights 0.6, 0.25 and 0.15 for B, S and R, we can compute, 8 for example, the global utility of the assignment (S f ull , B M , R H ) as ∆(0.6 × 2 + 0.25 × 4 + 0.15 × 4) = 2.8 = (3, -0.2) which gives the term high.

Conclusions

In this paper, we have presented a new variant of CP-Nets, called Linguistic CP-Nets (LCP-Nets), combining features of UCP-Nets and TCP-Nets with the advantages of a fuzzy linguistic approach to discretize continuous domain variables, and to express the utilities of assignments to variables in conditional preference tables. LCP-Nets prove to be well suited for semantic SOA, as they allow users to effectively discretize continuous domain QoS with appropriate linguistic terms, and to express utility of assignments in a qualitative manner rather than an often contrived numerical one.

We have assumed for the time being that utilities are always expressed using the same linguistic term set, but this restriction could easily be removed by using a multigranular 9 approach when computing the global utility function. Similarly, the assumption on the linguistic sets as being centered on 0.5 with terms being equidistant could also be removed using approaches to cope with unbalanced term sets. [START_REF] Herrera | A Hierarchical Ordinal Model for Managing Unbalanced Linguistic Term Sets Based on the Linguistic 2-Tuple Model[END_REF]