@proceedings {zeus2017,
	title = {Proceedings of the 9th Central European Workshop on Services and their Composition (ZEUS 2017)},
	year = {2017},
	month = {February},
	publisher = {CEUR-WS.org},
	address = {Lugano, Switzerland},
	keywords = {Web service composition},
	url = {http://ceur-ws.org/Vol-1826/},
	author = {Oliver Kopp and J{\"o}rg Lenhard and Cesare Pautasso}
}
@conference {s:2012:ppopp,
	title = {S: a scripting language for high-performance RESTful web services},
	booktitle = {17th ACM SIGPLAN symposium on Principles and Practice of Parallel Programming (PPoPP 2012)},
	year = {2012},
	month = {February},
	pages = {97{\textendash}106},
	publisher = {ACM},
	organization = {ACM},
	address = {New Orleans, USA},
	abstract = {There is an urgent need for novel programming abstractions to leverage the parallelism in modern multicore machines. We introduce S, a new domain-specific language targeting the server-side scripting of high-performance RESTful Web services. S promotes an innovative programming model based on explicit (control-flow) and implicit (process-level) parallelism control, allowing the service developer to specify which portions of the control-flow should be executed in parallel. For each service, the choice of the best level of parallelism is left to the runtime system. We assess performance and scalability by implementing two non-trivial composite Web services in S. Experiments show that S-based Web services can handle thousands of concurrent client requests on a modern multicore machine.},
	keywords = {REST, scripting, Web service composition},
	isbn = {978-1-4503-1160-1},
	doi = {10.1145/2145816.2145829},
	author = {Daniele Bonetta and Achille Peternier and Cesare Pautasso and Walter Binder}
}
@conference {jopera:2010:soca,
	title = {Exploiting multicores to optimize business process execution},
	booktitle = {International Conference on Service-Oriented Computing and Applications (SOCA 2010)},
	year = {2010},
	month = {December},
	pages = {1-8},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Perth, Australia},
	abstract = {While modern CPUs offer an increasing number of cores with shared caches, prevailing execution engines for business processes, workflows, or Web service compositions have not been optimized for properly exploiting the abundant processing resources of such CPUs. One factor limiting performance is the inefficient thread scheduling by the operating system, which can result in suboptimal use of shared caches. In this paper we study performance of the JOpera business process execution engine on a recent multicore machine. By analyzing the engine{\textquoteright}s architecture and by binding threads that are likely to access shared data to cores with a common cache, we achieve speedups up to 13\% for a variety of workloads, without modifying the engine{\textquoteright}s architecture and implementation, apart from binding threads to CPUs. As the engine is implemented in Java, we provide a new Java library to manage thread bindings and hardware performance counters. We also leverage hardware performance counters to explain the observed speedup in our performance analysis.},
	keywords = {business data processing, business process execution engines, business process execution optimization, hardware performance counters, Java, JOpera, multicores, performance optimization, thread-CPU bindings, Web service composition, Web services, workflow},
	doi = {10.1109/SOCA.2010.5707156},
	author = {Achille Peternier and Daniele Bonetta and Cesare Pautasso and Walter Binder}
}
@conference {jopera:2010:apscc,
	title = {A Multicore-Aware Runtime Architecture for Scalable Service Composition},
	booktitle = {5th Asia-Pacific Services Computing Conference (APSCC 2010)},
	year = {2010},
	month = {December},
	pages = {83-90},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Hangzhou, China},
	abstract = {Middleware for web service orchestration, such as runtime engines for executing business processes, workflows, or web service compositions, can easily become performance bottlenecks when the number of concurrent service requests increases. Many existing process execution engines have been designed to address scalability with distribution and replication techniques. However, the advent of modern multicore machines, comprising several chip multi-processors each offering multiple cores and often featuring a large shared cache, offers the opportunity to redesign the architecture of process execution engines in order to take full advantage of the underlying hardware resources. In this paper we present an innovative process execution engine architecture. Its design takes into account the specific constraints of multicore machines and scales well on different processor architectures, as shown by our extensive performance evaluation. A key feature of the design is self-configuration at startup according to the type and number of available CPUs. We show that our design makes efficient use of the available resources and can scale to run thousands of concurrent business process instances per second, highlighting the potential and the benefits for multicore-awareness in the design of scalable process execution engines.},
	keywords = {middleware, multicore-aware runtime architecture, multicores, process execution engine, Web service composition, Web services},
	doi = {10.1109/APSCC.2010.61},
	author = {Daniele Bonetta and Achille Peternier and Cesare Pautasso and Walter Binder}
}
@inproceedings {1948635,
	title = {Towards scalable service composition on multicores},
	year = {2010},
	month = {October},
	pages = {655{\textendash}664},
	publisher = {Springer},
	address = {Crete},
	abstract = {The advent of modern multicore machines, comprising several chip multi-processors each offering multiple cores and often featuring a large shared cache, offers the opportunity to redesign the architecture of service composition engines in order to take full advantage of the underlying hardware resources. In this paper we introduce an innovative service composition engine architecture, which takes into account specific features of multicore machines while not being constrained to run on any particular processor architecture. Our preliminary performance evaluation results show that the system can scale to run thousands of concurrent business process instances per second.},
	keywords = {JOpera, multicore, Web service composition},
	isbn = {3-642-16960-0},
	doi = {10.1007/978-3-642-16961-8_90},
	author = {Daniele Bonetta and Achille Peternier and Cesare Pautasso and Walter Binder}
}
@conference {jopera:2009:sc,
	title = {Composing RESTful Services with JOpera},
	booktitle = {8th International Conference on Software Composition},
	volume = {5634},
	year = {2009},
	month = {July},
	pages = {142-159},
	publisher = {Springer},
	organization = {Springer},
	address = {Zurich, Switzerland},
	abstract = {The REST architectural style is emerging as an alternative technology platform for the realization of service-oriented architectures. In this paper, we apply the notion of composition to RESTful services and derive a set of language features that are required by composition languages for RESTful services: dynamic late binding, dynamic typing, content-type negotiation, state inspection, and compliance with the uniform interface principle. To show how such requirements can be satisfied by an existing composition language, we include a case-study using the JOpera visual composition language. In it, we present how to build a composite application (DoodleMap) out of some well-known, public and currently existing RESTful service APIs.},
	keywords = {JOpera, REST, Web service composition},
	doi = {10.1007/978-3-642-02655-3_11},
	author = {Cesare Pautasso}
}
@article {DBLP:journals/dke/Pautasso09,
	title = {RESTful Web service composition with BPEL for REST},
	journal = {Data Knowl. Eng.},
	volume = {68},
	number = {9},
	year = {2009},
	month = {September},
	pages = {851-866},
	abstract = {Current Web service technology is evolving towards a simpler approach to define Web service APIs that challenges the assumptions made by existing languages for Web service composition. RESTful Web services introduce a new kind of abstraction, the resource, which does not fit well with the message-oriented paradigm of the Web service description language (WSDL). RESTful Web services are thus hard to compose using the Business Process Execution Language (WS-BPEL), due to its tight coupling to WSDL. The goal of the BPEL for REST extensions presented in this paper is twofold. First, we aim to enable the composition of both RESTful Web services and traditional Web services from within the same process-oriented service composition language. Second, we show how to publish a BPEL process as a RESTful Web service, by exposing selected parts of its execution state using the REST interaction primitives. We include a detailed example on how BPEL for REST can be applied to orchestrate a RESTful e-Commerce scenario and discuss how the proposed extensions affect the architecture of a process execution engine. },
	keywords = {BPEL, REST, Web service composition},
	doi = {http://dx.doi.org/10.1016/j.datak.2009.02.016},
	author = {Cesare Pautasso}
}
@article {jopjauto07,
	title = {Autonomic resource provisioning for software business processes},
	journal = {Information and Software Technology},
	volume = {49},
	year = {2007},
	month = {January},
	pages = {65-80},
	abstract = {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 both to the actual number of clients and to the kinds of processes to be executed. The main contribution of the paper is to show how resource provisioning for software business processes can be solved using autonomic computing techniques. The engine separates execution in two stages (navigation and dispatching) and uses a controller to allocate the node of a cluster of computers to each one of those stages as the workload changes. The controller can be configured with different policies that define how to reconfigure the system. To prove the feasibility of the concept, we have implemented the autonomic controller and evaluated its performance with an extensive set of experiments.},
	keywords = {autonomic computing, distributed business process execution engines, service oriented architectures, Web service composition},
	doi = {10.1016/j.infsof.2006.08.010},
	author = {Cesare Pautasso and Thomas Heinis and Gustavo Alonso}
}
@conference {jopera:2006:scc,
	title = {Control the Flow: How to Safely Compose Streaming Services into Business Processes},
	booktitle = {2006 IEEE International Conference on Services Computing},
	year = {2006},
	pages = {206 - 213},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Chicago, USA},
	abstract = {Although workflow languages are widely used for composing discrete services, these are not suitable for stream based interactions. In this paper we address the problem of how to extend a conventional Web service composition language with the ability to deal with data streaming services. The paper discusses several modeling alternatives and presents a marker based semantics for safely dealing with pipelined processing in service compositions. The paper also presents application examples that illustrate the advantages of the proposed approach},
	keywords = {JOpera, streaming, Web service composition},
	doi = {10.1109/SCC.2006.38},
	author = {Bi{\"o}rn Bi{\"o}rnstad and Cesare Pautasso and Gustavo Alonso}
}
@article {117,
	title = {JOpera: Autonomic Service Orchestration},
	journal = {IEEE Data Engineering Bulletin},
	volume = {29},
	year = {2006},
	month = {September},
	pages = {32-39},
	keywords = {autonomic computing, JOpera, Web service composition},
	url = {ftp://ftp.research.microsoft.com/pub/debull/A06sept/issue1.htm},
	author = {Cesare Pautasso and Thomas Heinis and Gustavo Alonso}
}
@conference {jopera:2005:icws,
	title = {Autonomic Execution of Service Compositions},
	booktitle = {3rd International Conference on Web Services (ICWS 2005)},
	year = {2005},
	month = {July},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Orlando, Florida},
	abstract = {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.},
	keywords = {autonomic computing, JOpera, Web service composition},
	doi = {10.1109/ICWS.2005.28},
	author = {Cesare Pautasso and Thomas Heinis and Gustavo Alonso}
}
@conference {jopera:2005:icac,
	title = {Design and Evaluation of an Autonomic Workflow Engine},
	booktitle = {2nd International Conference on Autonomic Computing (ICAC-05)},
	year = {2005},
	month = {June},
	pages = {27 - 38},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Seattle, Washington},
	abstract = {In this paper we present the design and evaluate the performance of an autonomic workflow execution engine. Although there exist many distributed workflow engines, in practice, it remains a difficult problem to deploy such systems in an optimal configuration. Furthermore, when facing an unpredictable workload with high variability, manual reconfiguration is not an option. Thanks to its autonomic controller, the engine features self-configuration, self-tuning and self-healing properties. The engine runs on a cluster of computers using a tuple space to coordinate its various components. Its autonomic controller monitors its performance and responds to workload variations by altering the configuration. In case failures occur, the controller can recover the workflow execution state from persistent storage and migrate it to a different node of the cluster. Such interventions are carried out without any human supervision. As part of the results of our performance evaluation, we compare different autonomic control strategies and discuss how they can automatically tune the system},
	keywords = {automatic configuration, autonomic computing, JOpera, Web service composition},
	doi = {10.1109/ICAC.2005.21},
	author = {Thomas Heinis and Cesare Pautasso and Gustavo Alonso}
}
@inproceedings {jopera:2005:sc,
	title = {Flexible Binding for Reusable Composition of Web Services},
	year = {2005},
	month = {April},
	pages = {151-166},
	publisher = {Springer},
	address = {Edinburg, Scotland},
	abstract = {In addition to publishing composite services as reusable services, compositions can also be reused by applying them to orchestrate different component services. To do so, it is important to describe compositions using flexible bindings, which define only the minimal constraints on the syntax and semantics of the services to be composed. This way, the choice of which service to invoke can be delayed to later stages in the life cycle of the composition. In the context of Web service composition, we refine the concept of binding beyond the basic distinction of static and dynamic binding. Bindings can be evaluated during the design, the compilation, the deployment, the beginning of the execution of a composition, or just before the actual service invocation takes place. Considering the current limited support of dynamic binding in the BPEL service composition language, we show how we addressed the problem in JOpera, where modeling bindings does not require a specific language construct as it can be considered a special application of reflection.},
	keywords = {dynamic binding, JOpera, Web service composition},
	doi = {10.1007/11550679_12},
	author = {Cesare Pautasso and Gustavo Alonso}
}
@article {106,
	title = {The JOpera visual composition language},
	journal = {J. Vis. Lang. Comput.},
	volume = {16},
	year = {2005},
	month = {February},
	pages = {119{\textendash}152},
	abstract = {Composing Web services into a coherent application can be a tedious and error-prone task when using traditional textual scripting languages or emerging XML-based approaches. As an alternative, complex interactions patterns and data exchanges between different Web services can be effectively modeled using a visual language. In this paper, we discuss the requirements of such an application scenario and we fully describe the JOpera Visual Composition Language. An extensive set of visual editing tools, a compiler and a debugger for the language have been implemented as part of the JOpera system with the goal of providing a true visual environment for Web service composition with usability features emphasizing rapid development and visual scalability. },
	keywords = {data flow, JOpera, visual composition languages, Web service composition, Web services},
	issn = {1045-926X},
	doi = {10.1016/j.jvlc.2004.08.004},
	author = {Cesare Pautasso and Gustavo Alonso}
}
@phdthesis {97,
	title = {A Flexible System for Visual Service Composition},
	volume = {PhD},
	year = {2004},
	school = {ETH Zurich, Computer Science Department},
	type = {PhD Thesis},
	abstract = {This dissertation brings together ideas of different research areas. First of all, we propose the application of visual languages to service composition. In order to connect basic services of various kinds into a larger system, their interactions along the time dimension are defined with the JOpera Visual Composition Language. As opposed to the textual or XML-based syntax of existing approaches, our language features a very simple graphical notation. This visual syntax is used to specify the data flow and control flow graphs linking the various service invocations. This way, it becomes possible to rapidly build distributed applications out of a set of reusable services by literally drawing the interactions between them. To achieve this, we present how usability features such as automatic, incremental graph layout and visual scalability features such as multiple views have been driving the design of JOpera{\textquoteright}s visual service composition environment. To provide support for realistic application scenarios, we have also included recursion, iteration and reflection constructs with minimal changes to the syntax of the visual language. Supported by the JOpera system, our visual language for service composition has been applied to many scenarios, as documented by the examples shown throughout the dissertation. Underneath the visual syntax, our approach to modeling service composition is based on the concept of process. In this dissertation we borrow the notion of business process so that it can be extended to model service oriented architectures. Thus, the structure of a process defines the partial order of invocation of its services, the data exchanges between them and the necessary failure handling behavior. In this context, an important contribution of this dissertation is the idea that a composition language should be orthogonal with respect to the types of components that are employed. More precisely, in our approach, composition is defined at the level of service interfaces. Therefore, a process is completely independent from the mechanisms and protocols used to access the implementation of its services. In other words, we introduce a composition language which is not limited to describing how components of a specific type (e.g., Web services) should be composed. Instead, in our open component meta-model, we generalize the notion of service by abstracting common features among a large set of different component types. This abstraction has several important implications. By supporting a large and open set of types of services, the composition language is simplified because many constructs (e.g., modeling synchronous or asynchronous service invocation) can be shifted from the composition language to the component meta-model. Also, the service composer is free to choose the most appropriate mechanism to access the functionality of an existing service. Thus, the runtime overhead of a service invocation can be minimized as it becomes possible to choose the most effcient access mechanism. This optimization regarding the service access mechanism would not make much of a difference regarding the overall system{\textquoteright}s performance if the execution of the visual language would incur in a high overhead, as typically process-based languages are executed by an interpreter. On the contrary, in this dissertation we propose to compile the visual specification of a process into executable code. One of the challenges of doing so is that the resulting code should still support the concurrent execution of multiple process instances. The choice of applying compilation to the execution of processes brings the following benefits. In addition to the potential for providing better performance through the optimization of the generated code, compiling processes also helps to simplify the design of the corresponding runtime system. As opposed to having a full-blown process interpreter, it is enough to design and build a flexible container of compiled processes. Following this approach, in the last part of the dissertation we present the design of a flexible architecture for a process support system. Flexibility is an important aspect of our design which, according to our experimental results, does not contradict the goal of building an efficient system. First, flexibility enables JOpera to support heterogeneous types of services. To do so, plug-ins are used to map the invocation of a service to the corresponding protocol in the most effcient manner. Second, the flexible architecture of JOpera{\textquoteright}s kernel can be deployed in a variety of configurations. This way, costly features such as reliable process execution can be added only if they are truly needed. Likewise, the system shows good scalability when deployed in a cluster-based configuration, as large workloads are shared among multiple cluster nodes. Thanks to a wise choice of architectural abstractions, the code generated by the compiler is kept independent of the actual configuration of the kernel into which it is loaded. Third, flexibility is also a fundamental property for an autonomic system, where the optimal configuration is determined automatically at runtime.},
	keywords = {JOpera, visual service composition, Web service composition},
	doi = {10.3929/ethz-a-004860667},
	url = {https://www.research-collection.ethz.ch/handle/20.500.11850/72796},
	author = {Cesare Pautasso}
}
@article {96,
	title = {JOpera: a Toolkit for Efficient Visual Composition of Web Services},
	journal = {International Journal of Electronic Commerce (IJEC)},
	volume = {9},
	year = {2004},
	month = {Winter 2004/2005},
	pages = {107-141},
	abstract = {Web services are attracting attention because of their ability to provide standard interfaces to heterogeneous distributed services. Standard interfaces make it possible to compose more complex services out of basic ones. This paper tackles the problem of visual service composition and the efficient and scalable execution of the resulting composite services. The effort revolves around the JOpera system, which combines a visual programming environment for Web services with a flexible execution engine that interacts with Web services through the simple object access protocol (SOAP), described with Web services language description (WSDL) and registered with a universal description discovery and integration (UDDI) registry. The paper explains the syntax and implementation of the JOpera Visual Composition Language (JVCL) and its ability to provide different quality of service (QoS) levels in the execution of composite services. },
	keywords = {JOpera, Scalable Process Execution, visual languages, Web service composition},
	issn = {1086-4415 },
	url = {http://www.ijec-web.org/past-issues/volume-9-number-2-winter-2004-05/ijecv9n2-6/},
	author = {Cesare Pautasso and Gustavo Alonso}
}
@conference {94,
	title = {Visual composition of Web services},
	booktitle = {IEEE Symposium on Human Centric Computing Languages and Environments (HCC 2003)},
	year = {2003},
	month = {October},
	pages = {92 - 99},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Auckland, New Zealand},
	abstract = {Composing Web services into a coherent application can be a tedious and error prone task when using traditional textual scripting languages. As an alternative, complex interactions patterns and data exchanges between different Web services can be effectively modeled using a visual language. In this paper we discuss the requirements of such an application scenario and we present the design of the BioOpera Flow Language. This visual composition language has been fully implemented in a development environment for Web service composition with usability features emphasizing rapid development and visual scalability.},
	keywords = {JOpera, visual languages, visual service composition, Web service composition, Web services},
	doi = {10.1109/HCC.2003.1260208},
	url = {http://ieeexplore.ieee.org/lpdocs/epic03/wrapper.htm?arnumber=1260208},
	author = {Cesare Pautasso and Gustavo Alonso}
}
