@article {2019:rest:sawq, title = {SAW-Q: a dynamic composition approach of REST services based on queue model}, journal = {International Journal of Web and Grid Services}, volume = {15}, year = {2019}, month = {January}, pages = {29 - 58}, abstract = {Service composition is one of the principles of service-oriented architecture; it enables reuse and allows developers to combine existing services in order to create new services that in turn can be part of another composition. Dynamic composition requires that service components are chosen from a set of services with equal or similar functionality at runtime and possibly automatically. The adoption of the REST services in the industry has led to a growing number of services of this type, many with similar functionality. The existing dynamic composition techniques are method-oriented whereas REST is resource-oriented and consider only traditional (WSDL/SOAP) services. We propose SAW-Q, an extension of simple additive weighting (SAW), as a novel dynamic composition technique that follows the principles of the REST style. Additionally, SAW-Q models quality attributes as a function of the actual service demand instead of the traditional constant values. Our model is much more accurate when compared to real implementation, positively improving the quality of dynamic service compositions.}, keywords = {automatic composition, dynamic composition, quality of service, REST, SOA, Web services}, doi = {10.1504/IJWGS.2019.096555}, author = {Bellido, Jesus and Rosa Alarc{\'o}n and Cesare Pautasso and Carla Vairetti} } @article {rest:tweb:2013, title = {Control-Flow Patterns for Decentralized RESTful Service Composition}, journal = {ACM Transactions on the Web (TWEB)}, volume = {8}, year = {2013}, month = {December}, pages = {5:1{\textendash}5:30}, abstract = {The REST architectural style has attracted a lot of interest from industry due to the nonfunctional properties it contributes to Web-based solutions. SOAP/WSDL-based services, on the other hand, provide tools and methodologies that allow the design and development of software supporting complex service arrangements, enabling complex business processes which make use of well-known control-flow patterns. It is not clear if and how such patterns should be modeled, considering RESTful Web services that comply with the statelessness, uniform interface and hypermedia constraints. In this article, we analyze a set of fundamental control-flow patterns in the context of stateless compositions of RESTful services. We propose a means of enabling their implementation using the HTTP protocol and discuss the impact of our design choices according to key REST architectural principles. We hope to shed new light on the design of basic building blocks for RESTful business processes.}, keywords = {business process management, control flow, control-flow patterns, REST, service composition, Web services}, issn = {1559-1131}, doi = {10.1145/2535911}, url = {http://doi.acm.org/10.1145/2535911}, author = {Bellido, Jesus and Rosa Alarc{\'o}n and Cesare Pautasso} } @inbook {pautasso2013rest, title = {RESTful Web Services: Principles, Patterns and Emerging Technologies}, booktitle = {Web Services Foundations}, year = {2013}, pages = {31-51}, publisher = {Springer}, organization = {Springer}, abstract = {RESTful Web services are software services which are published on the Web, taking full advantage and making correct use of the HTTP protocol. This chapter gives an introduction to the REST architectural style and how it can be used to design Web service APIs. We summarize the main design constraints of the REST architectural style and discuss how they impact the design of so-called RESTful Web service APIs. We give examples on how the Web can be seen as a novel kind of software connector, which enables the coordination of distributed, stateful and autonomous software services. We conclude the chapter with a critical overview of a set of emerging technologies which can be used to support the development and operation of RESTful Web services. }, keywords = {REST, Web services}, isbn = {978-1-4614-7517-0}, doi = {10.1007/978-1-4614-7518-7_2}, url = {http://www.springer.com/computer/database+management+\%26+information+retrieval/book/978-1-4614-7517-0}, author = {Cesare Pautasso} } @book {soawithrest:2013, title = {SOA with REST - Principles, Patterns and Constraints for Building Enterprise Solutions with REST}, series = {The Prentice Hall service technology series}, year = {2013}, pages = {I-XXXII, 1-577}, publisher = {Prentice Hall}, organization = {Prentice Hall}, keywords = {REST, service oriented architectures, Web services}, isbn = {978-0-13-701251-0}, author = {Thomas Erl and Benjamin Carlyle and Cesare Pautasso and Raj Balasubramanian} } @conference {bonetta2012EuroPar, title = {Node.Scala: Implicit Parallel Programming for High-Performance Web Services}, booktitle = {International European Conference on Parallel and Distributed Computing (EuroPar 2012)}, volume = {7484}, year = {2012}, month = {August}, pages = {626{\textendash}637}, publisher = {Springer}, organization = {Springer}, address = {Rhodes Island, Greece}, keywords = {Node.JS, REST, Scala, scalability, Web services}, isbn = {978-3-642-32819-0}, url = {http://sosoa.inf.unisi.ch/files/sosoa_europar2012.pdf}, author = {Daniele Bonetta and Danilo Ansaloni and Achille Peternier and Cesare Pautasso and Walter Binder} } @article {DBLP:journals/internet/VitvarVP12, title = {Programmatic Interfaces for Web Applications}, journal = {IEEE Internet Computing}, volume = {16}, number = {4}, year = {2012}, pages = {11-14}, keywords = {programmable web, REST, Web APIs, Web services}, doi = {http://doi.ieeecomputersociety.org/10.1109/MIC.2012.86}, author = {Tomas Vitvar and Steve Vinoski and Cesare Pautasso} } @conference {6227125, title = {Specification patterns from research to industry: A case study in service-based applications}, booktitle = {Proc. of the 34th International Conference on Software Engineering (ICSE2012), SeIP track}, year = {2012}, month = {June}, pages = {968-976}, address = {Zurich, Switzerland}, abstract = {Specification patterns have proven to help developers to state precise system requirements, as well as formalize them by means of dedicated specification languages. Most of the past work has focused its applicability area to the specification of concurrent and real-time systems, and has been limited to a research setting. In this paper we present the results of our study on specification patterns for service-based applications (SBAs). The study focuses on industrial SBAs in the banking domain. We started by performing an extensive analysis of the usage of specification patterns in published research case studies - representing almost ten years of research in the area of specification, verification, and validation of SBAs. We then compared these patterns with a large body of specifications written by our industrial partner over a similar time period. The paper discusses the outcome of this comparison, indicating that some needs of the industry, especially in the area of requirements specification languages, are not fully met by current software engineering research.}, keywords = {banking case study, formal specification, industry research, pattern matching, real-time systems, requirements specifications, service contracts, software engineering, specification patterns, Web services}, issn = {0270-5257}, doi = {10.1109/ICSE.2012.6227125}, author = {Domenico Bianculli and Carlo Ghezzi and Cesare Pautasso and Patrick Senti} } @proceedings {ecows2011, title = {9th IEEE European Conference on Web Services (ECOWS 2011)}, year = {2011}, month = {September}, publisher = {IEEE}, address = {Lugano, Switzerland}, keywords = {proceedings, Web services}, isbn = {978-1-4577-1532-7}, url = {http://ieeexplore.ieee.org/xpl/mostRecentIssue.jsp?punumber=6059529}, editor = {Gianluigi Zavattaro and Ulf Schreier and Cesare Pautasso} } @conference {5959776, title = {An Architectural Style for Liquid Web Services}, booktitle = {9th Working IEEE/IFIP Conference on Software Architecture (WICSA 2011)}, year = {2011}, month = {June}, pages = {232-241}, address = {Boulder, CO, USA}, abstract = {Just as liquids adapt their shape to the one of their container, liquid architectures feature a high degree of adaptability so that they can provide scalability to applications as they are executed on a wide variety of heterogeneous deployment environments. In this paper we enumerate the properties to be guaranteed by so-called liquid service-oriented architectures and define a set of design constraints that make up a novel architectural style for liquid architectures. These constraints drive the careful construction of a pattern, the Restful Actor (Reactor), which enables to deliver the required scalability by means of replication of its constituent parts. Reactors feature a Restful Web service interface and a composable architecture which is capable of delivering scalability and high performance in a way that is independent from the chosen deployment infrastructure. We discuss how the Reactor can be deployed to run on distributed (shared-nothing) execution environments typical of virtualized Cloud computing environments as well as on modern multicore processors with shared memory architectures.}, keywords = {architectural styles, cloud computing, design constraints, liquid service oriented architectures, liquid Web services, multicores, patterns, performance, REST, RESTful actor, RESTful Web service interface, scalability, shared memory architectures, virtualized cloud computing environments, Web services}, doi = {10.1109/WICSA.2011.38}, author = {Daniele Bonetta and Cesare Pautasso} } @inproceedings {sosoa:2011, title = {Towards Self-Organizing Service-Oriented Architectures}, year = {2011}, month = {July}, pages = {115-121}, publisher = {IEEE}, address = {Washington, DC, USA}, abstract = {Service-oriented architectures (SOAs) provide a successful model for structuring complex distributed software systems, as they reduce the cost of ownership and ease the creation of new applications by composing existing services. However, currently, the development of service-oriented applications requires many manual tasks and prevailing infrastructure is often based on centralized components that are central points of failure and easily become bottlenecks. In this paper, we promote self-organizing SOA as a new approach to overcome these limitations. Self-organizing SOA integrates research results in the areas of autonomic and service oriented computing. We consider self-organizing features for the whole life-cycle of a service-oriented application, from the creation to the execution, optimization, and monitoring.}, keywords = {autonomic computing, monitoring, self-organizing service-oriented architecture, service composition, service oriented computing, Web services}, doi = {10.1109/SERVICES.2011.44}, author = {Walter Binder and Daniele Bonetta and Cesare Pautasso and Achille Peternier and Diego Milano and Heiko Schuldt and Nenad Stojnic and Boi Faltings and Immanuel Trummer} } @proceedings {ecows2010, title = {8th IEEE European Conference on Web Services (ECOWS 2010)}, year = {2010}, month = {December}, publisher = {IEEE}, address = {Ayia Napa, Cyprus}, keywords = {proceedings, Web services}, isbn = {978-1-4244-9397-5}, url = {http://ieeexplore.ieee.org/xpl/mostRecentIssue.jsp?punumber=5691022}, editor = {Antonio Brogi and Cesare Pautasso and George Angelos Papadopoulos} } @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} } @book {wewst:2008, title = {Emerging Web Services Technology}, volume = {2}, year = {2008}, pages = {185}, publisher = {Birkh{\"a}user}, organization = {Birkh{\"a}user}, abstract = {This book contains a collection of selected and revised papers originally presented at the Workshop on Emerging Web Service Technology (WEWST{\textquoteright}07) held in conjunction with the 5th European Conference on Web Services (ECOWS{\textquoteright}07) in November 2007 in Halle (Saale), Germany. Acting as the natural extension to the main ECOWS conference, the main goal of the WEWST workshop is serving as a forum for providing early exposure and much needed feedback to grow and establish original and emerging ideas within the Web Services community. The wide variety of tools, techniques and technological solutions presented in WEWST share one common feature: they advance the current Web services research in new directions by introducing new and sometimes controversial ideas into the field.}, keywords = {Web services}, isbn = {978-3-7643-8864-5}, url = {http://www.springer.com/birkhauser/computer+science/book/978-3-7643-8863-8}, editor = {Thomas Gschwind and Cesare Pautasso} } @conference {www08restsoap, title = {RESTful Web Services vs. Big Web Services: Making the Right Architectural Decision}, booktitle = {17th World Wide Web Conference (WWW 2008)}, year = {2008}, month = {April}, pages = {805-814}, publisher = {ACM}, organization = {ACM}, address = {Beijing, China}, abstract = {Recent technology trends in the Web Services (WS) domain indicate that a solution eliminating the presumed complexity of the WS-* standards may be in sight: advocates of REpresentational State Transfer (REST) have come to believe that their ideas explaining why the World Wide Web works are just as applicable to solve enterprise application integration problems and to simplify the plumbing required to build service-oriented architectures. In this paper we objectify the WS-* vs. REST debate by giving a quantitative technical comparison based on architectural principles and decisions. We show that the two approaches differ in the number of architectural decisions that must be made and in the number of available alternatives. This discrepancy between freedom-from-choice and freedom-of-choice explains the complexity difference perceived. However, we also show that there are significant differences in the consequences of certain decisions in terms of resulting development and maintenance costs. Our comparison helps technical decision makers to assess the two integration styles and technologies more objectively and select the one that best fits their needs: REST is well suited for basic, ad hoc integration scenarios, WS-* is more flexible and addresses advanced quality of service requirements commonly occurring in enterprise computing. }, keywords = {architectural decisions, REST, SOAP, Web services}, doi = {10.1145/1367497.1367606}, author = {Cesare Pautasso and Olaf Zimmermann and Frank Leymann} } @book {wewst:2007, title = {Emerging Web Services Technology}, volume = {1}, year = {2007}, pages = {182}, publisher = {Birkh{\"a}user}, organization = {Birkh{\"a}user}, keywords = {Web services}, isbn = {978-3-7643-8448-7}, url = {http://www.springer.com/birkhauser/computer+science/book/978-3-7643-8447-0}, editor = {Cesare Pautasso and Christoph Bussler} } @article {115, title = {Enforcing Web Services Business Protocols at Run-Time: a Process Driven Approach}, journal = {International Journal of Web Engineering and Technology (IJWET)}, volume = {2}, year = {2006}, pages = {396-411}, abstract = {Business processes provide abstractions for modelling business protocols that define the correct interactions between two or more Web services (WS). It has been shown that it is possible to automatically derive role-specific processes from a global protocol definition and also statically verify the compliance of a local process with the corresponding global business process. In this paper, we show that a similar approach can be used at run-time. We propose to employ process-based tools to enforce that the messages exchanged between different WS comply with a given business protocol, both in terms of sequencing constraints and data flow characteristics. Our solution simplifies the implementation of WS because it helps to separate the concern of business protocol compliance from the actual service implementation. To do so, we show how to transparently add a protocol enforcement layer to the WS messaging stack. Our experimental results indicate that this imposes a minimal overhead.}, keywords = {business process modeling, business protocols, choreography, conversation controller, data flow, JOpera, Web services}, issn = {1476-1289}, doi = {10.1504/IJWET.2006.010422}, url = {http://www.inderscience.com/info/inarticle.php?artid=10422}, author = {Bi{\"o}rn Bi{\"o}rnstad and 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} } @inproceedings {95, title = {From Web Service Composition to Megaprogramming}, volume = {3324}, year = {2004}, month = {August}, pages = {39 - 53}, publisher = {Springer}, address = {Toronto, Canada}, abstract = {With the emergence of Web service technologies, it has become possible to use high level megaprogramming models and visual tools to easily build distributed systems using Web services as reusable components. However, when attempting to apply the Web service composition paradigm in practical settings, some limitations become apparent. First of all, all kinds of existing {\textquotedblleft}legacy{\textquotedblright} components must be wrapped as Web services, incurring in additional development, maintenance, and unnecessary runtime overheads. Second, current implementations of Web service protocols guarantee interoperability at high runtime costs, which justifies the composition of only coarse-grained Web services. To address these limitations and support the composition of also fine-grained services, in this paper we generalize the notion of service by introducing an open service meta-model. This offers freedom of choice between different types of services, which also include, but are not limited to, Web services. As a consequence, we argue that service composition {\textendash} defined at the level of service interfaces {\textendash} should be orthogonal from the mechanisms and the protocols which are used to access the actual service implementations.}, keywords = {heterogeneity, JOpera, megaprogramming, Web services}, isbn = {978-3-540-25049-4}, doi = {10.1007/b10662610.1007/978-3-540-31811-8_4}, author = {Cesare Pautasso and Gustavo Alonso} } @conference {93, title = {Programming for dependability in a service-based grid}, booktitle = {3rd IEEE/ACM International Symposium on Cluster Computing and the Grid, 2003 (CCGrid 2003)}, year = {2003}, month = {May}, pages = {164 - 171}, publisher = {IEEE}, organization = {IEEE}, address = {Tokyo, Japan}, abstract = {Service-based Grid infrastructures emphasize service composition rather than sharing of low level resources. The idea is to build Grid applications out of computational services provided by the different sites of the Grid. Recent developments in the area of Web services have strengthened this idea by standardizing procedures like service description, publication and invocation. What is still missing is the infrastructure necessary to support the complete life cycle of applications running on service based Grids, i.e., suitable programming paradigms, execution infrastructure, and the ability to monitor and control such computations. Moreover, once computations are made of composable services, dependability becomes a key issue that needs to be addressed by the infrastructure as it cannot be addressed separately by each individual service. To address these concerns, we have developed the BioOpera Grid computing platform. BioOpera is a process support system for dependable cluster computing that has been extended with additional functionality to provide adequate support for service-based Grids. In this paper we describe how BioOpera can be used to develop, execute, and administer highly dependable computations over service-based Grids.}, keywords = {BioOpera, distributed business process execution engines, grid computing, Web services}, isbn = {0-7695-1919-9}, doi = {10.1109/CCGRID.2003.1199365}, url = {http://ieeexplore.ieee.org/lpdocs/epic03/wrapper.htm?arnumber=1199365}, author = {Win Bausch and 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} }