@conference {liquid:2023:icwe,
	title = {LiquidAI: Towards an Isomorphic AI/ML System Architecture for the Cloud-Edge Continuum},
	booktitle = {23rd International Conference on Web Engineering (ICWE)},
	year = {2023},
	month = {June},
	publisher = {Springer},
	organization = {Springer},
	address = {Alicante, Spain},
	abstract = {A typical Internet of Things (IoT) system consists of a large number of different subsystems and devices, including sensors and actuators, gateways that connect them to the Internet, cloud services, end-user applications and analytics. Today, these subsystems are implemented with a broad variety of programming technologies and tools, making it difficult to migrate functionality from one subsystem to another.  In our earlier papers, we have predicted the rise of \emph{isomorphic} IoT system architectures in which all the subsystems can be developed with a consistent set of technologies.  
In this paper we expand the same research theme to machine learning technologies, highlighting the need to use ML in a consistent and uniform fashion across the entire Cloud-Edge continuum. },
	keywords = {IoT, liquid software},
	author = {Kari Systa and Cesare Pautasso and Antero Taivalsaari and Tommi Mikkonen}
}
@conference {fc4mc:2023:bpm,
	title = {Loose Collaborations on the Blockchain: Survey and Challenges},
	booktitle = {21st International Conference on Business Process Management - Blockchain Forum},
	year = {2023},
	month = {September},
	pages = {21--35},
	publisher = {Springer},
	organization = {Springer},
	address = {Utrecht, the Netherlands},
	abstract = {Blockchain technology has emerged as a promising infrastructure for enabling collaboration between mutually distrustful organizations. The enactment of blockchain-based collaborative processes typically requires a profound understanding of the process being executed, limiting support for flexible processes that cannot be fully prespecified at design time. To overcome this limitation, support for looseness, dealing with the configuration and execution of underspecified processes, is essential. In this paper, we conduct a systematic literature review to examine looseness support for blockchain-based collaborative processes from a behavioral and organizational perspective. In addition, we identify open research challenges to pave the way for further research in this area.},
	keywords = {blockchain, Collaborative processes, Flexibility, Looseness},
	doi = {10.1007/978-3-031-43433-4_2},
	url = {https://link.springer.com/chapter/10.1007/978-3-031-43433-4_2},
	author = {Tom Lichtenstein and Hassan Atwi and Mathias Weske and Cesare Pautasso}
}
@article {2022:jwe,
	title = {A Large-scale Empirical Assessment of Web API Size Evolution},
	journal = {Journal of Web Engineering},
	volume = {21},
	year = {2022},
	month = {November},
	pages = {1937{\textendash}1980},
	abstract = {Like any other type of software, also Web Application Programming Interfaces (APIs) evolve over time. In the case of widely used API, introducing changes is never a trivial task, because of the risk of breaking thousands of clients relying on the API. In this paper we conduct an empirical study over a large collection of OpenAPI descriptions obtained by mining open source repositories. We measure the speed at which Web APIs change and how changes affect their size, simply defined as the number of operations. The dataset of API descriptions was collected over a period of one year and includes APIs with histories spanning across up to 7 years of commits. The main finding is that APIs tend to grow, although some do reduce their size, as shown in the case study examples included in the appendix.},
	keywords = {API Evolution},
	doi = {10.13052/jwe1540-9589.2167},
	url = {https://ieeexplore.ieee.org/document/10246943},
	author = {Fabio Di Lauro and Souhaila Serbout and Cesare Pautasso}
}
@article {2022:sosym:bpmn,
	title = {Live process modeling with the BPMN Sketch Miner},
	journal = {Software and Systems Modeling},
	volume = {21},
	year = {2022},
	month = {October},
	pages = {1877{\textendash}1906},
	abstract = {BPMN Sketch Miner is a modeling environment for generating visual business process models starting from constrained natural language textual input. Its purpose is to support business process modelers who need to rapidly sketch visual BPMN models during interviews and design workshops, where participants should not only provide input but also give feedback on whether the sketched visual model represents accurately what has been described during the discussion. In this article, we present a detailed description of the BPMN Sketch Miner design decisions and list the different control flow patterns supported by the current version of its textual DSL. We also summarize the user study and survey results originally published in MODELS 2020 concerning the tool usability and learnability and present a new performance evaluation regarding the visual model generation pipeline under actual usage conditions. The goal is to determine whether it can support a rapid model editing cycle, with live synchronization between the textual description and the visual model. This study is based on a benchmark including a large number of models (1350 models) exported by users of the tool during the year 2020. The main results indicate that the performance is sufficient for a smooth live modeling user experience and that the end-to-end execution time of the text-to-model-to-visual pipeline grows linearly with the model size, up to the largest models (with 195 lines of textual description) found in the benchmark workload.},
	keywords = {BPMN, text to visual, Textual Modelling DSL},
	issn = {1619-1366},
	doi = {10.1007/s10270-022-01009-w},
	url = {https://link.springer.com/article/10.1007/s10270-022-01009-w$\#$citeas},
	author = {Ana Ivanchikj and Souhaila Serbout and Cesare Pautasso}
}
@phdthesis {2020:liquid:phd,
	title = {Liquid Web Applications - Design and Implementation of the Decentralized Cross-Device Web},
	year = {2020},
	month = {June},
	pages = {310},
	school = {USI},
	type = {PhD},
	address = {Lugano},
	abstract = {Web applications are traditionally designed having in mind a server-centric architecture, whereby the whole persistent data, dynamic state and logic of the application are stored and running on a Web server. The clients running in the Web browsers traditionally render only pre-computed views fetched from the server. Nowadays this centralized approach does not fit well with the kind of interactions that the users perform when they connect to a Web application. The users can access the Web and fetch applications with much faster devices than the ones we owned thirty years ago. Moreover the Web can now be accessed with devices of any shape, size, and capability: ranging from desktop computers, to laptops, tablets, and smartphones. Emerging smart and embedded devices in the Internet of Things are also able to access the Web and interact with each other thanks to new emerging Web standards, such as smart televisions, smart watches, or smart cars. The diversity in the devices increased together with the average number of Web-enabled devices owned by a single user. Today the average connected users access the Web with multiple devices at the same time and expect that their applications, which are now deployed on all the devices they own, can be seamlessly used on each one of them. In this dissertation we discuss liquid Web applications: software that can be deployed in a cross-device environment by exploiting the current HTML5 standards. In particular we design and implement decentralized liquid Web software able to flow between different platforms. Like liquid adapts its shape to its container, liquid Web applications adapt and can be deployed on all available devices. The Web platform allows devices of different manufactures to communicate, deploy, and distribute liquid applications among them, even when they do not share a common operating system. With liquid Web applications we seek to overcome the current stagnation in the traditional design of solid Web applications in favor of an affordable cross-device solution. We present the history and evolution of liquid applications and discuss why the Web is the best platform for creating them. We show how to design liquid software by discussing how to deploy the state, logic, and user interface of any Web application on multiple devices. The design we present allows developers to create liquid Web applications able to seamlessly flow between multiple devices following the attention of the users. We also present the Liquid.js for Polymer framework, whose goal is to simplify the creation of liquid Web applications by helping developers to create their own liquid user experience. Our contribution in the design of liquid software presented in this dissertation is decoupled from the framework implementation and can be re-used to create new liquid frameworks.},
	keywords = {liquid software, liquid.js},
	url = {https://doc.rero.ch/record/328744},
	author = {Andrea Gallidabino}
}
@article {2019:liquidjs:jwe,
	title = {The LiquidWebWorker API for Horizontal Offloading of Stateless Computations},
	journal = {Journal of Web Engineering},
	volume = {17},
	year = {2019},
	month = {March},
	pages = {405-448},
	abstract = {As most users access the Web from multiple devices with different characteristics, ranging from powerful desktops or laptops to tablets, mobile phones or watches and cars, liquid Web applications seamlessly flow across multiple Web-enabled devices and adapt their distributed user interface to the set of devices simultaneously accessing the application. In this paper we focus on the business logic layer of rich Web applications and explore the opportunity to reduce the execution time of CPU-intensive tasks or limit their energy consumption by offloading them among nearby devices running the same liquid Web application. We extend the standard HTML5 WebWorker API with the concept of liquid WebWorkers, so that developers can transparently offload parallel execution of stateless tasks by managing the necessary device selection and direct peer-to-peer data transfer. By introducing the liquid WebWorker API into our Liquid.js framework, we present how to create a pool of devices sharing their CPU processing capabilities according to different policies.},
	keywords = {Edge Computing, Horizontal Offloading, liquid software, liquid.js, WebWorkers},
	doi = {https://doi.org/10.13052/jwe1540-9589.17672},
	url = {https://www.riverpublishers.com/journal_read_html_article.php?j=JWE/17/7/2},
	author = {Andrea Gallidabino and Cesare Pautasso}
}
@conference {www2018:liquidjs,
	title = {The Liquid User Experience API},
	booktitle = {The Web Conference (WWW2018)},
	year = {2018},
	month = {April},
	pages = {767-774},
	publisher = {ACM},
	organization = {ACM},
	address = {Lyon, France},
	abstract = {In the past years the average number of Web-enabled devices owned by each user has significantly increased. Liquid Web applications enable users to take advantage of all their devices sequentially to migrate their running applications across them or simultaneously when running different views of the same application at the same time on each device. Developers of liquid Web application need to control how to expose the liquid behavior of their cross-device Web applications to the users. To do so, they can use the API of Liquid.js we describe in this paper. Liquid.js is a framework for building component-based rich Web applications which run across multiple Web-enabled devices. The framework is based on technologies such as Polymer, WebRTC, WebWorkers, PouchDB and Yjs. Liquid.js helps to build decentralized Web applications whose components can seamlessly flow directly between Web browsers carrying along their execution state. The Liquid.js API gives developers fine-grained control over the liquid user experience primitives, device discovery, and the lifecycle of liquid Web components. },
	keywords = {API, liquid software, web components},
	doi = {10.1145/3184558.3188738},
	author = {Andrea Gallidabino and Cesare Pautasso}
}
@inproceedings {2017:benchflow:wesoa,
	title = {Lessons Learned from Evaluating Workflow Management Systems},
	year = {2017},
	month = {November},
	publisher = {Springer},
	address = {Malaga, Spain},
	abstract = {Workflow Management Systems (WfMSs) today act as service composition engines and service-oriented middleware to enable the execution of automated business processes. 
Automation based on WfMSs promises to enable the model-driven construction of flexible and easily maintainable services with high-performance characteristics. 
In the past decade, significant effort has been invested into standardizing WfMSs that compose services, with standards such as the Web Services Business Process Execution Language (WS-BPEL) or the Business Process Model and Notation (BPMN).
One of the aims of standardization is to enable users of WfMSs to compare different systems and to avoid vendor lock-in. 
Despite these efforts, there are many expectations concerning portability, performance efficiency, usability, reliability and maintainability of WfMSs that are likely to be unfulfilled.
In this work, we synthesize the findings of two research initiatives that deal with WfMSs conformance and performance benchmarking to distill a set of lessons learned and best practices. 
These findings provide useful advice for practitioners who plan to evaluate and use WfMSs and for WfMS vendors that would like to foster wider adoption of process-centric service composition middleware. },
	keywords = {BenchFlow, Lessons Learned, Workflow Management Systems},
	author = {J{\"o}rg Lenhard and Vincenzo Ferme and Simon Harrer and Matthias Geiger and Cesare Pautasso}
}
@phdthesis {2017:phd:lws,
	title = {Liquid stream processing on the web: a JavaScript framework},
	year = {2017},
	month = {November},
	school = {USI},
	type = {PhD},
	address = {Lugano, Switzerland},
	abstract = {The Web is rapidly becoming a mature platform to host distributed applications. Pervasive computing application running on the Web are now common in the era of the Web of Things, which has made it increasingly simple to integrate sensors and microcontrollers in our everyday life. Such devices are of great interest to Makers with basic Web development skills. With them, Makers are able to build small smart stream processing applications with sensors and actuators without spending a fortune and without knowing much about the technologies they use. Thanks to ongoing Web technology trends enabling real-time peer-to-peer communication between Web-enabled devices, Web browsers and server- side JavaScript runtimes, developers are able to implement pervasive Web applications using a single programming language. These can take advantage of direct and continuous communication channels going beyond what was possible in the early stages of the Web to push data in real-time. Despite these recent advances, building stream processing applications on the Web of Things remains a challenging task. On the one hand, Web-enabled devices of different nature still have to communicate with different protocols. On the other hand, dealing with a dynamic, heterogeneous, and volatile environment like the Web requires developers to face issues like disconnections, unpredictable workload fluctuations, and device overload. To help developers deal with such issues, in this dissertation we present the Web Liquid Streams (WLS) framework, a novel streaming framework for JavaScript. Developers implement streaming operators written in JavaScript and may interactively and dynamically define a streaming topology. The framework takes care of deploying the user-defined operators on the available devices and connecting them using the appropriate data channel, removing the burden of dealing with different deployment environments from the developers. Changes in the semantic of the application and in its execution environment may be applied at runtime without stopping the stream flow. Like a liquid adapts its shape to the one of its container, the Web Liquid Streams framework makes streaming topologies flow across multiple heterogeneous devices, enabling dynamic operator migration without disrupting the data flow. By constantly monitoring the execution of the topology with a hierarchical controller infrastructure, WLS takes care of parallelising the operator execution across multiple devices in case of bottlenecks and of recovering the execution of the streaming topology in case one or more devices disconnect, by restarting lost operators on other available devices.},
	keywords = {JavaScript, liquid software, stream processing},
	url = {https://doc.rero.ch/record/306887},
	author = {Masiar Babazadeh}
}
@demo {liquidjs:2016:www,
	title = {The Liquid.js Framework for Migrating and Cloning Stateful Web Components across Multiple Devices},
	year = {2016},
	month = {April},
	pages = {183-186},
	publisher = {ACM},
	address = {Montreal, Canada},
	abstract = {We are heading toward an era in which users own more than one single Web-enabled device. These devices range from smart phones, tablets and personal computers to smart Web-enabled devices found in houses and cars. The access mechanisms and usage patterns of Web applications are changing accordingly, as users interact more and more with Web applications through all their devices, even if the majority of Web applications are not ready to offer a good user experience taking full advantage of multiple devices. In this demonstration we introduce Liquid.js, a framework whose goal is to enable Web developers to take advantage of multiple heterogeneous devices and offer to their users a liquid user experience, whereby any device can be used sequentially or concurrently with Web applications that can effortlessly roam from one device to another. This way, as highlighted in the demonstration users do not need to stop and resume their work on their Web application as they migrate and clone them across different devices. The demo will also show how developers can easily add such liquid behavior to any Polymer Web component.},
	keywords = {demo, liquid software, liquid.js, web components},
	url = {http://www2016.net/proceedings/companion/p183.pdf},
	author = {Andrea Gallidabino and Cesare Pautasso}
}
@conference {lws:icwe:2015,
	title = {Liquid Stream Processing across Web browsers and Web servers},
	booktitle = {15th International Conference on Web Engineering (ICWE 2015)},
	year = {2015},
	month = {June},
	pages = {24-33},
	publisher = {Springer},
	organization = {Springer},
	address = {Rotterdam, NL},
	abstract = {The recently proposed API definition WebRTC introduced peer-to-peer real time communication between Web browsers, allowing streaming systems to be deployed on browsers in addition to traditional server-side execution environments. While streaming applications can be adapted to run on Web browsers, it remains difficult to deal with temporary disconnections, energy consumption on mobile devices and a potentially very large number of heterogeneous peers that join and leave the execution environment affecting the quality of the stream. In this paper we present the decentralized control approach followed by the Web Liquid Streams (WLS) framework, a novel framework for streaming applications running on Web browsers, Web servers and smart devices. Given the heterogeneity of the deployment environment and the volatility of Web browsers, we implemented a control infrastructure which is able to take operator migration decisions keeping into account the deployment constraints and the unpredictable workload.},
	keywords = {liquid software, stream processing, web liquid streams},
	doi = {10.1007/978-3-319-19890-3_3},
	author = {Masiar Babazadeh and Andrea Gallidabino and Cesare Pautasso}
}
@inproceedings {aghaee2013live,
	title = {Live Mashup Tools: Challenges and Opportunities},
	year = {2013},
	month = {May},
	address = {San Francisco, CA, USA},
	abstract = {Live programming is a programming style in which the repetitive task of compiling and running the software being programmed is managed automatically. This style can be a helpful practice in End-User Development (EUD) where the non-professional end-users are to be supported through techniques and tools that empower them to create or modify software artifacts. Mashups {\textemdash} a form of lightweight Web applications composing reusable content and functionalities available on the Web {\textemdash} are a popular target for EUD activities on the Web. EUD for mashups is enabled by intuitive composition environments, called mashup tools. In this paper, we introduce live mashup tools, a new class of mashup tools based on the live programming style. We give a comprehensive definition and classification of live mashup tools, giving examples of how well existing tools fit in this category and discuss open research challenges and opportunities.},
	keywords = {live programming, NaturalMash, Web mashups},
	doi = {10.1109/LIVE.2013.6617338},
	author = {Saeed Aghaee and Cesare Pautasso}
}
@inproceedings {jopera:mashups07,
	title = {Let it flow: Building Mashups with Data Processing Pipelines},
	volume = {4907},
	year = {2007},
	month = {September},
	pages = {15-28},
	publisher = {Springer},
	address = {Vienna, Austria},
	abstract = {Mashups are a new kind of interactive Web application, built out of the composition of two or more existing Web service APIs and data sources. Whereas "pure" mashups are built relying entirely on the Web browser as a platform for integration at the presentation layer, this approach is not always feasible and part of the mashup integration logic must be deployed on the Web server instead. In the case study presented in this paper, we explore a novel approach to build mashups out of heterogeneous sources of streaming data. In particular, we introduce a layered mashup architecture, with a clear separation between the mashup user interface and the mashup integration logic run by a mashup engine. To do so, we show how to build a mashup application that displays in real time the location of visitors connecting to a Website. The integration logic feeding a map widget by processing the Web site logs is developed using a data flow model that connects a set of reusable and heterogeneous components into a data processing pipeline. We conduct a brief performance evaluation of the mashup showing that the pipeline introduces minimal delay and discuss several extensions of the mashup.},
	keywords = {JOpera, streaming, Web mashups},
	doi = {10.1007/978-3-540-93851-4_3},
	author = {Bi{\"o}rn Bi{\"o}rnstad and Cesare Pautasso}
}
