Service-Oriented Computing

With the intention of design by reuse,

configurable process models

provide a way to model variability in reference models that need to be configured according to specific needs. Recently, the increasing adoption of configurable process models has resulted in a large number of configured process variants. Current research activities are successfully investigating the design and configuration of configurable process models. However, a little attention is attributed to analyze the way they are configured. Such analysis can yield useful information in order to help organizations improving the quality of their configurable process models. In this paper, we introduce

configuration rule mining

, a frequency-based approach for supporting the variability analysis in configurable process models. Basically, we propose to enhance configurable process models with configuration rules that describe the interrelationships between the frequently selected configurations. These rules are extracted from a large collection of process variants using

association rule mining

techniques. To show the feasibility and effectiveness of our approach, we conduct experiments on a dataset from SAP reference model.

Traditional structured process-support systems increasingly prove too rigid amidst today’s fast-paced and knowledge-intensive environments. Commonly described as “unstructured” or “semi-structured” processes, they cannot be pre-planned and likely to be dependent upon the interpretation of human-workers during process execution. On the other hand, there has been a plethora of Social and Web 2.0 services to support workers with enhanced collaboration, however these tools are often used ad-hoc with little or no customisable process support. In order to address these challenges, we thus present: “

ProcessBase

”, an innovative Hybrid-Processes platform that holistically combines

structured

,

semi-structured

and

unstructured

activities. Our task-model proposed encapsulates a spectrum of process specificity, including: structured to ad-hoc Web-service tasks, automated rule-tasks, human-tasks as well as lifecycle state-tasks. In addition, our hybrid process-model enables the “evolution/agility” from unstructured to increasingly structured process design; as well as the notion of “cases” representing repeatable process patterns and variations. We further propose an incremental process-knowledge acquisition technique for curation, which is thereby utilised to facilitate efficient “re-use” in the form of a context-driven recommendation system.

Business process model repair aims at updating an existing model so as to accept deviant (e.g., new) behaviours, while remaining as close as possible to the initial model. In this paper, we present a multi-objective approach to process model repair, which maximizes the behaviours accepted by the repaired model while minimizing the cost associated with the repair operations. Given the repair operations for full process repair, we formulate the associated multi-objective problem in terms of a set of pseudo-Boolean constraints. In order to evaluate our approach, we have applied it to a case study from the Public Administration domain. Results indicate that it provides business analysts with a selection of good and tunable alternative solutions.

The propagation and management of changes in process choreographies has been recently addressed as crucial challenge by several approaches. A change rarely confines itself to a single change, but triggers other changes in different partner processes. Specifically, it has been stated that with an increasing number of partner processes, the risk for transitive propagations and costly negotiations increases as well. In this context, utilizing past change events to learn and analyze the propagation behavior over process choreographies will help avoiding significant costs related to unsuccessful propagations and negotiation failures, of further change requests. This paper aims at the posteriori analysis of change requests in process choreographies by the provision of mining algorithms based on change logs. In particular, a novel implementation of the memetic mining algorithm for change logs, with the appropriate heuristics is presented. The results of the memetic mining algorithm are compared with the results of the actual propagation of the analyzed change events.

Organizations use business process management techniques to manage their core business processes more efficiently. A recent technique is the synchronization of multiple process instances by processing a set of activities as a batch – referred to as batch regions, e.g., the shipment of goods of several order processes at once. During process execution, events occur providing information about state changes of (a) the business process environment and (b) the business process itself. Thus, these events may influence batch processing. In this paper, we investigate how these events influence batch processing to enable flexible and improved batch region execution. Therefore, we introduce the concept of batch adjustments that are defined by rules following the Event-Condition-Action principle. Based on batch adjustment rules, relevant events are correlated at run-time to batch executions that fulfill the defined condition and are adjusted accordingly. We evaluate the concept by a real-world use case.

Efficient evaluation of distributed computation on large-scale data is prominent in modern scientific computation; especially analysis of big data, image processing and data mining applications. This problem is particularly challenging in distributed environments such as campus clusters, grids or clouds on which the basic computation routines are offered as web/cloud services. In this paper, we propose a locality-aware workflow-based solution for evaluation of large-scale matrix expressions in a distributed environment. Our solution is based on automatic generation of BPEL workflows in order to coordinate long running, asynchronous and parallel invocation of services. We optimize the input expression in order to maximize parallel execution of independent operations while reducing the matrix transfer cost to a minimum. Our approach frees the end-user of the system from the burden of writing and debugging lengthy BPEL workflows. We evaluated our solution on realistic mathematical expressions executed on large-scale matrices distributed on multiple clouds.

Service-based applications must be adaptable to cope with the dynamic environments in which they reside. Dynamic service composition is a common solution to achieving adaptation, but it is challenging in mobile ad hoc network (MANET) environments where devices are resource-constrained and mobile. Existing solutions to dynamic service composition predefine the multiple configurations that may be possible, but this requires knowledge of the configurations a-priori. Alternatively, some solutions provide on-demand composition configurations, but they depend on central entities which are inappropriate in MANET environments. We propose a decentralized service composition model, in which a system dynamically adapts its business process by composing its fragments on-demand, as appropriate to the constraints of the service consumer and service providers. Results show a high composition success rate for the service compositions in high mobility environments.

In this article, we propose a model based on 0-1 linear programming for automatically determining a transactional composite web service (CWS) from a service dependency graph that optimizes a QoS measure. The QoS measure used in this model can be either a classical weighted sum of QoS criteria or a minmax-type criterion (e.g. response time). The transactional properties are a set of rules that ensures a reliable execution of the resulting CWS. The proposed 0-1 linear program is solved using a standard solver (CPLEX). Our experiments show that this new exact model surpasses two main related approaches: an approximate one based on transactional requirements and an exact one, based on 0-1 linear programming (LP), but not dealing with transactional properties. In a large majority of the test sets used for our experiments, our model finds a better solution more rapidly than both related approaches and is able to guarantee its optimality. Moreover, our model is able to find the optimal solutions of big size test sets, as the ones proposed by the Web Service Challenge 2009.

The last years witnessed the success of Linked Open Data (LOD) project and the growing amount of semantic data sources available on the web. However, there is still a lot of data that will not be published as a fully materialized knowledge base (dynamic data, data with limited acces patterns, etc). Such data is in general available through web api or web services. In this paper, we introduce a SPARQL-driven approach for searching linked data and relevant services. In our framework, a user data query is analyzed and transformed into service requests. The resulting service requests, formatted for different semantic web services languages, are addressed to services repositories. Our system also features automatic web service composition to help finding more answers for user queries. The intended applications for such a framework vary from mashups development to aggregated search.

DecSerFlow is a declarative language to specify business processes. It consists of a set of temporal predicates that can be translated into LTL but limited to finite sequences. This paper focuses on the “conformance problem”: Given a set of DecSerFlow constraints, is there an execution sequence that satisfies all given constraints? This paper provides syntactic characterizations of conformance for several subclasses of DecSerFlow constraints. These characterizations directly lead to efficient (polynomial time) conformance testing. Furthermore, algorithms are developed to generate conforming strings if the set of constraints is conformable. A conformance analyzer is developed based on the syntactic characterizations and the string generating algorithms. Experiments reveal several interesting factors concerning performance and scalability.

In service computing, online services and the Internet environment are evolving over time, which poses a challenge to service composition for adaptivity. In addition, high efficiency should be maintained when faced with massive candidate services. Consequently, this paper presents a new model for large-scale and adaptive service composition based on multi-agent reinforcement learning. The model integrates on-policy reinforcement learning and game theory, where the former is to achieve adaptability in a highly dynamic environment with good online performance, and the latter is to enable multiple agents to work for a common task (i.e., composition). In particular, we propose a multi-agent SARSA (State-Action-Reward-State-Action) algorithm which is expected to achieve better performance compared with the single-agent reinforcement learning methods in our composition framework. The features of our approach are demonstrated by an experimental evaluation.

In order to address the unreliable nature of service providers, and the dynamic nature of services (their quality values could change frequently over time due to various factors), this paper proposes a probabilistic, multi-valued quality model for services, capable of capturing uncertainty in their quality values by assigning each quality attribute with multiple potential values (or ranges of values), along with a corresponding probability distribution over these values. The probability distribution indicates the most likely quality value for an attribute at the current time step, but also notifies discovery applications of the possibility of other, possibly worse outcomes, thus ultimately facilitating more reliable service selection and composition via avoiding services with high uncertainty. Such uncertainty-aware, multi-valued quality models of services are maintained via an agent-based service marketplace, where each service is associated with a software agent, capable of learning the time-varying probability distributions of its quality values through applying online learning techniques, based on the service’s past performance information. The experiments conducted demonstrate the effectiveness of the proposed approach.

Complex, message-based service systems discourage central execution control, require extremely loose coupling, have to cope with unpredictable availability of individual (composite) services, and may experience a dynamically changing number of service instances. At the topmost level, the architecture of such a complex system often follows a messaging style most naturally. A major problem during the design of these systems is achieving an overall consistent configuration (i.e, ensuring intended message routing across producers, consumers, and brokers). While orchestration or choreography-based approaches support the design of individual composite services along a workflow-centric paradigm, they are an awkward fit for specifying a message-centric architecture. In this paper, we present an architecture-centric approach to designing complex service systems. Specifically we propose modeling the system’s high-level architecture with an architecture description language (ADL). The ADL captures the message-centric configuration which subsequently allows for consistency checking. An architecture-to-configuration transformation ensures that the individual deployed services follow the architecture without having to rely on a central coordinator at runtime. Utilizing our provided tool support, we demonstrate the successful application of our methodology on a real world service system.

Interconnected smart devices in the Internet of Things (IoT) provide fine-granular data about real-world events, leveraged by service-based systems using the paradigm of event-based systems (EBS) for invocation. Depending on the capabilities and state of the system, the information propagated in EBS differs in content but also in properties like precision, rate and freshness. At runtime, consumers have different dynamic requirements about those properties that constitute quality of information (QoI) for them. Current approaches to support quality-related requirements in EBS are either domain-specific or limited in terms of expressiveness, flexibility and scope as they do not allow participants to adapt their behavior. We introduce the generic concept of

expectations

to express, negotiate and enforce arbitrary requirements about information quality in EBS at runtime. In this paper, we present the model of expectations, capabilities and feedback based on generic properties. Participants express requirements and define individual tradeoffs between them as expectations while system features are expressed as capabilities. We discuss the algorithms to (i) negotiate requirements at runtime in the middleware by matching expectations to capabilities and (ii) adapt participants as well as the middleware. We illustrate the architecture for runtime-support in industry-strength systems by describing prototypes implemented within a centralized and a decentralized EBS.

Distributed storage systems (e.g. clustered filesystems - HDFS, GPFS and Object Stores - Openstack swift ) often partition sequential data across storage systems for performance (

data striping

) or protection (

Erasure-Coding

) . This partitioning leads to logically correlated data being stored on different physical storage devices, which operate autonomously. This un-coordinated operation may lead to inefficient caching, where different devices may cache segments that belong to different working sets. From an application perspective, caching is effective only if all segments needed by it at a given point in time are cached and a single missing segment may lead to high application latency. In this work, we present C2P: a middleware for co-operative caching in distributed storage.

C2P

uses an event-based architecture to co-ordinate caching across the storage devices and ensures that all devices cache correlated segments. We have implemented C2P as a caching middleware for hosted Openstack Swift Object Store. Our experiments show 4-6% improved cache hit and 3-5% reduced disk IO with minimal resource overheads.

REST

(REpresentational State Transfer), relying on

resources

as its architectural unit, is currently a popular architectural choice for building Web-based applications. It is shown that

design patterns

—good solutions to recurring design problems—improve the design quality and facilitate maintenance and evolution of software systems.

Antipatterns

, on the other hand, are poor and counter-productive solutions. Therefore, the detection of

REST

(anti)patterns is essential for improving the maintenance and evolution of

RESTful

systems. Until now, however, no approach has been proposed. In this paper, we propose

SODA-R

(Service Oriented Detection for Antipatterns in

REST

), a heuristics-based approach to detect (anti)patterns in

RESTful

systems. We define detection heuristics for eight

REST

antipatterns and five patterns, and perform their detection on a set of 12 widely-used

REST

APIs

including BestBuy, Facebook, and DropBox. The results show that

SODA-R

can perform the detection of

REST

(anti)patterns with high accuracy. We also found that Twitter and DropBox are not well-designed,

i.e.

, contain more antipatterns. In contrast, Facebook and BestBuy are well-designed,

i.e.

, contain more patterns and less antipatterns.

With the rapid adoption of REpresentational State Transfer (REST), more software organizations expose their applications as RESTful web APIs and client code developers integrate RESTful APIs into their applications. When web APIs evolve, the client code developers have to update their applications to incorporate the API changes accordingly. However client code developers often encounter challenges during the migration and API providers have little knowledge of how client code developers react to the API changes. In this paper, we investigate the changes among subsequent versions of APIs and classify the identified changes to understand how the RESTful web APIs evolve. We study the on-line discussion from developers to the API changes by analyzing the StackOverflow questions. Through an empirical study, we identify 21 change types and 7 of them are new compared with existing studies. We find that a larger portion of RESTful web API elements are changed between versions compared with Java APIs and WSDL services. Moreover, our results show that

adding new methods

in the new version causes more questions and views from developers. However the

deleted methods

draw more relevant discussions. In general, our results provide valuable insights of RESTful web API evolution and help service providers understand how their consumers react to the API changes in order to improve the practice of evolving the service APIs.

In a knowledge based service system like IT services, the requirements of skills to service customer requests keep changing with time. The service workers are expected to learn the required skills very quickly and become productive. Due to high attrition rate and demand, service workers are given basic class room training and then rest of the training is carried out on-job. When a service worker learns multiple skills simultaneously, learning slows down due to factors like forgetting and interference. At the same time, the organization needs to meet service level agreements (SLA). We have developed a model for on-job training which extends the business process for IT service delivery. The key idea is to model learning, forgetting and interference in service time estimation to get realistic service times. Accurate estimation of service time taken by a service worker to resolve the service tickets helps in resource allocation and planning decisions for achieving the desired objectives of upskilling and SLA success. The simulation of execution of the augmented business process provides insights into what kind of planning and dispatch policies should be practiced for achieving the desired goals of multi-skill learning and SLA success.

Complex cloud services rely on different elasticity control processes to deal with dynamic requirement changes and workloads. However, enforcing an elasticity control process to a cloud service does not always lead to an optimal gain in terms of quality or cost, due to the complexity of service structures, deployment strategies, and underlying infrastructure dynamics. Therefore, being able, a priori, to estimate and evaluate the relation between cloud service elasticity behavior and elasticity control processes is crucial for runtime choices of appropriate elasticity control processes. In this paper we present ADVISE, a framework for estimating and evaluating cloud service elasticity behavior. ADVISE gathers service structure, deployment, service runtime, control processes, and cloud infrastructure information. Based on this information, ADVISE utilizes clustering techniques to identify cloud elasticity behavior produced by elasticity control. Our experiments show that ADVISE can estimate the expected elasticity behavior, in time, for different cloud services thus being a useful tool to elasticity controllers for improving the quality of runtime elasticity control decisions.

While conversion of atomic and back-end services from centralized servers to cloud platforms has been largely successful, the composition layer, which gives the service-oriented architecture its flexibility and versatility, often remains a bottleneck. The latter can be re-engineered for horizontal and vertical scalability by moving away from coarser concurrency model that uses transactional databases for keeping and maintaining composition internal state, towards a finer-grained model of concurrency and distribution based on actors, state messaging, and non-blocking write-only state persistence. In this paper we present a scheme for automatically transforming the traditional (orchestration-style) service compositions into Cloud-friendly actor networks, which can benefit from high performance, location transparency, clustering, load balancing, and integration capabilities of modern actor systems, such as Akka. We show how such actor networks can be monitored and automatically made persistent while avoiding transactional state update bottlenecks, and that the same networks can be used for both executing compositions and their testing and simulation.

Organizations have to comply with geo-location policies that prescribe geographical locations at which personal data may be stored or processed. When using cloud services, checking data geo-location policies during design-time is no longer possible - data geo-location policies need to be checked during run-time. Cloud elasticity mechanisms dynamically replicate and migrate virtual machines and services among data centers, thereby affecting the geo-location of data. Due to the dynamic nature of such replications and migrations, the actual, concrete changes to the deployment of cloud services and thus to the data geo-locations are not known. We propose a policy checking approach utilizing runtime models that reflect the deployment and interaction structure of cloud services and components. By expressing privacy policy checks as an st-connectivity problem, potential data transfers that violate the geo-location policies can be rapidly determined. We experimentally evaluate our approach with respect to applicability and performance using an SOA-version of the CoCoME case study.

When utilizing cloud-based services, consumers obtain high configurable resources with minimal management effort and eliminate large up-front IT investments. However, this shift in responsibility to the cloud provider is accompanied by a loss of control for the cloud consumer. By offering SLAs and corresponding monitoring solutions, cloud providers already try to address this issue, but these solutions are not considered as sufficient from a consumer’s perspective. Therefore, we developed an approach that allows to verify compliance with SLAs from a consumer’s perspective in our former work. Since the monitoring infrastructure itself may fail, this approach was enhanced in one of our subsequent works in order to account for reliability. We introduced the Robust Cloud Monitor Placement Problem and a formal optimization model. In this paper, we propose corresponding solution approaches and evaluate their practical applicability, since the problem is NP-complete.

Leading paradigms to develop and operate applications such as continuous delivery, configuration management, and the merge of development and operations (DevOps) are the foundation for various techniques and tools to implement automated deployment. To expose such applications as services (SaaS) to users and customers these approaches are typically used in conjunction with Cloud computing to automatically provision and manage underlying resources such as storage or virtual machines. A major class of these automation approaches follows the idea of converging toward a desired state of a resource (e.g., a middleware component deployed on a virtual machine). This is achieved by repeatedly executing idempotent scripts until the desired state is reached. Because of major drawbacks of this approach, we present an alternative deployment automation approach based on compensation and fine-grained snapshots using container virtualization. We further perform an evaluation comparing both approaches in terms of difficulties at design time and performance at runtime.

Collaborative Inter-Organisational Business Processes (IOBPs) are a major step in automating and supporting collaborations of organisations. In this context, collaborative IOBP are usually constrained by hard timing requirements. This paper proposes an approach for analyzing

temporal consistency

of collaborative IOBPs. The aim is to verify temporal consistency of IOBP and to provide the enactment service with largest intervals as starting time windows of the processes. The proposed approach enables organisations to detect, early on, temporal inconsistencies that may constitute obstacles towards their interaction. Indeed, it provides an enactment service, which provides each partner with information about temporal restrictions to respect by its own processes in accordance with the overall temporal constraints of all involved processes.

Process models specify behavioral execution constraints between activities as well as between activities and data objects. A data object is characterized by its states and state transitions represented as object life cycle. For process execution, all behavioral execution constraints must be correct. Correctness can be verified via soundness checking which currently only considers control flow information. For data correctness, conformance between a process model and its object life cycles is checked. Current approaches abstract from dependencies between multiple data objects and require fully specified process models although, in real-world process repositories, often underspecified models are found. Coping with these issues, we apply the notion of weak conformance to process models to tell whether each time an activity needs to access a data object in a particular state, it is guaranteed that the data object is in or can reach the expected state. Further, we introduce an algorithm for an integrated verification of control flow correctness and weak data conformance using soundness checking.

We propose a new failure-proof composition model for Sensor-Cloud services based on dynamic features such as spatio-temporal aspects. To evaluate Sensor-Cloud services, a novel spatio-temporal quality model is introduced. We present a new failure-proof composition algorithm based on D* Lite to handle QoS changes of Sensor-Cloud services at run-time. Analytical and simulation results are presented to show the performance of the proposed approach.

The ability to a priori predict the QoS of a service orchestration is of pivotal importance for both the design of service compositions and the definition of their SLAs. QoS prediction is challenging because the results of service invocations is not known a priori. In this paper we present an algorithm to probabilistically predict the QoS of a WS-BPEL service orchestration. Our algorithm employs Monte Carlo simulations and it improves previous approaches by coping with complex dependency structures, unbound loops, fault handling, and unresponded service invocations.

The proliferation of sensor devices and services along with the advances in event processing brings many new opportunities as well as challenges. It is now possible to provide, analyze and react upon real-time, complex events about physical or social environments. When existing event services do not provide such complex events directly, an event service composition maybe required. However, it is difficult to determine which compositions best suit users’ quality-of-service requirements. In this paper, we address this issue by first providing a quality-of-service aggregation schema for event service compositions and then developing a genetic algorithm to efficiently create optimal compositions.

The quality of service (QoS) of complex software systems, built by composing many components, is essential to determine their usability. Since the QoS of each component usually has some degree of uncertainty, the QoS of the composite system also exhibits stochastic behavior. We propose to compute probability distributions of the QoS of a service composition using its structure and the probability distributions of the QoS of the components. We experimentally evaluate our approach on services deployed in a real setting using a tool to predict probability distributions for the composition QoS and comparing them with those obtained from actual executions.

The composition of web services requires process designers to capture the goals of the service composition in a partial process model. Manually deriving the partial process model from the requirement specifications is not trivial. A clear understanding of the requirements, interaction among services, their inputs and outputs are precursors for developing the partial process models. To reduce the complexity, we propose an approach to guide process designers in deriving the partial process models by reusing the knowledge captured in requirement specifications and domain ontologies. The results of the evaluation shows that our approach is promising in terms of correctness and completeness.

Services are self-contained software components that can be used platform independent and that aim at maximizing software reuse. A basic concern in service oriented architectures is to measure the reusability of services. One of the most important qualities is the

functional

reusability, which indicates how relevant the task is that a service solves. Current metrics for functional reusability of software, however, either require source code analysis or have very little explanatory power. This paper gives a formally described vision statement for the estimation of functional reusability of services and sketches an exemplary reusability metric that is based on the service descriptions.

Service recommendation facilitates developers to select services to create new mashups with large-granularity and added value. Currently, most studies concentrate on mining and recommending common composition patterns in mashups. However, latent negative patterns in mashups, which indicate the inappropriate combinations of services, remain largely ignored. By combining additional negative patterns between services with the already-exploited common mashup patterns, we present a more comprehensive and accurate model for service recommendation. Both positive association rules and negative ones are mined from services’ annotated tags to predict future mashups. The extensive experiment conducted on real-world data sets shows a 33% enhancement in terms of F1-Score compared to classic association mining approach.

Owing to the proliferation of web services, service oriented architecture (SOA) is widely acknowledged as an ideal paradigm for both enterprise applications and compute intensive scientific processes. In todays world, the present scenario of conducting business has found a new inclination towards the Mobile Device. Mobile devices, however, are constrained by battery power, processing capability, availability and network outages. Achieving service composition in such dynamic environment is challenging. In this paper, we propose a technique inspired by Electromagnetism in Physics to enact service choreography over mobile devices. The focus of the work is to minimize the waiting time and to balance load between services of a similar kind, thereby preserving battery power. The technique is validated through a real prototype. We prove the model minimized battery consumption and achieved a reduction in the waiting time.

Software adaptation techniques aim at generating new components called adapters, which make a set of services work correctly together by compensating for existing mismatch. Most approaches assume that services interact synchronously using rendez-vous communication. In this paper, we focus on asynchronous communication, where services interact exchanging messages via buffers. We overview a method for automatically generating adapters in such asynchronous environments.

Service mediation provides an effective way to integrate a service requester and a service provider, by reconciling the mismatches between the two. The techniques to assess the mediation degrees of services, to analyze irreconcilable mismatches, and to provide resolutions for irreconcilable behavioral mismatches are therefore essential. To address these challenges, we introduce in this paper two quantifiable metrics, called

service mediatability

and

modification complexity

, to evaluate the feasibility and complexity of mediating a requester and a service. We also propose a pattern-based approach for analyzing service behaviors that cannot be automatically mediated. We further offer resolutions for each irreconcilable mismatch pattern, which help developers to adjust and improve the service behaviors to fulfill the interaction requirements.

This paper proposes a novel model for evaluating cloud users’ credibility of providing subjective assessment or objective assessment for cloud services. In contrast to prior studies, cloud users in our model are divided into two classes, i.e., ordinary cloud consumers providing subjective assessments and professional testing parties providing objective assessments. By analyzing and comparing subjective assessments and objective assessments of cloud services, our proposed model can not only effectively evaluate the trustworthiness of cloud consumers and reputations of testing parties on how truthfully they assess cloud services, but also resist user collusion to some extent. The experimental results demonstrate that our model significantly outperforms existing work in both the evaluation of users’ credibility and the resistance of user collusion.

Cloud markets promise virtually unlimited resource supplies. Some providers set up distributed data centers at different geographical locations and jurisdictions and may not always be able to offer effectual physical capacity to serve large customers in one location. A solution is cloud collaborations, where multiple providers unite to conjointly offer capacities. Both Quality of Service and security properties of such collaborations will be determined by the “weakest link in the chain”, therefore resulting in a trade-off between monetary aggregates, cumulative capacity and non-functional attributes of a collaboration. Based on our previous research, we examine in our paper efficient composition of cloud collaborations from the broker’s perspective, considering Quality of Service and security requirements of cloud providers and users. We propose a Mixed Integer Programming-based heuristic approach CCCP-HEU.COM with deterministic and stochastic variants and provide its quantitative evaluation in comparison with our prior optimal approach.

Cloud computing has gained extremely rapid adoption in the recent years. In the complex computing environment of the cloud, automatically detecting application bottleneck points of multi-tier applications is practically a challenging problem. This is because multiple potential bottlenecks can co-exist in the system and affect each other while a management system reallocates resources. In this paper, we tackle this problem by developing a comprehensive capability profiling of such multi-tier applications. Based on the capability profiling, we develop techniques to identify the potential resource bottlenecks and recommend the additional required resources.

Service interactions account for major source of revenue and employment in many modern economies, and yet the service operations management process remains extremely complex. Ticket is the fundamental management entity in this process and resolution of tickets remains largely human intensive. A large portion of these human executed resolution tasks are repetitive in nature and can be automated. Ticket description analytics can be used to automatically identify the true category of the problem. This when combined with automated remediation actions considerably reduces the human effort. We look at monitoring data in a big provider’s domain and abstract out the repeatable tasks from the noisy and unstructured human-readable text in tickets. We present a novel approach for automatic problem determination from this noisy and unstructured text. The approach uses two distinct levels of analysis, (a) correlating different data sources to obtain a richer text followed by (b) context based classification of the correlated data. We report on accuracy and efficiency of our approach using real customer data.

IT Infrastructure Library (ITIL) has become the

de facto

standard for IT Service Management (ITSM). Despite the advantages in the adoption of ITIL’s best practices, some problems have been identified: different interpretations due to the complexity of concepts with poor specification and formalization; different approaches to the same problems; difficulties exchanging process models in different process model languages. Besides all published work, is still missing a metamodel expressing the core concepts, their relationship, and constraints. In this paper, we propose an ITIL metamodel to reduce conceptual and terminological ambiguity, addressing the identified problems, namely: (1) describing the core concepts of ITIL to be used by other approaches; (2) allowing the integration, exchange, sharing and reutilization of models; and (3) the use of different modelling languages following the defined principles.

A home care plan defines all the services provided for a given patient at his/her own home and permits the coordination of the involved health care professionals. In this paper, we present a DSL (Domain specific language) based approach tailored to express home care plans using high level and user-oriented abstractions. Then we describe how home care plans, formalized as timed automata, can be automatically generated from these abstractions. We finally show how verification and monitoring of the resulting care plan can be handled using existing techniques and tools.

In this paper we consider the problem of work order (WO) arrivals and time spent on work orders in service delivery to derive the asymptotic behavior of a strategic outsourcing contract. We model both the work order arrivals and time spent on the work orders, also known as effort, as a collective stochastic process. We use the resulting model to derive the probability that a contract will exceed the allocated budget for resolving work orders, and also to calculate the staffing requirement for resolving work orders.

Trustworthy service recommendation has become indispensable for the success of the service ecosystem. However, traditional trustworthy methods somehow overlook the service equality which result into a “rich-get-richer” effect and become a barrier for the novice services to startup and grow. This paper addresses this problem through a novel equitable trustworthy mechanism, which distinguished the difference between the novice and mature services over the trustworthy service recommendation. The results based on the real-world service ecosystem, i.e. ProgrammableWeb, show that our method achieves a better performance in equality guarantee and white-washing prevention. Thus it can promote the service ecosystem’s healthy growth in a fair manner.

Many techniques for addressing trust negotiation issues is little concerned with managing the dynamic evolution of trust negotiation protocols (policies), particularly in cases where there exist ongoing negotiations when a protocol has been changed. We propose an approach that automatically determines how consequences of changing a protocol affect ongoing negotiations. In particular, our approach allows to capture the semantics and intention of protocol changes, memorize and apply them in effectively analyzing the impact of protocol changes on negotiations.

Online social networks have been widely used for a large number of activities in recent years. Utilizing social network information to infer or predict trust among people to recommend services from trustworthy providers have drawn growing attention, especially in online environments. Conventional trust inference approaches predict trust between people along paths connecting them in social networks. However, most of the state-of-the-art trust prediction approaches do not consider the contextual information that influences trust and trust evaluation. In this paper, we first analyze the personal properties and interpersonal properties which impact trust transference between contexts. Then, a new trust transference method is proposed to predict the trust in a target context from that in different but relevant contexts. Next, a social context-aware trust prediction model based on matrix factorization is proposed to predict trust in various situations regardless of whether there is a path from a source participant to a target participant. To the best of our knowledge, this is the first context-aware trust prediction model in social networks in the literature. The experimental analysis illustrates that the proposed model can mitigate the sparsity situation in social networks and generate more reasonable trust results than the most recent state-of-the-art context-aware trust inference approach.

This paper studies the problem of checking the simulation preorder for data-centric services. It focuses more specifically on the underlying decidability and complexity issues in the framework of the Colombo model [1]. We show that the simulation test is

exptime

-complete for Colombo services without any access to the database (noted

Colombo

DB

 = ∅ 

) and

2exptime

-complete when only bounded databases are considered (the obtained model is noted

Colombo

bound

). This is a decidability border since we have shown in previous work that the simulation test for unbounded Colombo is undecidable. Moreover, as a side effect of this work, we establish a correspondance between

Colombo

DB

 = ∅ 

, restricted to equality, and Guarded Variable Automata (GVA) [2]. As a consequence, we derive EXPTIME-completeness of simulation for GVA.

Various approaches in service engineering are based on service markets where brokers use service matching in order to perform service discovery. For matching, a broker translates the specifications of providers’ services and requesters’ requirements into her own specification language, in order to check their compliance using a matcher. The broker’s success depends on the configuration of her language and its matcher because they influence important properties like the effort for providers and requesters to create suitable specifications as well as accuracy and runtime of matching. However, neither existing service specification languages, nor existing matching approaches are optimized in such way. Our approach automatically provides brokers with an optimal configuration of a language and its matcher to improve her success in a given market with respect to her strategy. The approach is based on formalized configuration properties and a predefined set of configuration rules.

This paper presents an approach that we have developed to support the design of secure service based applications in BPEL. The approach is based on the use of secure service composition patterns, which are proven to preserve composition level security properties if the services that are composed according to the pattern satisfy other properties individually. The secure service composition patterns are used for two purposes: (a) to analyse whether a given workflow fragment satisfies a given security property, and (b) to generate compositions of services that could substitute for individual services within the workflow that cause the violation of the security properties. Our approach has been implemented in a tool that is based on Eclipse BPEL Designer.

SLA management of non-computational services, such as transport and logistics services, may differ from SLA management of computational services, such as cloud or web services. As an important difference, SLA management for transport and logistics services has to consider so called frame SLAs. A frame SLA is a general agreement that constitutes a long-term contract between parties. The terms and conditions of the frame SLA become the governing terms and conditions for all specific SLAs established under such a frame SLA. Not considering the relationships between frame SLAs, specific SLAs and QoS monitoring information may lead to partial conclusions and decisions, thereby resulting in avoidable penalties. Based on a real industry case in the transport and logistics domain, this paper elaborates on a multi-level run-time SLA management approach for non-computational services that takes into account those relationships. We describe a cloud-based software component, the BizSLAM App, able to automatically manage multi-level SLAs by extending SLA management solutions from service-oriented computing. We demonstrate the feasibility and usefulness of the SLA management approach in an industrial context.

Enterprises have embraced Service Oriented Architecture (SOA) for years. With SOA, each business entity should be the Single Source of Truth (SSOT) of its data, and offer data services to other entities. Instead of sharing data through services, many business entities still share data through data replication. Replicating data causes inconsistencies and interoperability challenges. Even when there is a single authoritative source, that resolves inconsistencies, the data copies may end up being out-of-sync and cause errors. This paper describes how to use a SSOT service to eliminate data replication, enforce data autonomy, advocate data self-containment, and enhance data maintenance. Both mutable and immutable SSOT relationships (mappings) are considered. This paper describes the challenges, solutions, interactions and abstractions between the SSOT data service providers and the loosely coupled data consumers. It also assesses the performance and future usage of a SSOT service.

Rapid growth and consumption of REST APIs is generating new types of service marketplaces, which are dynamic and complex networks of providers and consumers. Existing models for software licenses and service standards, such as WDSL fall short of providing flexible frameworks for capturing the requirements that this newly created environment demands. Gaps exist in support for multi-pricing agreements across multiple providers and consumers, support for both usage and capacity events and automated generation and composition of licenses. Developers are accustomed to self-serve model, where they create and deploy new applications on the Cloud with a few mouse clicks, employing one or more available APIs. As a result, there is a need to be able to automatically assess existing licenses, compose new ones and understand their dependencies in order to shorten the time-to-value for new services. In this paper, we propose a model-driven approach for defining API service licenses, which provides capabilities to capture business and legal constraints, enable license metric calculation, QoS calculation and service pricing rules. We present API SLA analyzer system, which utilizes proposed license model to uncover SLA violations in real-time.