@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 {2021:icwe:fullstack,
	title = {Full Stack is Not What It Used to Be},
	booktitle = {21st International Conference on Web Engineering (ICWE2021)},
	year = {2021},
	month = {May},
	publisher = {Springer},
	organization = {Springer},
	address = {Biarritz, France},
	abstract = {The traditional definition of full stack development refers to a skill set that is required for writing software both for the frontend and backend of a web application or site.  In recent years, the scope of full stack development has expanded significantly, though.  Today, a full stack software developer is assumed to master various additional areas especially related to cloud infrastructure and deployment, message brokers and data analytics technologies.  In addition, the emergence of Internet of Things (IoT) and the rapidly spreading use of AI/ML technologies are introducing additional skill set requirements.  In this paper, we discuss the expectations for a modern full stack developer based on our industry observations, and argue that these expectations have significant implications for software and web engineering education.},
	keywords = {Cloud, Education, Internet of Things, IoT, Programmable World, software architecture, software engineering, Web engineering},
	doi = {10.1007/978-3-030-74296-6_28},
	author = {Antero Taivalsaari and Tommi Mikkonen and Cesare Pautasso and Kari Systa}
}
@conference {2020:bpmn-sketch-miner:models,
	title = {From Text to Visual BPMN Process Models: Design and Evaluation},
	booktitle = {23rd International Conference on Model Driven Engineering Languages and Systems (MODELS)},
	year = {2020},
	month = {October},
	pages = {229{\textendash}239},
	publisher = {ACM/IEEE},
	organization = {ACM/IEEE},
	address = {Montreal, Canada},
	abstract = {Most existing Business Process Model and Notation (BPMN) editing tools are graphical, and as such based on explicit modeling, requiring good knowledge of the notation and its semantics, as well as the ability to analyze and abstract business requirements and capture them by correctly using the notation. As a consequence, their use can be cumbersome for live modeling during interviews and design workshops, where participants should not only provide input but also give feedback on how it has been represented in a model. To overcome this, in this paper we present the design and evaluation of BPMN Sketch Miner, a tool which combines notes taking in constrained natural language with process mining to automatically produce BPMN diagrams in real time as interview participants describe them with stories. In this work we discuss the design decisions regarding the trade-off between using mining vs. modelling in order to: 1) support a larger number of BPMN constructs in the textual language; 2) target both BPMN beginners and business analysts, in addition to the process participants themselves. The evaluation of the new version of the tool in terms of how it balances the expressiveness and learnability of its DSL with the usability of the text-to-visual sketching environment shows encouraging results. Namely while BPMN beginners could model a non-trivial process with the tool in a relatively short time and with good accuracy, business analysts appreciated the usability of the tool and the expressiveness of the language in terms of supported BPMN constructs.},
	keywords = {BPMN, domain specific languages, live modeling, text to visual},
	doi = {10.1145/3365438.3410990},
	author = {Ana Ivanchikj and Souhaila Serbout and Cesare Pautasso}
}
@conference {benchflow:2015:bpm,
	title = {A Framework for Benchmarking BPMN 2.0 Workflow Management Systems},
	booktitle = {13th International Conference on Business Process Management (BPM 2015)},
	year = {2015},
	month = {August},
	publisher = {Springer},
	organization = {Springer},
	address = {Innsbruck, Austria},
	keywords = {BenchFlow, BPMN, Workflow Benchmarking},
	doi = {10.1007/978-3-319-23063-4_18},
	author = {Vincenzo Ferme and Ana Ivanchikj and Cesare Pautasso}
}
@inproceedings {wesoa2015,
	title = {From Choreography Diagrams to RESTful Interactions},
	year = {2015},
	month = {November},
	publisher = {Springer},
	address = {Goa, India},
	abstract = {Today, business process management is a key approach to organize work, and many companies represent their operations in business process models. Recently, choreography diagrams have been introduced to represent interactions between business processes, run by different partners. While there is considerable work on using process models during process implementation, there is little work on using choreography models to implement interactions between business processes. In this paper, a novel approach to enhance choreography diagrams by execution information is introduced. The approach is based on the REST architecture style, which is the primary way for interacting systems. Using enhanced choreography diagrams allows us to develop REST-based interactions among business partners in an efficient manner. The approach is illustrated by an example of an accommodation reservation service.},
	keywords = {BPMN Choreography, RESTful conversation},
	author = {Adriatik Nikaj and Sankalita Mandal and Cesare Pautasso and Mathias Weske}
}
@proceedings {wsrest2010,
	title = {First International Workshop on RESTful Design (WS-REST 2010)},
	year = {2010},
	month = {April},
	publisher = {ACM},
	address = {Raleigh, NC, USA},
	doi = {http://doi.acm.org/10.1145/1798354.1798375},
	url = {http://portal.acm.org/beta/citation.cfm?id=1798354},
	editor = {Cesare Pautasso and Erik Wilde and Alexandros Marinos}
}
@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}
}
@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}
}
@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}
}
