Availability of a wide variety of Web services over the Internet offers opportunities of providing new value added services built by composing them out of existing ones. Service composition poses a number of challenges. A composite service can be very complex in structure, containing many temporal and data-flow dependencies between their constituent services. Furthermore, each individual service is likely to have its own sequencing constraints over its operations. It is highly desirable therefore to be able to validate that a given composite service is well formed: proving that it will not deadlock or livelock and that it respects the sequencing constraints of the constituent services. With this aim in mind, the paper proposes simple extensions to web service definition language (WSDL) enabling the order in which the exposed operations should be invoked to be specified. In addition, the paper proposes a composition language for defining the structure of a composite service. Both languages have an XML notation and a formal basis in the pi-calculus (a calculus for concurrent systems). The paper presents the main features of these languages, and shows how it is possible to validate a composite service by applying the pi-calculus reaction rules.

Software development nowadays involves several levels of abstraction: starting from the programming of single objects, to their combination into components, to their publication as services and the overall architecture linking elements at each level. As a result, software engineering is dealing with a wider range of artifacts and concepts (i.e., in the context of this paper: services and business processes) than ever before. In this paper we explore the importance of having an adequate engine for executing business processes written as compositions of Web services. The paper shows that, independently of the composition language used, the overall scalability of the system is determined by how the run time engine treats the process execution. This is particularly relevant at the service level because publishing a process through a Web service interface makes it accessible to an unpredictable and potentially very large number of clients. As a consequence, the process developer is confronted with the difficult question of resource provisioning. Determining the optimal configuration of the distributed engine that runs the process becomes sensitive

An increasing amount of Web services are being implemented using process management tools and languages (BPML, BPEL, etc.). The main advantage of processes is that designers can express complex business conversations at a high level of abstraction, even reusing standardized business protocols. The downside is that the infrastructure behind the Web service becomes more complex. This is particularly critical for Web services that may be subjected to high variability in demand and suffer from unpredictable peaks of heavy load. In this paper we present a flexible architecture for process execution that has been designed to support autonomic scalability. The system runs on a cluster of computers and reacts to workload variations by altering its configuration in order to optimally use the available resources. Such changes happen automatically and without any human intervention. This feature completely removes the need for the manual monitoring and reconfiguration of the system, which in practice is a difficult and time-consuming operation. In the paper we describe the architecture of the system and present an extensive performance evaluation of its autonomic capabilities. 1

Abstract not found

This chapter is concerned with the issue of knowledge representation for AI Planning problems, especially those related to Semantic Web Service composition. It discusses current approaches in encoding planning problems using the PDDL formal language and it presents ViTAPlan, a user-friendly visual tool for planning. The tool is built on top of HAPRC, a rule-configurable planning system, which automatically adapts to each problem, in order to achieve best performance. Apart from HAPRC, ViTAPlan can be interfaced with any other planning system that supports the PDDL language. More than just being a user friendly environment for executing the underlying planner, the tool serves as a unified planning environment for encoding a new problem, solving it, visualizing the solution and monitoring its execution on a simulation of the problem’s world. The tool consists of various sub-systems, each one accompanied by a graphical interface, which collaborate with each other and assist the user, either a knowledge engineer, a domain expert, an academic or even an end-user in industry, to carry out complex planning tasks, such as composing complex Semantic Web Services from simple ones, in order to achieve complex tasks. The key feature of ViTAPlan is a visual programming module that enables the user to encode new planning problems just by using visual elements and simple mouse operations. The visual tool performs a validity check on the visual program created by the user 1 and then compiles it to PDDL files that are ready to be used by any planning system. Finally, the planning system will solve the planning problem and then export the plan in an appropriate Web Service composition language to a Web Service execution monitoring system or just publish it in a UDDI registry.

Thanks to the interoperability offered by Web services standards it is now possible to build large scale distributed software systems by composing reusable services published on the Web. In this presentation we will demonstrate how we combined Eclipse’s user experience (background model checking and incremental recompilation) with a simple visual composition language to develop the JOpera for Eclipse plugins [1]. With them, it is not required to work with XML-based languages when composing many kinds of different services because their interactions can be specified by literally drawing them in a data and control flow graph. The visual representation is then directly compiled to Java code in order to be executed efficiently. A visual monitor and debugger are also included, so that it is possible to interactively watch the progress of the composition as it runs at the same level of abstraction and with the same visual syntax used to define it. Web services offer a standards-based approach to address many interoperability issues arising when composing distributed software systems out of reusable services. Thanks to the SOAP protocol and WSDL interface description language, an increasingly large number of basic services are being published on the Internet. Clearly, it becomes important to find the right composition abstractions

Abstract. In the following article we provide our experience with the creation of the Swiss National Grid Association (SwiNG) as well as the establishment of a nation-wide Grid infrastructure based on the ARC Grid middleware. Although not yet fully in production, we already have several scientific user communities in different domains (high energy physics, snow and avalanche related physics, biochemistry, bioinformatics and computer security). 1.

Web Services technology is becoming the de-facto standard for integration of legacy applications within an organisation and for cross organisation enterprise application integration (B2BEAI). Much work has gone into specifying Web Services functionality using workflow like techniques (BPEL4WS, WSCI, WSFL, XLANG) and production of software to enact such descriptions. However, most of this software relies on one central server to enact the workflow which may be a performance bottleneck when the server is under high load. In this paper we outline a workflow specification language and present a sample implementation of a workflow engine which allows distributed enactment of workflows. Distributed enactment removes this potential bottleneck and can also reduce data transfer. We also describe how the workflow engine promotes message based integration, simplifying the problem of application integration across organisational boundaries. 1.

Web Services technology is becoming the de-facto standard for integration of legacy applications within an organisation and for cross organisation enterprise application integration. Much work has gone into specifying Web Services functionality using workflow like techniques and production of software to enact such descriptions. However, most of this software relies on one central server to enact the workflow. Centralised enactment may be unattractive in inter-organisational settings and in addition, form a performance bottleneck when the server is under high load. In this paper we outline the DECS task model for workflow specification and present a prototype implementation of a distributed enactment engine based on J2EE middleware. There is a separation of concerns between the specification of the workflow and its enactment, allowing it to be deployed in a number of configurations based on performance considerations and organisational requirements. We also describe how the workflow engine promotes message based integration, simplifying the problem of application integration across organisational boundaries. 1