@proceedings {2024:asianplop, title = {Decentralized Task Execution Patterns}, year = {2024}, month = {March}, address = {Fujisawa City, Kanagawa Prefecture, Japan}, abstract = {Decentralized task execution requires to assign planning, execution and control roles and responsibilities to at least two distinct parties. These include making decisions about {\textquoteleft}{\textquoteleft}who does what when{\textquoteright}{\textquoteright} so that one party can track the progress and the outcome of tasks executed by another party. In this paper we outline the design space for decentralized task execution by presenting 18 different patterns, going from imperative task execution all the way to autonomous task execution. We will distinguish how decisions about who performs a task, what needs to be done and when to do it can be made by different parties and how these alternative decision-making locations impact the interactions between the parties responsible to plan, execute and control the task execution. The patterns are applicable within human organizations with many actors delegating or performing multiple tasks but also to fully automated systems, e.g., distributed operating systems, intelligent autonomous vehicles, blockchain-based workflow engines or high throughput job schedulers.}, keywords = {patterns, Workflow Management Systems, workflow patterns}, author = {Cesare Pautasso} } @conference {2021:europlop:api-fragments, title = {From OpenAPI Fragments to API Pattern Primitives and Design Smells}, booktitle = {European Conference on Pattern Languages of Programs (EuroPLoP{\textquoteright}21)}, year = {2021}, month = {July}, publisher = {ACM}, organization = {ACM}, address = {Virtual Kloster Irsee, Germany}, abstract = {In the past few years, the OpenAPI Specification (OAS) has emerged as a standard description language for accurately modeling Web APIs. Today, thousands of OpenAPI descriptions can be found by mining open source repositories. In this paper, we attempt to exploit these artifacts to extract commonly occurring building blocks used in Web API structures, in order to assist Web API designers in their modelling task. Our work is based on a fragmentation mechanism, that starts from OpenAPI descriptions of Web APIs to extract their structures, then fragment these structures into smaller blocks. This approach enabled us to extract a large dataset of reoccurring fragments from a collection of 6619 API specifications. Such fragments have been found multiple times in the same or across different APIs. We have classified the most reoccurring fragments into four pattern primitives used to expose in the API access to collections of items. We distinguish for each primitive variants from design smells. This classification is based on the specific combinations of operations associated with the collection items and on an in-depth analysis of their natural language labels and descriptions. The resulting pattern primitives are intended to support designers who would like to introduce one or more collections for a specific class of items in their HTTP-based API.}, keywords = {API, API fragments, design smells, OpenAPI, patterns}, doi = {10.1145/3489449.3489998}, url = {https://zenodo.org/record/5727094$\#$.YZ97mFMo-0o}, author = {Souhaila Serbout and Cesare Pautasso and Uwe Zdun and Olaf Zimmermann} } @conference {2019:map:europlop, title = {Interface Evolution Patterns {\textemdash} Balancing Compatibility and Flexibility across Microservices Lifecycles}, booktitle = {24th European Conference on Pattern Languages of Programs (EuroPLoP 2019)}, year = {2019}, month = {July}, publisher = {ACM}, organization = {ACM}, address = {Irsee, Germany}, abstract = {Remote Application Programming Interfaces (APIs) are technology enablers for distributed system trends such as cloud-native application development. API providers find it hard to design their remote APIs so that they can be evolved easily; refactoring and extending an API while preserving backward compatibility is particularly challenging. If APIs are evolved poorly, clients are critically impacted; high costs to adapt and compensate for downtimes may result. For instance, if an API provider publishes a new incompatible API version, existing clients might break and not function properly until they are upgraded to support the new version. Hence, applying adequate strategies for evolving service APIs is one of the core problems in API governance, which in turn is a prerequisite for successfully integrating service providers with their clients in the long run. Although many patterns and pattern languages are concerned with API and service design and related integration technologies,patterns guiding the evolution of APIs are missing to date. Extending our pattern language on Microservice API Patterns (MAP), we introduce a set of patterns focusing on API evolution strategies in this paper: API Description, Version Identifier, Semantic Versioning, Eternal Lifetime Guarantee, Limited Lifetime Guarantee, Two in Production, Aggressive Obsolescence, and Experimental Preview.The patterns have been mined from public Web APIs and industry projects the authors have been involved in.}, keywords = {API, API Evolution, Microservices, patterns}, doi = {10.1145/3361149.3361164}, url = {https://dl.acm.org/citation.cfm?id=3361164}, author = {Daniel L{\"u}bke and Olaf Zimmermann and Cesare Pautasso and Uwe Zdun} } @conference {2018:map:europlop, title = {Interface Quality Patterns --- Crafting and Consuming Message-Based Remote APIs}, booktitle = {23rd European Conference on Pattern Languages of Programs (EuroPLoP)}, year = {2018}, month = {July}, publisher = {ACM}, organization = {ACM}, address = {Kloster Irsee, Germany}, abstract = {The design and evolution of Application Programming Interfaces (APIs) in microservices architectures is challenging. General design issues in integration and programming have been covered in great detail in many pattern languages since the beginnings of the patterns movement, and service-oriented infrastructure design patterns have also been published in the last decade. However, the interface representations (i.e., the content of message payloads) have received less attention. We presented five structural representation patterns in our previous work; in this paper we continue our coverage of the API design space and propose five interface quality patterns that deal with the observable aspects of quality-attribute-driven interface design for efficiency, security, and manageability: An API Key allows API providers to identify clients. Providers may offer rich data contracts in their responses, which not all consumers might need. A Wish List allows the client to request only the attributes in a response data set that it is interested in. If a client makes many API calls, the provider can employ a Rate Limit and bill clients according to a specified Rate Plan . A provider has to provide a high-quality service while at the same time having to use its available resources economically. The resulting compromise is expressed in a provider{\textquoteright}s Service Level Agreement. }, keywords = {interfaces, Microservices, patterns, quality}, author = {Mirko Stocker and Olaf Zimmermann and Daniel L{\"u}bke and Uwe Zdun and Cesare Pautasso} } @conference {2018:blockchain:europlop, title = {A Pattern Collection for Blockchain-based Applications}, booktitle = {23rd European Conference on Pattern Languages of Programs (EuroPLoP)}, year = {2018}, month = {July}, publisher = {ACM}, organization = {ACM}, address = {Kloster Irrsee, Germany}, abstract = {Blockchain is an emerging technology that enables new forms of decentralized software architectures, where distributed components can reach agreements on shared system states without trusting a central integration point. Blockchain provides a shared infrastructure to execute programs, called smart contracts, and to store data. Since blockchains are at an early stage, there is a lack of a systematic and holistic view on designing software systems that use blockchain. We view blockchain as part of a bigger system, which requires patterns of using blockchain in the design of the bigger systems. In this paper, we collect a list of patterns for blockchain-based applications. The pattern collection is categorized into four types, including interaction with external world patterns, data management patterns, security patterns and contract structural patterns. Some patterns are designed specifically based on real-world blockchain-based applications considering the nature of blockchain. Others are variants of existing design patterns applied in the context of blockchain-based applications and smart contracts.}, keywords = {blockchain, patterns}, doi = {10.1145/3282308.3282312}, url = {https://dl.acm.org/citation.cfm?id=3282312}, author = {Xiwei Xu and Cesare Pautasso and Liming Zhu and Qinghua Lu and Ingo Weber} } @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} }