@conference {apiace:2025:icsa,
	title = {Mining Security Documentation Practices in OpenAPI Descriptions},
	booktitle = {22nd IEEE International Conference on Software Architecture (ICSA)},
	year = {2025},
	month = {March},
	address = {Odense, Denmark},
	abstract = {Security is an integral requirement of any trustworthy software architecture, particularly critical for application programming interfaces (APIs). In this paper, we survey security documentation practices, specifically API security schemes related to authentication and authorization, by mining a large collection of OpenAPI descriptions retrieved from open-source GitHub repositories. Our study focuses on detecting existing security schemes and evaluating their prevalence and positioning within API descriptions. We distinguish whether security schemes are introduced locally (at the path or operation level) or globally (for the entire API). Our analysis highlights scenarios where security schemes are featured in APIs in different proportions over time, thus tracking whether the API documentation tends to include more (or less) security details as the API evolves.},
	keywords = {API Analytics, OpenAPI, Security},
	author = {Diana Carolina Mu{\~n}oz Hurtado and Souhaila Serbout and Cesare Pautasso}
}
@conference {2020:bac:iccs,
	title = {Microservice Disaster Crash Recovery: A Weak Global Referential Integrity Management},
	booktitle = {International Conference on Computational Science},
	year = {2020},
	month = {June},
	address = {Amsterdam, The Netherlands},
	abstract = {Microservices which use polyglot persistence (using multiple data storage techniques) cannot be recovered in a consistent state from backups taken independently. As a consequence, references across microservice boundaries may break after disaster recovery. 
In this paper, we give a weak global consistency definition for microservice architectures and present a recovery protocol which takes advantage of cached referenced data to reduce the amnesia interval for the recovered microservice, i.e., the time interval after the most recent backup, during which state changes may have been lost.},
	keywords = {BAC theorem, Microservices},
	author = {Maude Manouvrier and Cesare Pautasso and Marta Rukoz}
}
@inbook {2020:restalk:ms,
	title = {Modeling Microservice Conversations with RESTalk},
	booktitle = {Microservices},
	year = {2020},
	pages = {129--146},
	publisher = {Springer},
	organization = {Springer},
	abstract = {Microservices are characterized by their small size and low degree of coupling. As a consequence, building microservice architectures requires composing multiple microservices and determine how they interact to achieve a given client{\textquoteright}s goal. In this chapter we introduce the concept of RESTful conversation, whereby clients or API gateways perform multiple basic HTTP request/response interactions with one or more microservice APIs. To represent possible sequences of interactions, we introduce the RESTalk visual notation, as well as its textual DSL, and the corresponding metamodel, and show how it can be used to complement existing structural approaches to represent RESTful APIs, such as the OpenAPI Specification. To reveal the degree of coupling between clients and microservices, the language supports the concept of hyperlink flow, showing whether, within a conversation, the links embedded into responses provided by a microservice are used by the client/API gateway to form the subsequent requests.},
	keywords = {API, conversation, Microservices, RESTalk},
	doi = {10.1007/978-3-030-31646-4_6},
	author = {Ana Ivanchikj and Cesare Pautasso}
}
@article {liquidjs:2020:jwe,
	title = {Multi-Device Complementary View Adaptation with Liquid Media Queries},
	journal = {Journal of Web Engineering (JWE)},
	volume = {18},
	year = {2020},
	month = { 761{\textendash}800 },
	abstract = {Responsive Web applications assume that they run on a single device at a time. Developers use CSS3 media queries to declare how the Web application user interface adapts to specific capabilities (e.g., screen size or resolution) of individual devices. 

As users own and use multiple devices across which they attempt to run the same Web application at the same time, we propose to extend CSS media queries so that developers can also use them to dynamically adapt so-called liquid Web applications as they are seamlessly deployed across multiple devices.

In this paper we present the concept of liquid media queries. They support features to detect the number of connected devices, the number of users running the application, or the role played by each device during the application execution. The liquid media query types and features defined in this paper are designed for component-based Web applications, and they enable developers to control the deployment and dynamic migration and cloning of individual Web components across multiple browsers. Furthermore we present the design of how liquid media queries are implemented within the Liquid.js for Polymer framework and the corresponding distributed adaptation algorithms. We discuss the implications of multi-device adaptation from the perspective of the developers and also the users of a liquid Web application. Finally we showcase the expressiveness of the liquid media queries to support real-world examples and evaluate the algorithmic complexity of our approach.
},
	keywords = {complementary view adaptation, liquid software, media queries, multi-device adaptation, responsive user interface},
	doi = {10.13052/jwe1540-9589.1882},
	url = {https://journals.riverpublishers.com/index.php/JWE/article/view/1099},
	author = {Andrea Gallidabino and Cesare Pautasso}
}
@conference {2019:icwe:liquid,
	title = {Multi-device Adaptation with Liquid Media Queries},
	booktitle = {19th International Conference on Web Engineering (ICWE 2019)},
	year = {2019},
	month = {June},
	pages = {474-489},
	publisher = {Springer},
	organization = {Springer},
	address = {Daejeon, Korea},
	abstract = {The design of responsive Web applications is traditionally based on the assumption that they run on a single client at a time. Thanks to CSS3 media queries, developers can declaratively specify how the Web application UI adapts to the capabilities of specific devices. As users own more and more devices and they attempt to use them to run Web applications in parallel, we propose to extend CSS media queries so that they can be used to adapt the UI of liquid Web applications while they are dynamically deployed across multiple devices. In this paper we present our extension of CSS media queries with liquid-related types and features, allowing to detect the number of devices connected, the number of users running the application, or the role played by each device. The liquid media query types and features defined in this paper are designed and suitable for liquid component-based Web architectures, and they enable developers to control the deployment of individual Web components across multiple browsers. Furthermore we show the design of liquid media queries in the Liquid.js for Polymer framework and propose different adaptation algorithms. Finally we showcase the expressiveness of the liquid media queries to support real-world examples and evaluate the algorithmic complexity of our approach.},
	keywords = {complementary view adaptation, liquid software, liquid web application, liquid.js, media queries, multi-device adaptation, responsive user interface},
	doi = {10.1007/978-3-030-19274-7_33},
	author = {Andrea Gallidabino and Cesare Pautasso}
}
@inproceedings {2018:wesoacs,
	title = {May Contain Nuts: The Case for API Labels},
	year = {2018},
	month = {September},
	address = {Como, Italy},
	abstract = {As APIs proliferate, managing the constantly growing and evolving API landscapes inside and across organizations becomes a challenge. Part of the management challenge is for APIs to be able to describe themselves, so that users and tooling can use descriptions for finding and filtering APIs. A standardized labeling scheme can help to cover some of the cases where API self-description allows API landscapes to become more usable and scalable. In this paper we present the vision for standardized API labels, which summarize and represent critical aspects of APIs. These aspect allow consumers to more easily become aware of the kind of dependency they are going to establish with the service provider when choosing to use them. API labels not only summarize critical coupling factors, but also can include claims that require to be validated by trusted third parties.},
	keywords = {API, API Labels},
	author = {Cesare Pautasso and Erik Wilde}
}
@inproceedings {2018:restalk:dsldi,
	title = {Modeling REST API Behaviour with Text, Graphics or Both?},
	year = {2018},
	month = {November},
	address = {Boston, USA},
	abstract = {The dissemination of domain specific modeling languages in the software engineering world can be challenging as developers love to code and frequently look at graphical modeling as unnecessary and inefficient. This is less true when they are developing business facing software as the end users are non-technical people, and models become a common language to facilitate the communication with them, which explains the diffusion of modeling languages such as for example the Business Process Modeling Notation (BPMN). However, in Application Programming Interface (API) design, where both the creators and the users of the API are developers, the perceived benefits of modeling using a visual notation can be less evident for the developers. When developing APIs adhering to the REpresentation State Transfer (REST) architectural style, the documentation best practices of the structure of the API, i.e., the exposed resources and the HTTP methods that they support together with the corresponding media types, has been evolving in the past decade across a number of textual Domain Specific Languages (DSLs) currently being standardized within the Open API initiative. However, modeling the dynamics of the REST API showing the request-response interactions leading to conversations between clients and one or more resources exposed within the API is not yet a common practice. Thus, we have been working on designing RESTalk, a visual DSL for modeling RESTful conversations, i.e., sequences of client-server interactions aimed at achieving a certain goal. We have conducted a short exploratory survey where, regardless of the positive feedback on the usefulness of such a DSL and the cognitive characteristics of RESTalk, many of the respondents conditioned the adoption of the language to the existence of a suitable modeling tool. Faced with the challenge of developing such a tool, in this talk we would like to pinpoint a critical issue within the design space concerning the input modalities supported by a modeling tool tailored for RESTful APIs. Our goal is to encourage further discussions and empirical studies on what are the pros and cons of different approaches to modeling tools{\textquoteright} design and whether and how the targeted users of the modeling tool (e.g, business people, software architects, developers) affect the design choices.},
	keywords = {dsl, RESTalk},
	url = {https://2018.splashcon.org/event/dsldi-2018-talks-modeling-rest-api-behaviour-with-text-graphics-or-both-},
	author = {Ana Ivanchikj and Cesare Pautasso}
}
@conference {liquidjs:2017:icwe,
	title = {Maturity Model for Liquid Web Architectures},
	booktitle = {17th International Conference on Web Engineering (ICWE2017)},
	volume = {10360},
	year = {2017},
	month = {June},
	pages = {206-224},
	publisher = {Springer},
	organization = {Springer},
	address = {Rome, Italy},
	abstract = {Whenever a user connects with more that one single device, either sequentially or concurrently, to a liquid Web application, the application adapts to the set of connected devices and it is able to flow seamlessly between them following the user attention. As opposed to traditional centralised architectures, in which the data and logic of the application resides entirely on a Web server, Liquid software needs decentralised or distributed architectures in order to achieve seamless application mobility between clients.
By decomposing Web application architectures into layers, following the Model View Controller design pattern, we define a maturity model for Web application architectures evolving from classical solid applications deployed on single devices, to fully liquid applications deployed across multiple Web-enabled devices.
The maturity model defines  different levels based on where the application layers are deployed and how they migrate or synchronize their state across multiple devices. The goal of the maturity model described in this paper is to understand, control and describe how Web applications following the liquid user experience paradigm are designed and also provide Web developers with a gradual adoption path to evolve existing Web applications.},
	keywords = {liquid software, liquid web application, maturity model},
	doi = {10.1007/978-3-319-60131-1_12},
	author = {Andrea Gallidabino and Cesare Pautasso}
}
@conference {asq:2017:umap,
	title = {Measuring student behaviour dynamics in a large interactive classroom setting},
	booktitle = {25th International Conference on User Modelling, Adaption and Personalisation (UMAP 2017)},
	year = {2017},
	month = {July},
	pages = {212--220},
	publisher = {ACM},
	organization = {ACM},
	address = {Bratislava, Slovakia},
	abstract = {Digital devices (most often laptops and smartphones), though desired tools by students in a higher education classroom, have in the past been shown to serve more as distractors than supporters of learning. One of the reasons is the often undirected nature of the devices{\textquoteright} usage. With our work we aim to turn students{\textquoteright} digital devices into teaching and communication tools by seamlessly interleaving lecture material and complex questions in the students{\textquoteright} browser through ASQ, a Web application for broadcasting and tracking interactive presentations. ASQ{\textquoteright}s fine-grained logging abilities allow us to track second by second to what extent students are engaging with ASQ which in turn enables insights into student behaviour dynamics. This setup enables us to conduct {\textquoteleft}{\textquoteleft}in situ{\textquoteright}{\textquoteright} experiments. Based on the logs collected in a longitudinal study over a ten week period across 14 lectures with more than 300 students, we investigate (i) to what extent ASQ can be reliably employed to assess attention and learning in the classroom, and (ii) whether different in-class question spacing strategies impact student learning and engagement.},
	keywords = {ASQ},
	doi = {10.1145/3079628.3079671},
	url = {http://dl.acm.org/authorize?N31530},
	author = {Vasileios Triglianos and Sambit Praharaj and Cesare Pautasso and Alessandro Bozzon and Claudia Hauff}
}
@article {2017:sw:ms1,
	title = {Microservices in Practice (Part 1): Reality Check and Service Design},
	journal = {IEEE Software},
	volume = {34},
	year = {2017},
	month = {January-February},
	pages = {91-98},
	keywords = {Microservices},
	doi = {10.1109/MS.2017.24},
	url = {http://ieeexplore.ieee.org/document/7819415/},
	author = {Cesare Pautasso and Olaf Zimmermann and Mike Amundsen and James Lewis and Nicolai Josuttis}
}
@article {2017:sw:ms2,
	title = {Microservices in Practice (Part 2): Service Integration and Sustainability},
	journal = {IEEE Software},
	volume = {34},
	year = {2017},
	month = {March-April},
	pages = {97-104},
	keywords = {Microservices},
	doi = {10.1109/MS.2017.56},
	url = {http://ieeexplore.ieee.org/document/7888407/},
	author = {Cesare Pautasso and Olaf Zimmermann and Mike Amundsen and James Lewis and Nicolai Josuttis}
}
@inproceedings {icwe:2015:rmc:wls,
	title = {Mashup Development with Web Liquid Streams},
	year = {2016},
	pages = {98-117},
	publisher = {Springer},
	address = {Rotterdam, The Netherlands},
	abstract = {Web services such as Twitter and Facebook provide direct access to their streaming APIs. The data generated by all of their users is forwarded in quasi-real-time to any external client requesting it: this continuous feed opens up new ways to create mashups that differ from existing data aggregation approaches, which focus on presenting with multiple widgets an integrated view of the data that is pulled from multiple sources.
Streaming data flows directly into the mashup without the need to fetch it in advance, making it possible to exchange data between mashup components through streaming channels. In this challenge submission we show how streaming APIs can be integrated using a stream processing framework. Mashup components can be seen as stream operators, while the mashup can be defined by building a streaming topology. The mashup is built with \wls, a dynamic streaming framework that takes advantage of standard Web protocols to deploy stream topologies both on Web servers and Web browsers.},
	keywords = {mashup development, rapid mashup challenge, web liquid streams},
	author = {Andrea Gallidabino and Masiar Babazadeh and Cesare Pautasso}
}
@conference {benchflow:2016:caise,
	title = {Micro-Benchmarking BPMN 2.0 Workflow Management Systems with Workflow Patterns},
	booktitle = {Proc. of the 28th International Conference on Advanced Information Systems Engineering (CAISE)},
	year = {2016},
	month = {June},
	pages = {67--82},
	publisher = {Springer},
	organization = {Springer},
	address = {Ljubljana, Slovenia},
	abstract = {Although Workflow Management Systems (WfMSs) are a key component in workflow technology, research work for assessing and comparing their performance is limited. This work proposes the first micro- benchmark for WfMSs that can execute BPMN 2.0 workflows. To this end, we focus on studying the performance impact of well-known workflow patterns expressed in BPMN 2.0 with respect to three open source WfMSs (i.e., Activiti, jBPM and Camunda). We executed all the experiments under a reliable environment and produced a set of meaningful metrics. This paper contributes to the area of workflow technology by defining building blocks for more complex BPMN 2.0 WfMS benchmarks. The results have shown bottlenecks on architectural design decisions, resource utilization, and limits on the load a WfMS can sustain, especially for the cases of complex and parallel structures. Experiments on a mix of workflow patterns indicated that there are no unexpected performance side effects when executing different workflow patterns concurrently, although the duration of the individual workflows that comprised the mix was increased.},
	keywords = {BenchFlow, benchmarking, BPMN, Microbenchmark, workflow engine, Workflow Management Systems, workflow patterns},
	doi = {10.1007/978-3-319-39696-5_5},
	url = {http://www2.informatik.uni-stuttgart.de/cgi-bin/NCSTRL/NCSTRL_view.pl?id=INPROC-2016-05\&engl=0},
	author = {Marigianna Skouradaki and Vincenzo Ferme and Cesare Pautasso and Frank Leymann and Andr{\'e} van Hoorn}
}
@demo {2016:icwe:liquidjs:demo,
	title = {Migrating and Pairing Recursive Stateful Components Between Multiple Devices with Liquid.js for Polymer},
	year = {2016},
	pages = {555{\textendash}558},
	publisher = {Springer},
	address = {Lugano, Switzerland},
	abstract = {With the continuous development of new Web-enabled devices, we are heading toward an era in which users connect to the Web with multiple devices at the same time. Users expect Web applications to be able to flow between all the devices they own, however the majority of the current Web applications was not designed considering this use case scenario. As the number of devices owned by a user increases, we have to find new ways to give Web developers the tools to easily implement the expected liquid behaviour into their software. We present a new contribution provided by the Liquid.js for Polymer framework, allowing the migration of recursive component-based Web applications from a device to another. In this demo paper we will show how to create recursive components, how to migrate them among devices, and how their state can be paired among the various components.},
	keywords = {liquid software, liquid.js, web components},
	isbn = {978-3-319-38791-8},
	doi = {10.1007/978-3-319-38791-8_47},
	url = {http://dx.doi.org/10.1007/978-3-319-38791-8_47},
	author = {Gallidabino, Andrea}
}
@conference {ecsa2015:restcon,
	title = {Modeling RESTful Conversations with extended BPMN Choreography diagrams},
	booktitle = {9th European Conference on Software Architecture (ECSA 2015)},
	year = {2015},
	month = {September},
	publisher = {Springer},
	organization = {Springer},
	address = {Dubrovnik, Croatia},
	abstract = {RESTful Web APIs often make use of multiple basic HTTP interactions to guide clients towards their goal. For example, clients may get redirected towards related resources by means of hypermedia controls such as links. Existing modeling approaches for describing RESTful APIs expose low-level HTTP details that help developers construct individual requests and parse the corresponding responses. However, very little attention has been given to high-level modeling of RESTful conversations, which abstracts the structure of multiple HTTP interactions. To address such issue in this paper we introduce an extension of the notation used in BPMN choreography diagrams. Its purpose is to represent concisely all possible interaction sequences in a given RESTful conversation.},
	keywords = {BPMN Choreography, REST, RESTful conversation},
	author = {Cesare Pautasso and Ana Ivanchikj and Silvia Schreier}
}
@conference {naturalmash:iiwas:2012,
	title = {The mashup component description language},
	booktitle = {13th International Conference on Information Integration and Web-based Applications and Services  (iiWAS 2011)},
	year = {2011},
	month = {December},
	pages = {311-316},
	address = {Ho Chi Minh City, Vietnam},
	abstract = {Mashups can be seen as the result of software composition applied to the Web. One of the characteristics of mashup development is the heterogeneity of its building components in terms of logical layering (e.g., user interface, application logic, and data), access method (e.g., REST, SOAP), and composition technique (e.g., scraping vs. clipping, synchronous vs. asynchronous interaction, discrete vs. streaming). This poses a challenge towards the design of mashup tools aiming at lowering the barriers of mashup development, as this heterogeneity needs to be abstracted. In this paper, we address this challenge by proposing a new JSON-based domain-specific language for describing heterogeneous mashup components, called the Mashup Component Description Language (MCDL). MCDL lies at the core of a meta-model for mashup component modeling, and can be used for component discovery and classification but also for user-centric mashup development as it decouples the interface of a mashup component from its underlying implementation technologies.},
	keywords = {natural language processing, NaturalMash, service contracts, Web mashups},
	doi = {10.1145/2095536.2095591},
	author = {Saeed Aghaee and Cesare Pautasso}
}
@inproceedings {mashups:2010:html5,
	title = {Mashup Development with HTML5},
	year = {2010},
	month = {December},
	pages = {10:1{\textendash}10:8},
	publisher = {ACM},
	address = {Ayia Napa, Cyprus},
	abstract = {HTML5 is a new technology standard promising to empower browsers to become a suitable platform for developing rich Web applications. Whilst it is still considered an emerging technology, in this paper we attempt to capture and explore its impacts on mashup development. To do so, we start with a mashup case study showcasing new HTML5 features. We then move on to explore those aspects of mashup development that are affected and will possibly be enabled by HTML5 in the near future. These aspects are grouped into two categories: short-term impacts, that can be harnessed by mashup developers, and long-term impacts, that should be considered by service/content providers.},
	keywords = {HTML5, mashup, mashup development},
	isbn = {978-1-4503-0418-4},
	doi = {10.1145/1944999.1945009},
	author = {Saeed Aghaee and Cesare Pautasso}
}
@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}
}
@inbook {db:2009:mediation,
	title = {Mediation},
	booktitle = {Encyclopedia of Database Systems},
	year = {2009},
	pages = {1704-1706},
	publisher = {Springer},
	organization = {Springer},
	keywords = {software composition},
	doi = {10.1007/978-0-387-39940-9_1546},
	author = {Cesare Pautasso},
	editor = {Ling Liu and M. Tamer {\"O}zsu}
}
@inproceedings {mashups08:atelier,
	title = {The Mashup Atelier},
	volume = {5472},
	year = {2008},
	month = {December},
	pages = {155-165},
	publisher = {Springer},
	address = {Sydney, Australia},
	abstract = {Can mashups be used to make high school students interested in studying computer science? To answer this question, we have designed the mashup atelier. The goal of this experimental lecture is to make students realize that the Web is not only a medium for passively consuming information but it can be actively reprogrammed as they see fit. The atelier introduces the topic of Web 2.0 Mashups to students without any formal pre-existing computer science education. After giving the atelier several times, we report on the results of a student evaluation survey showing that, if supported with right kind of mashup tools, creative students can become very productive developing interesting mashups in a short timeframe. The feedback we gathered from the students can also be used to improve existing mashup languages and tools, with the ultimate goal of understanding what makes them intuitive and fun to use.},
	keywords = {end-user software engineering, Web mashups},
	doi = {10.1007/978-3-642-01247-1_15},
	author = {Cesare Pautasso and Monica Frisoni}
}
@conference {jopera:2006:ccgrid,
	title = {Mirroring Resources or Mapping Requests: implementing WS-RF for Grid workflows},
	booktitle = {6th IEEE International Symposium on Cluster Computing and the Grid (CCGrid2006)},
	year = {2006},
	month = {May},
	address = {Singapore},
	abstract = {The Web Services Resource Framework (WS-RF) and the Web Services Notification (WS-N) specifications are a crucial component of Grid infrastructures. They provide a standardized interface to stateful services so that they can be managed remotely. There are already several implementations of these specifications and initial performance studies have compared them in terms of the overhead observed by a single client. In this paper we address the problem of implementing the WS-RF and WS-N specifications for large scale systems. In particular, we discuss how to implement WS-RF and WSN as the management interfaces to a Grid workflow engine. In the paper we describe and compare two different architectures for mapping resources to processes. The first one mirrors the state of the process as a resource. The second one maps the client requests to access the state of a resource embedded into the Grid workflow engine. We include an extensive performance evaluation, comparing the resulting systems in terms of scalability when servicing a large number of concurrent clients. },
	keywords = {grid computing, JOpera, scientific workflow management},
	doi = {10.1109/CCGRID.2006.69},
	author = {Thomas Heinis and Cesare Pautasso and Gustavo Alonso}
}
