One of the most challenging issues of service-centric software engineering is the QoS-aware composition of services. The aim is to search for the optimal set of services that, composed to create a new service, result in the best QoS, under the user or service designer constraints. During service execution, re-planning such a composition may be needed whenever deviations from the QoS estimates occur. Both QoS-aware composition and re-planning may need to be performed in a short time, especially for interactive or real-time systems. This paper proposes a lightweight approach for QoS-aware service composition that uses genetic algorithms for the optimal QoS estimation. Also, the paper presents an algorithm for early triggering service re-planning if required re-planning is triggered as soon as possible during service execution. The performances of our approach are evaluated by means of numerical simulation.

Run-time service discovery and late-binding constitute some of the most challenging issues of service-oriented software engineering. For late-binding to be effective in the case of composite services, a QoS-aware composition mechanism is needed. This means determining the set of services that, once composed, not only will perform the required functionality, but also will best contribute to achieve the level of QoS promised in Service Level Agreements (SLAs). However, QoS-aware composition relies on estimated QoS values and workflow execution paths previously obtained using a monitoring mechanism. At run-time, the actual QoS values may deviate from the estimations, or the execution path may not be the one foreseen. These changes could increase the risk of breaking SLAs and obtaining a poor QoS. Such a risk could be avoided by replanning the service bindings of the workflow slice still to be executed.
This paper proposes an approach to trigger and perform composite service replanning during execution. An evaluation has been performed simulating execution and replanning on a set of composite service workflows.

Web services are rapidly changing the landscape of software engineering. One of the most interesting challenges introduced by web services is represented by Quality Of Service (QoS)-aware composition and late-binding. This allows to bind, at run-time, a service-oriented system with a set of services that, among those providing the required features, meet some non-functional constraints, and optimize criteria such as the overall cost or response time. In other words, QoS-aware composition can be modelled as an optimization problem.
We propose to adopt Genetic Algorithms to this aim. Genetic Algorithms, while being slower than integer programming, represent a more scalable choice, and are more suitable to handle generic QoS attributes. The paper describes our approach and its applicability, advantages and weaknesses, discussing results of some numerical simulations.

The introduction of the Semantic Web techniques in Service-oriented Architectures enables explicit representation and reasoning about semantically rich descriptions of service operations. Those techniques hold promise for the automated discovery, selection, composition and binding of services. This paper describes an approach to derive formal specifications of Web Service compositions on the basis of the interpretation of informal user requests expressed in (controlled) Natural Language. Our approach leverages the semantic and ontological description of a portfolio of known service operations (called Semantic Service Catalog). Each user request is processed against a Natural Language vocabulary that includes lexical constructs designed to convey the operations’ semantics, in order to recognize and extract fundamental functional requirements implied by the request, and associate them to entries in the Catalog. In addition, the request interpreter extracts the overall service logic in terms of a set of modular templates describing control and data flow among the selected operations. The result is a composition specification that associates on demand each user request to a new composed service; that specification is formal and can thus be transformed in an executable flow document for a target service composition engine.

Service-centric systems exist in a very dynamic environment, which requires these systems to adapt at runtime in order to keep fulfilling its QoS requirements to its users. In order to create self-adaptive service-centric systems, developers not only design the service architecture, but also need to design the self-adaptability aspects in a structured way. A key aspect in creating these self-adaptive service systems is the possibility of reasoning about runtime component variability properties, e.g. when and how to reconfigure the system. In this paper, we propose DySOA (Dynamic Service-Oriented Architecture), an architecture that extends service-centric applications to make them self-adaptive. DySOA allows developers to explicitly model the process and components that deal with determining the QoS of the running system, with evaluating the QoS, and with reconfiguring the system when necessary. Having the DySOA elements explicit enables separation of concerns, making the DySOA elements adaptable at runtime and reusable in next versions. We demonstrate the use of DySOA with an example.