@inbook {sa:2023:education, title = {A Better Way to Teach Software Architecture}, year = {2023}, pages = {101 - 110}, publisher = {Springer}, organization = {Springer}, abstract = {Software architecture education is a weak spot in many undergraduate programs in computer science and software engineering. While the concepts and practices used by software architects in industry are rich and varied, transferring this expertise into a university classroom has proved problematic. Bridging the gap between industry and academia requires ongoing, often heroic, effort. This is a {\textquotedblleft}chicken and egg{\textquotedblright} problem: Because there is a lack of good teaching materials, architecture is seldom taught, and because it is seldom taught, there has been little incentive to create good materials. We would like to change that. Our goal is to establish guidelines for how software architecture practices should be taught{\textemdash}both technical and non-technical topics{\textemdash}and to suggest appropriate teaching methods to best prepare students to be software architects in practice.}, keywords = {software architecture}, isbn = {978-3-031-36846-2}, doi = {10.1007/978-3-031-36847-9_6}, url = {https://link.springer.com/10.1007/978-3-031-36847-9_6}, author = {Kazman, Rick and Cai, Yuanfang and Godfrey, Michael W. and Cesare Pautasso and Liu, Anna}, editor = {Pelliccione, Patrizio and Kazman, Rick and Weber, Ingo and Liu, Anna} } @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 {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} } @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 {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} } @conference {2018:icwe:liquid, title = {Decentralized Computation Offloading on the Edge with Liquid WebWorkers}, booktitle = {18th International Conference On Web Engineering (ICWE 2018)}, year = {2018}, month = {June}, publisher = {Springer}, organization = {Springer}, address = {C{\'a}ceres, Spain}, abstract = {Liquid Web applications seamlessly flow across any kind of device ranging from powerful desktop and laptop devices to smaller devices, such as tablets, smart phones or any device capable of running a Web browser. In this context, there is the opportunity to reduce the execution time of CPU-intensive tasks or limit their energy consumption by offloading them across the set of machines running the liquid Web application. To do so, in this paper we present Liquid WebWorkers, which build upon the standard HTML5 WebWorker API and transparently offload the task execution to other devices and manage the corresponding data transfer. This way, Web developers can reuse their existing WebWorker scripts without any changes. We present how to create a pool of paired devices and compare different policies for choosing the target device that have been implemented in the Liquid.js framework.}, keywords = {liquid software, offloading}, author = {Andrea Gallidabino and Cesare Pautasso} } @demo {2018:icsoc:demo:electra, title = {ELeCTRA: induced usage limitations calculation in RESTful APIs}, year = {2018}, month = {November}, publisher = {Springer}, address = {Hangzhou, Zhejiang, China}, abstract = {As software architecture design is evolving to microservice paradigms, RESTful APIs become the building blocks of applications. In such a scenario, a growing market of APIs is proliferating and developers face the challenges to take advantage of this reality. For an example, third-party APIs typically define different usage limitations depending on the purchased Service Level Agreement (SLA) and, consequently, do- ing a manual limitation analysis of external APIs and their impact in a microservice architecture is a complex and tedious task. In this demonstration paper, we present ELeCTRA, a tool to automate the analysis of induced limitations in an API, derived from its usage of external APIs with limitations. Specifically, this tools takes the structural, conversational and SLA specifications of the API, generates a visual dependency graph and translates the problem into a constraint satisfaction optimization problem (CSOP) to obtain the optimal usage limitations.}, keywords = {API, demo, REST}, author = {Antonio Gamez-Diaz and Pablo Fernandez and Cesare Pautasso and Ana Ivanchikj and Antonio Ruiz-Cortes} } @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} } @conference {2018:asq:disa, title = {Short Texts Analysis for Teacher Assistance during Live Interactive Classroom Presentations}, booktitle = {World Symposium on Digital Intelligence for Systems and Machines (DISA2018)}, year = {2018}, month = {August}, publisher = {IEEE}, organization = {IEEE}, address = {Ko{\v s}ice, Slovakia}, abstract = {We aim to improve the communication process of a teacher with students during lectures using question answering. Our work is focused on the analysis of students{\textquoteright} answers to support the teacher in his or her lecturing. We work with students{\textquoteright} answers to open questions, where it is impossible to identify finite number of solutions. In large classes it is impossible to react in real time to such answers since their evaluation is time consuming. We propose our own approach that helps the teacher by grouping similar answers. These groups are created based on proposed method employing text classification and clustering. Proposed method automatically estimates a number of clusters in answers using combination of k-Nearest Neighbors (KNN) algorithm and affinity propagation. We evaluated the method on real data in Slovak language collected from the course Principles of Software Engineering using real time presentation system ASQ.}, keywords = {ASQ, clustering}, author = {Michal Hucko and Peter Gaspar and Matus Pikuliak and Vasileios Triglianos and Cesare Pautasso and Maria Bielikova} } @article {2017:jwe:liquid, title = {Architecting Liquid Software}, journal = {Journal of Web Engineering}, volume = {16}, year = {2017}, month = {September}, pages = {433-470}, abstract = {The Liquid Software metaphor refers to software that can operate seamlessly across multiple devices owned by one or multiple users. Liquid software applications can take advantage of the computing, storage and communication resources available on all the devices owned by the user. Liquid software applications can also dynamically migrate from one device to another, following the user{\textquoteright}s attention and usage context. The key design goal in Liquid Software development is to minimize the additional efforts arising from multiple device ownership (e.g., installation, synchronization and general maintenance of personal computers, smartphones, tablets, home and car displays, and wearable devices), while keeping the users in full control of their devices, applications and data. In this paper we present the design space for Liquid Software, categorizing and discussing the most important architectural dimensions and technical choices. We also provide an introduction and comparison of two frameworks implementing Liquid Software capabilities in the context of the World Wide Web. }, keywords = {design space, liquid software, multi-device programming, software architecture}, doi = {10.26421/JWE16.5-6}, url = {http://www.rintonpress.com/journals/jweonline.html$\#$v16n56}, author = {Andrea Gallidabino and Cesare Pautasso and Tommi Mikkonen and Kari Systa and Jari-Pekka Voutilainen and Antero Taivalsaari} } @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} } @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} } @article {benchflow:2017:icse, title = {Workflow Management Systems Benchmarking: Unfulfilled Expectations and Lessons Learned}, year = {2017}, month = {May}, address = {Buenos Aires, Argentina}, abstract = {Workflow Management Systems (WfMSs) are a type of middleware that enables the execution of automated business processes. Users rely on WfMSs to construct flexible and easily maintainable software systems. Significant effort has been invested into standardising languages for business processes execution, with standards such as the Web Services Business Process Execution Language 2.0 or the Business Process Model and Notation 2.0. Standardisation aims at avoiding vendor lock-in and enabling WfMS users to compare different systems. The reality is that, despite standardisation efforts, different independent research initiatives show that objectively comparing WfMSs is still challenging. As a result, WfMS users are likely to discover unfulfilled expectations while evaluating and using these systems. In this work, we discuss the findings of two research initiatives dealing with WfMSs benchmarking, presenting unfulfilled expectations and lessons learned concerning WfMSs{\textquoteright} usability, reliability, and portability. Our goal is to provide advice for practitioners implementing or planning to use WfMSs.}, keywords = {Lessons Learned, Workflow Management Systems}, doi = {10.1109/ICSE-C.2017.126}, author = {Vincenzo Ferme and J{\"o}rg Lenhard and Simon Harrer and Matthias Geiger and Cesare Pautasso} } @conference {liquidjs:2016:wicsa, title = {On the Architecture of Liquid Software: Technology Alternatives and Design Space}, booktitle = {13th Working IEEE/IFIP Conference on Software Architecture (WICSA 2016)}, year = {2016}, month = {April}, address = {Venice, Italy}, abstract = {The liquid metaphor refers to software that operates seamlessly across multiple devices owned by one or multiple users. Liquid software architectures can dynamically deploy and redeploy stateful software components and transparently adapt them to the capabilities of heterogeneous target devices. The key design goal in liquid software development is to minimize the efforts that are related to multiple device ownership (e.g., installation, synchronization and general maintenance of personal computers, smartphones, tablets, home displays, cars and wearable devices), while keeping the users in full control of their devices, applications and data. In this paper we present a design space for liquid software, categorizing and discussing the most important architectural issues and alternatives. These alternatives represent relevant capabilities offered by emerging technologies and deployment platforms that are then positioned and compared within the design space presented in the paper.}, keywords = {design space, liquid software, liquid.js}, author = {Andrea Gallidabino and Cesare Pautasso and Ville Ilvonen and Tommi Mikkonen and Kari Systa and Jari-Pekka Voutilainen and Antero Taivalsaari} } @conference {blockchain:2016:wicsa, title = {The Blockchain as a Software Connector}, booktitle = {13th Working IEEE/IFIP Conference on Software Architecture (WICSA 2016)}, year = {2016}, month = {April}, address = {Venice, Italy}, abstract = {Blockchain is an emerging technology for decentralized and transactional data sharing across a large network of untrusted participants. It enables new forms of distributed software architectures, where components can find agreements on their shared states without trusting a central integration point or any particular participating components. Considering the blockchain as a software connector helps make explicitly important architectural considerations on the resulting performance and quality attributes (for example, security, privacy, scalability and sustainability) of the system. Based on our experience in several projects using blockchain, in this paper we provide rationales to support the architectural decision on whether to employ a decentralized blockchain as opposed to other software solutions, like traditional shared data storage. Additionally, we explore specific implications of using the blockchain as a software connector including design trade-offs regarding quality attributes.}, keywords = {blockchain, software connector}, author = {Xiwei Xu and Cesare Pautasso and Liming Zhu and Vincent Gramoli and Alexander Ponomarev and An Binh Tran and Shiping Chen} } @conference {liquidjs:2016:cbse, title = {Deploying Stateful Web Components on Multiple Devices with Liquid.js for Polymer}, booktitle = {19th International ACM Sigsoft Symposium on Component-Based Software Engineering (CBSE 2016)}, year = {2016}, month = {April}, pages = {85-90}, address = {Venice, Italy}, abstract = {Nowadays, the average users owns two or more Web-enabled devices (smart phones, personal computers and tablets), while more are coming: watches, cars, glasses. While responsive Web applications can adapt to the specific device (e.g., screen size or input method) on which they are deployed, they only provide limited support when one user connects from more than one device at the same time. In this paper we present Liquid.js for Polymer, a framework whose goal is to support developers that need to build liquid Web applications taking full advantage of multiple heterogeneous devices. It extends emerging Web components standards to enable the liquid user experience, whereby any device can be used sequentially or concurrently with applications that can roam from one device to another with no effort required by users controlling them. This way, users do not need to stop and resume their work on their Web application as they switch devices. Developers using Liquid.js do not need to worry about the underlying connectivity, pairing and synchronization issues of their stateful Web components. }, keywords = {liquid software}, author = {Andrea Gallidabino and Cesare Pautasso} } @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} } @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} } @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 {lisa:2015:esocc, title = {Decentralized Stream Processing over Web-enabled devices}, booktitle = {4th European Conference on Service-Oriented and Cloud Computing}, volume = {9306}, year = {2015}, month = {September}, pages = {3-18}, publisher = {Springer}, organization = {Springer}, address = {Taormina, Italy}, keywords = {liquid software, stream processing}, doi = {10.1007/978-3-319-24072-5_1}, author = {Masiar Babazadeh and 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} } @article {toffetti2013IC, title = {Kriging Controllers for Cloud Applications}, journal = {IEEE Internet Computing}, volume = {17}, year = {2013}, month = {July-August 2013}, pages = {40-47}, publisher = {IEEE}, abstract = {Infrastructure as a Service is a Cloud computing paradigm that enables service providers to execute applications on third-party infrastructures with the pay-as-you-go billing model. Service providers can balance operational costs and quality of service by monitoring the application behavior and changing the deployed configuration at runtime as operating conditions change. Current approaches for automatically scaling cloud applications exploit user defined rules that respond well to events that can be predicted at design time, but have no provision for learning, hence do not react adequately to unexpected execution conditions. In this article we present a new approach for designing autonomic controllers that automatically adapt to unpredicted conditions by dynamically updating a model of the system behavior. The approach demonstrates Kriging models as a suitable means to design efficient autonomic controllers.}, keywords = {automatic control, autonomic computing, autonomic controller, cloud computing}, issn = {1089-7801}, doi = {10.1109/MIC.2012.142}, author = {Giovanni Toffetti-Carughi and Alessio Gambi and Mauro Pezz{\`e} and Cesare Pautasso} } @inproceedings {restbpm:2013:pesos, title = {RESTful Business Process Management in the Cloud}, year = {2013}, month = {May}, address = {San Francisco, CA, USA}, abstract = {As more and more business processes are migrated into cloud-based runtimes, there is a need to manage their state to provide support for quality attributes such as elasticity, scalability and dependability. In this paper we discuss how the REST architectural style provides a sensible choice to manage and publish service compositions under the Platform as a Service paradigm. We define the design principles of RESTful business process management in the cloud and compare several architectural alternatives to support elastic processes which can be monitored and dynamically adapted to workload changes.}, keywords = {business process management, cloud computing, REST, RESTful business process management}, author = {Alessio Gambi and Cesare Pautasso} } @inproceedings {scube:icse:2012, title = {Research challenges on service technology foundations}, year = {2012}, month = {June}, pages = {27-33}, abstract = {This work gives an overview of the future research challenges on enabling technologies for service-based applications that have been identified in the network of excellence S-Cube. Service-based applications comprise three layers: business processes, service compositions and services and service infrastructures. The goal of this work is to present a roadmap for future research in technologies for software and system services.}, keywords = {adaptation models, biological system modeling, business process management, business transactions, cloud computing, computational modeling, formal models, KPIs, liquid computing, monitoring, monitoring and adaptation, nature-inspired approches, quality of service, s-cube, service composition, service infrastructures, service networks, service oriented architectures, service oriented computing, service technology foundations}, doi = {10.1109/S-Cube.2012.6225505}, author = {Dimka Karastoyanova and Manuel Carro and Dragan Ivanovic and Claudia Di Napoli and Maurizio Giordano and Zsolt Nem{\'e}th 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} } @conference {jopera:2010:icwe, title = {Engineering autonomic controllers for virtualized web applications}, booktitle = {10th international conference on Web engineering (ICWE 2010)}, series = {ICWE{\textquoteright}10}, volume = {6189}, year = {2010}, note = {Best Paper Award}, month = {July}, pages = {66{\textendash}80}, publisher = {Springer}, organization = {Springer}, address = {Berlin, Heidelberg}, keywords = {autonomic computing, cloud computing, control system synthesis, JOpera}, isbn = {3-642-13910-8, 978-3-642-13910-9}, doi = {10.1007/978-3-642-13911-6_5}, author = {Giovanni Toffetti-Carughi and Alessio Gambi and Mauro Pezz{\`e} and Cesare Pautasso} } @inproceedings {clavos:2009:pesos, title = {Embedding continuous lifelong verification in service life cycles}, year = {2009}, month = {May}, pages = {99-102}, address = {Vancouver, Canada}, abstract = {Service-oriented systems are an instantiation of open world software, which is characterized by high dynamism and decentralization. These properties strongly impact on how service-oriented systems are engineered, built, and operated, as well as verified. To address the challenges of applying verification to open service-oriented systems, in this position paper we propose to apply verification across the entire life cycle of a service and introduce a verification-oriented service life cycle.}, keywords = {continuous lifelong verification, formal verification, monitoring, service contracts, service life cycles, service-oriented systems, software architecture, software engineering}, doi = {10.1109/PESOS.2009.5068828}, author = {Domenico Bianculli and Carlo Ghezzi and Cesare Pautasso} } @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 {ibm:2007:agtive, title = {Combining Quality Assurance and Model Transformations in Business-Driven Development}, booktitle = {Third International Symposium on Applications of Graph Transformations with Industrial Relevance (AGTIVE 2007)}, year = {2007}, month = {October}, pages = {1-16}, abstract = {Business-driven development is a methodology for developing IT solutions that directly satisfy business requirements. At its core are business processes, which are usually modeled by combining graphical and textual notations. During business-driven development, business process models are taken to the IT level, where they are implemented in a Service-Oriented Architecture. A major challenge in business-driven development is the semantic gap between models captured at the business and the IT level. Model transformations play a major role in bridging this gap. This paper presents a transformation framework for IBM WebSphere Business Modeler that enables programmers to quickly develop in-place model transformations, which are then made available to users of this tool. They address various user needs such as quickly correcting modeling errors, refining a process model, or applying a number of refactoring operations. Transformations are combined with quality assurance techniques, which help users to preserve or improve the correctness of their business process models when applying transformations. }, keywords = {business driven development, model-driven engineering}, doi = {10.1007/978-3-540-89020-1_1}, author = {Jana Koehler and Thomas Gschwind and Jochen Malte K{\"u}ster and Cesare Pautasso and Ksenia Ryndina and Jussi Vanhatalo and Hagen V{\"o}lzer} } @article {119, title = {Developing scientific workflows from heterogeneous services}, journal = {SIGMOD Rec.}, volume = {35}, year = {2006}, month = {June}, pages = {22{\textendash}28}, abstract = {Scientific Workflows (SWFs) need to utilize components and applications in order to satisfy the requirements of specific workflow tasks. Technology trends in software development signify a move from component-based to service-oriented approach, therefore SWF will inevitably need appropriate tools to discover and integrate heterogeneous services. In this paper we present the SODIUM platform consisting of a set of languages and tools as well as related middleware, for the development and execution of scientific workflows composed of heterogeneous services.}, keywords = {JOpera, scientific workflow management}, issn = {0163-5808}, doi = {10.1145/1147376.1147380}, author = {Aphrodite Tsalgatidou and Georgios Athanasopoulos and Michael Pantazoglou and Cesare Pautasso and Thomas Heinis and Roy Gr{\o}nmo and Hoff Hj{\o}rdis and Arne-J{\o}rgen Berre and Magne Glittum and Simela Topouzidou} }