@book {emap2015, title = {Just send an email: Anti-patterns for email-centric organizations}, year = {In Press}, publisher = {LeanPub}, organization = {LeanPub}, abstract = {Anti-patterns are practices that despite their negative consequences continue to be applied due to their low cost, ease of use and apparent good fit to solve pressing problems. It is possible to outgrow them by learning that a better way exists. While many organizations already learned how to take full advantage of business process management methods and tools, many still live in a world where email is the main (sometimes the only) tool used for internal and external communication, coordination and collaboration. Emails continue to provide a very fast and flexible asynchronous communication medium between two or more people, which however comes with many pitfalls. In this book published on LeanPub we present our ongoing work towards uncovering email anti-patterns which we have actually observed in the field. Some examples of anti-patterns we have uncovered so far are: Unsecured Sensitive Mail, Monday Morning Mail, 5pm Reply, Redirect, Re:gret, Ticketless Support, On Behalf, Fuzzy Link, Attached Body, Collaborative Edit, Datamail, Unintended Reply-To-All, Total Recall, Lightning Reply, Untimely Reminder, Mail from the Grave, Mail-Call-Meet and META SPAM. }, keywords = {anti-patterns, email}, isbn = {979-8871441718}, issn = {979-8871782873}, url = {https://leanpub.com/email-antipatterns/}, author = {Cesare Pautasso} } @conference {apiace:2024:msr, title = {APIstic: A Large Collection of OpenAPI Metrics}, booktitle = {21st IEEE/ACM International Conference on Mining Software Repositories (MSR)}, year = {2024}, note = {(to appear)}, month = {April}, address = {Lisbon, Portugal}, abstract = {In the rapidly evolving landscape of web services, the significance of efficiently designed and well-documented APIs is paramount. In this paper, we present APIstic an API analytics dataset and exploration tool to navigate and segment APIs based on an extensive set of precomputed metrics extracted from OpenAPI specifications, sourced from GitHub, SwaggerHub, BigQuery and APIs.guru. These pre-computed metrics are categorized into structure, data model, natural language description, and security metrics. The extensive dataset of varied API metrics provides crucial insights into API design and documentation for both researchers and practitioners. Researchers can use APIstic as an empirical resource to extract refined samples, analyze API design trends, best practices, smells, and patterns. For API designers, it serves as a benchmarking tool to assess, compare, and improve API structures, data models, and documentation using metrics to select points of references among 1,275,568 valid OpenAPI specifications. The paper discusses potential use cases of the collected data and presents a descriptive analysis of selected API analytics metrics. }, keywords = {dataset, metrics, OpenAPI}, author = {Souhaila Serbout and Cesare Pautasso} } @proceedings {2024:asianplop, title = {Decentralized Task Execution Patterns}, year = {2024}, month = {March}, address = {Fujisawa City, Kanagawa Prefecture, Japan}, abstract = {Decentralized task execution requires to assign planning, execution and control roles and responsibilities to at least two distinct parties. These include making decisions about {\textquoteleft}{\textquoteleft}who does what when{\textquoteright}{\textquoteright} so that one party can track the progress and the outcome of tasks executed by another party. In this paper we outline the design space for decentralized task execution by presenting 18 different patterns, going from imperative task execution all the way to autonomous task execution. We will distinguish how decisions about who performs a task, what needs to be done and when to do it can be made by different parties and how these alternative decision-making locations impact the interactions between the parties responsible to plan, execute and control the task execution. The patterns are applicable within human organizations with many actors delegating or performing multiple tasks but also to fully automated systems, e.g., distributed operating systems, intelligent autonomous vehicles, blockchain-based workflow engines or high throughput job schedulers.}, keywords = {patterns, Workflow Management Systems, workflow patterns}, author = {Cesare Pautasso} } @conference {apiace:2024:icwe, title = {How Many Web APIs Evolve Following Semantic Versioning?}, booktitle = {24th International Conference on Web Engineering (ICWE)}, year = {2024}, month = {June}, address = {Tampere, Finland}, keywords = {API Analytics, API Evolution, Semantic Versioning, Web API}, author = {Souhaila Serbout and Cesare Pautasso} } @conference {apiace:2023:europlop, title = {API Rate Limit Adoption - A Pattern Collection}, booktitle = {28th European Conference on Pattern Languages of Programs (EuroPLoP 2023)}, year = {2023}, month = {July}, publisher = {ACM}, organization = {ACM}, address = {Kloster Irsee, Germany}, keywords = {API Design Patterns}, doi = {10.1145/3628034.3628039}, url = {https://dl.acm.org/doi/10.1145/3628034.3628039}, author = {Souhaila Serbout and Amine El Malki and Cesare Pautasso and Uwe Zdun} } @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} } @conference {liquid:2023:iedge, title = {A brief history of liquid software}, booktitle = {iEDGE Symposium on Intelligent Edge Computing and Communications}, year = {2023}, month = {July}, pages = {354--363}, publisher = {IEEE}, organization = {IEEE}, address = {Chicago, USA}, abstract = {The concept of liquid software, i.e., software with flexible deployment, over the past two decades has appeared in the fields of edge computing, Internet of Things (IoT), Human-Computer Interaction, DevOps and Web engineering. In this paper, we survey, compare, and provide a comprehensive definition of liquid software by analyzing how the metaphor has been used in existing literature and identifying gaps and inconsistencies in the current vs. past understanding of the concept. Overall, liquid software can be seamlessly deployed and redeployed within a dynamic and distributed runtime environment in response to changes applied to the set of available devices and to the software itself. Liquid software has been introduced in the context of active networks and intelligent environments, it has been applied to describe the user interaction with multi and cross-device user interfaces, it has found a promising foundation in Web technology, continuous software delivery pipelines, as well as isomorphic software architectures running across the IoT, edge and Cloud continuum.}, keywords = {liquid software}, doi = {10.1109/EDGE60047.2023.00058}, author = {Cesare Pautasso} } @inbook {sa:2023:empirical, title = {An Empirical Basis for Software Architecture Research}, booktitle = { Software Architecture - Research Roadmaps from the Community }, year = {2023}, pages = {87 - 100}, publisher = {Springer}, organization = {Springer}, abstract = {Despite the clear need for and importance of performing empirical studies as part of software architecture research, there is still a lack of curated, standardized, clean, well-maintained, documented, easily accessible, reusable, and shared datasets. In this chapter, we provide an overview of the problems, of the motivations, and of the opportunities currently related to mining and sharing datasets for researchers in software architecture. We first explore and describe which artifacts should be included into such datasets, such as code, documentation, and requirements, but also including other architecturally relevant artifacts, such as architectural decision records, models, and other kinds of documentation. This information can be complemented with revision history logs, social metadata, and email or chat discussion archives. The availability of such datasets would enable not only architectural reconstruction studies but would also help to catalyze broader and more ambitious program of empirical studies in software architecture research.}, keywords = {software architecture}, isbn = {978-3-031-36846-2}, doi = {10.1007/978-3-031-36847-9_5}, url = {https://link.springer.com/chapter/10.1007/978-3-031-36847-9_5}, author = {Rick Kazman and Roberto Tonelli and Cesare Pautasso}, editor = {Pelliccione, Patrizio and Kazman, Rick and Weber, Ingo and Liu, Anna} } @conference {apiace:2023:icwe, title = {An empirical study of Web API versioning practices}, booktitle = {23rd International Conference on Web Engineering (ICWE)}, year = {2023}, month = {June}, publisher = {Springer}, organization = {Springer}, address = {Alicante, Spain}, abstract = {As Web APIs evolve, developers assign them version identifiers to reflect the amount and the nature of changes that the API clients should expect. In this work we focus on identifying versioning practices adopted by Web API developers by extracting and classifying version identifiers found in a large collection of OpenAPI descriptions. In particular, we observe how frequently different versioning schemes have been adopted for identifying both stable and preview releases (e.g., simple version counters, semantic versioning, or release timestamps). We further study the stability of versioning schemes during APIs evolution. We also detect APIs which offer dynamic access to versioning metadata through dedicated endpoints as well as APIs which support clients expecting to reach up to 14 different versions of the same API at the same time. Overall the results offer a detailed view over current Web API versioning practices and can serve as the basis for future discussions on how to standardize critical API versioning metadata.}, keywords = {API Analytics, Versioning}, author = {Souhaila Serbout and Cesare Pautasso} } @conference {apiace:2023:vissoft, title = {Interactively exploring API changes and versioning consistency}, booktitle = {11th IEEE Working Conference on Software Visualization (VISSOFT 2023)}, year = {2023}, month = {October}, pages = {28-39}, publisher = {IEEE}, organization = {IEEE}, address = {Bogota, Colombia}, abstract = {Application Programming Interfaces (APIs) evolve over time. As they change, they are expected to be versioned based on how changes might affect their clients. In this paper, we present two novel visualizations specifically designed to represent all structural changes and the level of adherence to semantic versioning practices over time. They can also serve for characterizing and comparing the evolution history of different Web APIs. The API VERSION CLOCK helps to visualize the sequence of API changes over time and highlight inconsistencies between major, minor, or patch version changes and the corresponding introduced breaking or non-breaking changes applied to the API. The API CHANGES overview aggregates all changes to an OpenAPI (OAS) description, highlighting the unstable vs. the stable elements of the API over its entire history. Both visualizations can be automatically created using the APICTURE, a command-line and web-based tool that analyzes the histories of git code repositories containing OAS descriptions, extracting the necessary data for generating visualizations and computing metrics related to API evolution and versioning. The visualizations have been successfully applied to classify, compare, and interactively explore the multi-year evolution history of APIs with up to hundreds of individual commits.}, keywords = {API Versioning; Software Visualization}, doi = {10.1109/VISSOFT60811.2023.00013}, url = {https://ieeexplore.ieee.org/document/10350155}, author = {Souhaila Serbout and Diana Carolina Mu{\~n}oz Hurtado and Cesare Pautasso} } @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} } @book {2023:map, title = {Patterns for API Design: Simplifying Integration with Loosely Coupled Message Exchanges}, series = {Addison-Wesley Signature Series (Vernon)}, year = {2023}, pages = {544}, publisher = {Pearson Education}, organization = {Pearson Education}, abstract = {Proven Patterns for Designing Evolvable High-Quality APIs--For Any Domain, Technology, or Platform APIs enable breakthrough innovation and digital transformation in organizations and ecosystems of all kinds. To create user-friendly, reliable and well-performing APIs, architects, designers, and developers need expert design guidance. This practical guide cuts through the complexity of API conversations and their message contents, introducing comprehensive guidelines and heuristics for designing APIs sustainably and specifying them clearly, for whatever technologies or platforms you use. In Patterns for API Design: Simplifying Integration with Loosely Coupled Message Exchanges, five expert architects and developers cover the entire API lifecycle, from launching projects and establishing goals through defining requirements, elaborating designs, planning evolution, and creating useful documentation. They crystallize the collective knowledge of many practitioners into 44 API design patterns, consistently explained with context, pros and cons, conceptual solutions, and concrete examples. To make their pattern language accessible, they present a domain model, a running case study, decision narratives with pattern selection options and criteria, and walkthroughs of real-world projects applying the patterns in two different industries.}, keywords = {API Design Patterns}, isbn = {9780137670017}, url = {https://api-patterns.org}, author = {Olaf Zimmermann and Mirko Stocker and Daniel L{\"u}bke and Uwe Zdun and Cesare Pautasso} } @conference {2022:sose:ccc, title = {Cargo-Cult Containerization: A Critical View of Containers in Modern Software Development}, booktitle = {16th International Conference on Service-Oriented System Engineering (SOSE 2022)}, year = {2022}, month = {August}, publisher = {IEEE}, organization = {IEEE}, address = {San Francisco, USA}, abstract = {Software is increasingly developed and deployed using containers. While the concept of a container is conceptually straightforward, there are various issues to be considered while using them, ranging from technical details inside containers to the orchestration of containers that jointly form a meaningful application. In recent years, the use of containers has become so prevalent that developers have a tendency to resort to cargo-cult containerization {\textendash} ritual adherence to the use of containers just because so many others are doing the same thing. In this paper, we study advantages and downsides of containers in modern- day software development. We foresee the use of containers to spread into new areas, including IoT systems and embedded devices. At the same time, we caution against indiscriminate use of containers, since excessive containerization can have adverse impacts on software maintenance and overall complexity of a system architecture.}, keywords = {containers, software architecture}, author = {Tommi Mikkonen and Cesare Pautasso and Kari Systa and Antero Taivalsaari} } @demo {2022:ecsa:expresso, title = {ExpressO: From Express.js implementation code to OpenAPI interface descriptions}, year = {2022}, month = {September}, pages = {29{\textendash}44}, publisher = {Springer}, abstract = {This tool demo paper brings forward a new CLI tool called ExpressO for developers who need to analyze a Web API implemented using the Express.js framework and automatically extract a specification written in the standard OpenAPI interface description language. The specification includes all of the implemented endpoints along with their response status codes and path and query parameters. Developers can use it to automatically determine whether the interface of a Web API matches its implementation based on the Express.js framework. The tool has been released on the npm component registry as {\textquoteleft}expresso-api{\textquoteright}. }, keywords = {API, express.js, OpenAPI}, doi = {10.1007/978-3-031-36889-9_4}, author = {Souhaila Serbout and Alessandro Romanelli and Cesare Pautasso} } @conference {apiace:2022:icws, title = {How Composable is the Web? An Empirical Study on OpenAPI Data model Compatibility}, booktitle = {IEEE World Congress on Services (ICWS Symposium on Services for Machine Learning)}, year = {2022}, month = {July}, publisher = {IEEE}, organization = {IEEE}, address = {Barcelona, Spain}, abstract = {Composing Web APIs is a widely adopted practice by developers to speed up the development process of complex Web applications, mashups, and data processing pipelines. However, since most publicly available APIs are built independently of each other, developers often need to invest their efforts in solving incompatibility issues by writing ad-hoc glue code, adapters and message translation mappings. How likely are Web APIs to be directly composable? The paper presents an empirical study to determine the potential composability of a large collection of 20,587 public Web APIs by verifying their schemas{\textquoteright} compatibility. We define three levels of data model elements compatibility -- considering matches between property names and/or data types -- which can be determined statically based on API descriptions conforming to the OpenAPI specification. The study research questions address: to which extent are Web APIs compatible; the average number of compatible endpoints within each API; the likelihood of finding two APIs with at least one pair of compatible endpoints. To perform the analysis we developed a compatibility checker tool which can statically determine API schema compatibility on the three levels and find matching pairs of API responses which can be directly forwarded as requests to the same or other APIs. We run the tool on a dataset of 751,390 request and response message schemas extracted from publicly available OpenAPI descriptions. The results indicate a relatively high number of compatible APIs when matching their data models only on the level of their elements{\textquoteright} data type. However, this number gets lower narrowing the scope to only the ones handling data objects having identical properties name. The average likelihood of finding two compatible APIs with both matching property names and data types reaches 21\%. Also, the number of compatible endpoints within the same API is very low.}, keywords = {API Analytics, empirical study, mashups, OpenAPI, Web APIs}, author = {Souhaila Serbout and Cesare Pautasso and Uwe Zdun} } @conference {2022:sose:apiace, title = {Impact of API Rate Limit on Reliability of Microservices- Based Architectures}, booktitle = {16th International Conference on Service-Oriented System Engineering (SOSE 2022)}, year = {2022}, month = {August}, publisher = {IEEE}, organization = {IEEE}, address = {San Francisco, USA}, abstract = {Many API patterns and best practices have been developed around microservices-based architectures, such as Rate Limiting and Circuit Breaking, to increase quality properties such as reliability, availability, scalability, and performance. Even though estimates on such properties would be beneficial, especially during the early design of such architectures, the real impact of the patterns on these properties has not been rigorously studied yet. This paper focuses on API Rate Limit and its impact on reliability properties from the perspective of API clients. We present an analytical model that considers specific workload configurations and predefined rate limits and then accurately predicts the success and failure rates of the back-end services. The model also presents a method for adaptively fine-tuning rate limits. We performed two extensive data experiments to validate the model and measured Rate Limiting impacts, firstly on a private cloud to minimize latency and other biases, and secondly on the Google Cloud Platform to test our model in a realistic cloud environment. In both experiments, we observed a low percentage of prediction errors. Thus, we conclude that our model can provide distributed system engineers and architects with insights into an acceptable value for the rate limits to choose for a given workload. Very few works empirically studied the impact of Rate Limit or similar API-related patterns on reliability.}, keywords = {API Analytics}, author = {Amine El Malki and Uwe Zdun 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} } @conference {apiace:2022:ecsa, title = {To deprecate or to simply drop operations? An empirical study on the evolution of a large OpenAPI collection}, booktitle = {16th European Conference on Software Architecture (ECSA)}, volume = {13444}, year = {2022}, month = {September}, pages = {38-46}, publisher = {Springer}, organization = {Springer}, address = {Prague, Czech Republic}, keywords = {API Analytics, API Evolution}, doi = {doi.org/10.1007/978-3-031-16697-6_3}, author = {Fabio Di Lauro and Souhaila Serbout and Cesare Pautasso} } @conference {2022:icsa, title = {Web APIs Structures and Data Models Analysis}, booktitle = {19th IEEE International Conference on Software Architecture (ICSA 2022)}, year = {2022}, month = {March}, publisher = {IEEE}, organization = {IEEE}, address = {Honululu, Hawaii}, abstract = {Microservice architectures emphasize keeping components small, to foster autonomy, low coupling, and independent evolution. In this large-scale empirical study, we measure the size of Web API specifications mined from open source repositories. These APIs are modeled using the OpenAPI Specification (OAS), which, in addition to documenting the offered operations, also contain schemas definitions for the data exchanged with the API request and response message payloads. This study has as a goal to build empirical knowledge about: (1) How big and diverse are real-world web APIs both in terms of their operations and data, (2) How different API structures use and reuse schema definitions. By mining public software repositories on Github, we gathered 42,194 valid OAS specifications published between 2014-2021. }, keywords = {API Analytics, API Size, OpenAPI}, author = {Souhaila Serbout and Fabio Di Lauro and Cesare Pautasso} } @book {2021:bapie, title = {Beautiful API Evolution}, year = {2021}, publisher = {LeanPub}, organization = {LeanPub}, abstract = {This book presents the catalog of a virtual exhibition featuring different visualizations of the structural evolution of 51 Web APIs of different sizes and shapes, showing how they mostly grow but sometimes also shed some dead branches over the years. The diagrams are drawn based on the exact OpenAPI specifications as they were versioned on some open source repository. While there are many books on how to improve the design of existing APIs, the goal of this book is to show a small sample of actual API designs undergoing change. Learn from these examples to avoid false starts and discover which structures turn out to be stable over the years. All APIs represented are Web APIs: they come from the age when many attempted with very different results to use the HTTP protocol to remotely invoke software delivered as a service. The APIs have been selected mainly due to their visual appearance.}, keywords = {API, API Evolution, visualization}, url = {https://leanpub.com/beautiful-api-evolution/}, author = {Cesare Pautasso} } @book {bapis2021, title = {Beautiful APIs}, year = {2021}, publisher = {LeanPub}, organization = {LeanPub}, abstract = {This book presents the catalog of a virtual exhibition featuring the structural visualizations of 93 Web APIs of different sizes and shapes. The diagrams are drawn based on the exact API specification found on some open source repository. While there are many books on how to design good APIs, the goal of this book is to show a small sample of actual API designs. There is a lot that can be learned from them. All APIs represented are Web APIs: they come from the time when many attempted with very different results to use the HTTP protocol to remotely invoke software delivered as a service. The APIs have been selected mainly due to their visual appearance.}, keywords = {API visualization, software architecture}, url = {https://leanpub.com/beautiful-apis/}, author = {Cesare Pautasso} } @book {2021:bpm, title = {Business Process Modeling, Management, and Mining: visual lecture notes}, year = {2021}, publisher = {LeanPub}, organization = {LeanPub}, abstract = {Processes are everywhere. Learn how to recognize them using process modeling, reconstruct them with process mining, improve them with process simulation, and run them with process automation. And yes, also visualize them with the Business Process Model and Notation (BPMN). These are the revised and illustrated notes of the BPM3 lecture of the Master in Management and Informatics held at the Faculty of Informatics and Economics at USI Lugano, Switzerland during the Spring of 2020. The book includes the slides and the script for all lectures:
  1. Introduction
  2. Modeling
  3. BPMN
  4. Mining
  5. Improvement
  6. Simulation
  7. Automation
}, url = {leanpub.com/business-process-management/}, author = {Cesare Pautasso} } @conference {2021:europlop:api-fragments, title = {From OpenAPI Fragments to API Pattern Primitives and Design Smells}, booktitle = {European Conference on Pattern Languages of Programs (EuroPLoP{\textquoteright}21)}, year = {2021}, month = {July}, publisher = {ACM}, organization = {ACM}, address = {Virtual Kloster Irsee, Germany}, abstract = {In the past few years, the OpenAPI Specification (OAS) has emerged as a standard description language for accurately modeling Web APIs. Today, thousands of OpenAPI descriptions can be found by mining open source repositories. In this paper, we attempt to exploit these artifacts to extract commonly occurring building blocks used in Web API structures, in order to assist Web API designers in their modelling task. Our work is based on a fragmentation mechanism, that starts from OpenAPI descriptions of Web APIs to extract their structures, then fragment these structures into smaller blocks. This approach enabled us to extract a large dataset of reoccurring fragments from a collection of 6619 API specifications. Such fragments have been found multiple times in the same or across different APIs. We have classified the most reoccurring fragments into four pattern primitives used to expose in the API access to collections of items. We distinguish for each primitive variants from design smells. This classification is based on the specific combinations of operations associated with the collection items and on an in-depth analysis of their natural language labels and descriptions. The resulting pattern primitives are intended to support designers who would like to introduce one or more collections for a specific class of items in their HTTP-based API.}, keywords = {API, API fragments, design smells, OpenAPI, patterns}, doi = {10.1145/3489449.3489998}, url = {https://zenodo.org/record/5727094$\#$.YZ97mFMo-0o}, author = {Souhaila Serbout and Cesare Pautasso and Uwe Zdun and Olaf Zimmermann} } @conference {2021:icwe:fullstack, title = {Full Stack is Not What It Used to Be}, booktitle = {21st International Conference on Web Engineering (ICWE2021)}, year = {2021}, month = {May}, publisher = {Springer}, organization = {Springer}, address = {Biarritz, France}, abstract = {The traditional definition of full stack development refers to a skill set that is required for writing software both for the frontend and backend of a web application or site. In recent years, the scope of full stack development has expanded significantly, though. Today, a full stack software developer is assumed to master various additional areas especially related to cloud infrastructure and deployment, message brokers and data analytics technologies. In addition, the emergence of Internet of Things (IoT) and the rapidly spreading use of AI/ML technologies are introducing additional skill set requirements. In this paper, we discuss the expectations for a modern full stack developer based on our industry observations, and argue that these expectations have significant implications for software and web engineering education.}, keywords = {Cloud, Education, Internet of Things, IoT, Programmable World, software architecture, software engineering, Web engineering}, doi = {10.1007/978-3-030-74296-6_28}, author = {Antero Taivalsaari and Tommi Mikkonen and Cesare Pautasso and Kari Systa} } @article {2021:computer, title = {Isomorphic Internet of Things Architectures With Web Technologies}, journal = {Computer}, volume = {54}, year = {2021}, month = {July}, pages = {69--78}, abstract = {Internet of Things development needs isomorphic software architectures, in which every kind of device can be programmed with a consistent set of implementation technologies, allowing applications and their components to be statically deployed or dynamically migrated without having to change their shape.}, keywords = {Internet of Things, Isomorphic Architecture, Web}, doi = {10.1109/MC.2021.3074258}, url = {https://ieeexplore.ieee.org/document/9473238}, author = {Tommi Mikkonen and Cesare Pautasso and Antero Taivalsaari} } @conference {2021:plop, title = {Patterns on Designing API Endpoint Operations}, booktitle = {28th Conference on Pattern Languages of Programs (PLoP{\textquoteright}21)}, year = {2021}, month = {October}, publisher = {ACM}, organization = {ACM}, address = {Virtual}, abstract = {Domain-driven design (DDD) is often applied when implementing microservices or communicating through APIs in distributed systems. APIs expose a published language that provides a view on entire domain models or subsets of such models. Hence, tactical DDD patterns such as Aggregate, Service, and Entity may not only structure API implementations, but also guide API specification work. In our previous work, we described endpoint-level patterns for this context. In this paper, we present three complementary patterns, namely Aggregated Domain Operation on API Endpoint, Event-Based API Endpoint Operation, and CRUD-Based API Operation. These patterns aim to derive API operations from the operations of Domain Services and Entities as well as Domain Events. We also discuss variants of these patterns, such as their combination with the patterns Command Query Responsibility Segregation (CQRS) and Publish/Subscribe. Our pattern mining work is based on a data set from an empirical study of 32 grey literature sources investigating practitioner views on deriving API designs from DDD models.}, keywords = {API, Domain-Driven Design}, author = {Apitchaka Singjai and Uwe Zdun and Olaf Zimmermann and Mirko Stocker and Cesare Pautasso} } @conference {2021:icwe:api-evolution, title = {Towards Large-scale Empirical Assessment of Web APIs Evolution}, booktitle = {21st International Conference on Web Engineering (ICWE2021)}, year = {2021}, month = {May}, pages = {124-138}, publisher = {Springer}, organization = {Springer}, address = {Biarritz, France}, abstract = {Web Application Programming Interfaces (APIs) decouple the internal implementation of a service from its consumers which can reuse and compose them to rapidly build new applications. Many Web APIs are described with the OpenAPI Specification (OAS). The goal of our research is to check the feasibility of using API descriptions found in public open source repositories to study how APIs evolve over time. To do so, we collected a large dataset of OAS documents by crawling open source repositories, we parsed the corresponding metadata and measured the API size in order to extract a simple model to track the lifecycle of API artifacts and observe common evolution behaviors. Our preliminary results indicate that only a subset of the APIs changes, but as opposed to the expectation that APIs should only grow to maintain backward compatibility we also detected a number of APIs with a more variable history. We also study the stability of API artifacts over time and whether APIs are more or less likely to change as they age.}, keywords = {API Evolution, OpenAPI, Web API}, doi = {10.1007/978-3-030-74296-6_10}, author = {Fabio Di Lauro and Souhaila Serbout and Cesare Pautasso} } @conference {2021:icwe:liquid-wasm, title = {WebAssembly Modules as Lightweight Containers for Liquid IoT Applications}, booktitle = {21st International Conference on Web Engineering (ICWE2021)}, year = {2021}, month = {May}, publisher = {Springer}, organization = {Springer}, address = {Biarritz, France}, abstract = {Going all the way to IoT with web technologies opens up the door to isomorphic IoT system architectures, which deliver flexible deployment and live migration of code between any device in the overall system. In this vision paper, we propose using WebAssembly to implement lightweight containers and deliver the required portability. Our long-term vision is to use the technology to support developers of liquid IoT applications offering seamless, hassle-free use of multiple devices.}, keywords = {containers, Internet of Things, IoT, Light-weight containers, liquid software, Web of Things, WebAssemly, WoT}, author = {Niko M{\"a}kitalo and Tommi Mikkonen and Cesare Pautasso and Victor Bankowski and Paulius Daubaris and Risto Mikkola and Oleg Beletski} } @conference {2020:bpmn-sketch-miner:models, title = {From Text to Visual BPMN Process Models: Design and Evaluation}, booktitle = {23rd International Conference on Model Driven Engineering Languages and Systems (MODELS)}, year = {2020}, month = {October}, pages = {229{\textendash}239}, publisher = {ACM/IEEE}, organization = {ACM/IEEE}, address = {Montreal, Canada}, abstract = {Most existing Business Process Model and Notation (BPMN) editing tools are graphical, and as such based on explicit modeling, requiring good knowledge of the notation and its semantics, as well as the ability to analyze and abstract business requirements and capture them by correctly using the notation. As a consequence, their use can be cumbersome for live modeling during interviews and design workshops, where participants should not only provide input but also give feedback on how it has been represented in a model. To overcome this, in this paper we present the design and evaluation of BPMN Sketch Miner, a tool which combines notes taking in constrained natural language with process mining to automatically produce BPMN diagrams in real time as interview participants describe them with stories. In this work we discuss the design decisions regarding the trade-off between using mining vs. modelling in order to: 1) support a larger number of BPMN constructs in the textual language; 2) target both BPMN beginners and business analysts, in addition to the process participants themselves. The evaluation of the new version of the tool in terms of how it balances the expressiveness and learnability of its DSL with the usability of the text-to-visual sketching environment shows encouraging results. Namely while BPMN beginners could model a non-trivial process with the tool in a relatively short time and with good accuracy, business analysts appreciated the usability of the tool and the expressiveness of the language in terms of supported BPMN constructs.}, keywords = {BPMN, domain specific languages, live modeling, text to visual}, doi = {10.1145/3365438.3410990}, author = {Ana Ivanchikj and Souhaila Serbout and Cesare Pautasso} } @conference {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} } @article {2020:asq:sle, title = {Role of interactive presentation platform ASQ in delivering web design course}, journal = {Smart Learning Environments}, volume = {7}, year = {2020}, month = {May}, abstract = {Contemporary technology enhanced learning together with different innovative learning methodologies are significantly initiating progress in educational ecosystems. Educational systems and tools that invoke active participation of learners are excellent facilitators of modern education. One such system is ASQ. ASQ is an interactive presentation platform that allows teachers to incorporate interactive questions in their presentations. Learners are then answering these questions on site on their digital devices. In that way teachers have immediate feedback from learners, allowing them to adjust course of presentation. In this paper we tried to determine in what extent is ASQ beneficial for learners. For that purpose we conducted analysis on the data collected from Web Design course, where ASQ was utilized during two school years. Results of the analysis suggest that ASQ has a positive influence on learners{\textquoteright} acquired knowledge.}, keywords = {Active learning, ASQ, Interactive presentations, Web design}, doi = {10.1186/s40561-020-00123-w}, author = {Brankica Brati{\'c} and Vasileios Triglianos and Vladimir Kurbalija and Cesare Pautasso and Mirjana Ivanovic} } @book {book:sa, title = {Software Architecture: visual lecture notes}, year = {2020}, publisher = {LeanPub}, organization = {LeanPub}, abstract = {From quality attributes to how to design and model components, interfaces, connectors, containers, all the way to services and microservices. These are the revised and illustrated notes of the Software Architecture lecture of the Master in Software and Data Engineering held at the Software Institute at USI Lugano, Switzerland during the Spring of 2020. The book includes the script for these lectures:
  1. Introduction
  2. Quality Attributes
  3. Definitions
  4. Modeling Software Architecture
  5. Modularity and Components
  6. Reusability and Interfaces
  7. Composability and Connectors
  8. Compatibility and Coupling
  9. Deployability, Portability and Containers
  10. Scalability
  11. Availability and Services
  12. Flexibility and Microservices
}, keywords = {software architecture}, url = {https://leanpub.com/software-architecture/}, author = {Cesare Pautasso} } @conference {2019:icpe:benchflow, title = {Behavior-driven Load Testing Using Contextual Knowledge {\textemdash} Approach and Experiences}, booktitle = {10th ACM/SPEC International Conference on Performance Engineering (ICPE 2019)}, year = {2019}, month = {April}, pages = {265-272}, publisher = {ACM/SPEC}, organization = {ACM/SPEC}, address = {Mumbai, India}, abstract = {Load testing is widely considered a meaningful technique for performance quality assurance. However, empirical studies reveal that in practice, load testing is not applied systematically, due to the sound expert knowledge required to specify, implement, and execute load tests. Our Behavior-driven Load Testing (BDLT) approach eases load test specification and execution for users with no or little expert knowledge. It allows a user to describe a load test in a template based on natural language and to rely on an automated framework to execute the test. Utilizing the system{\textquoteright}s contextual knowledge such as workload-influencing events, the framework automatically determines the workload and test configuration. We investigated the applicability of our approach in an industrial case study, where we were able to express four load test concerns using BDLT and received positive feedback from our industrial partner. They understood the BDLT definitions well and proposed further applications, such as the usage for software quality acceptance criteria.}, keywords = {BenchFlow, Performance Testing}, doi = {10.1145/3297663.3309674}, author = {Henning Schulz and Du{\v s}an Okanovi{\'c} and Andr{\'e} van Hoorn and Vincenzo Ferme and Cesare Pautasso} } @book {2019:book:esdebp, title = {Empirical Studies on the Development of Executable Business Processes}, year = {2019}, pages = {223}, publisher = {Springer}, organization = {Springer}, abstract = {This book collects essential research on the practical application of executable business process modeling in real-world projects, i.e., model-driven solutions for the support and automation of digital business processes that are created using languages such as BPEL or BPMN. It mainly focuses on empirical research, but also includes an up-to-date cross-section of case studies in order to assess examples of BPM{\textquoteright}s practical impact in the industry. On the one hand, executable models are formally and precisely defined so that computers can interpret and execute them; on the other, they are visualized so that humans can describe, document and optimize business processes at a higher level of abstraction than with traditional textual programming languages. While these important research areas have long been separated from one another, this book is an attempt at cross-fertilization, driven by the insight that business processes are the software behind today{\textquoteright}s digital organizations, and that achieving a precise representation of such processes is key to their reliable execution. Consequently, the book presents various case studies and experiments that investigate questions of interest to both academia (e.g., identifying challenges for which no solution exists; sharing new insights into how existing approaches are actually used) and industry (e.g., guidelines on using certain technologies and on modeling comprehensible and executable processes). Both researchers and practitioners will benefit from the presentation of how concepts are transformed into working solutions. The studies are presented in a structured manner and with sufficient rigor to be considered empirical research, further enhancing the book{\textquoteright}s value for the research community, while practitioners will find concrete guidance on making the right decisions for their projects.}, keywords = {business process management, empirical business process management, executable business process modeling}, issn = {978-3-030-17665-5}, doi = {10.1007/978-3-030-17666-2}, editor = {Daniel L{\"u}bke and Cesare Pautasso} } @article {2019:askalot, title = {Employing community question answering for online discussions in university courses: Students{\textquoteright} perspective}, journal = {Computers \& Education}, volume = {135}, year = {2019}, month = {July}, pages = {75-90}, abstract = {In university courses as well as in MOOCs, Community Question Answering (CQA) systems have been recently recognized as a promising alternative to standard discussion forums for mediating online discussions. Despite emerging research on educational CQA systems, a study investigating when and how to use these systems to support university education is still missing. We stress that such a study should effectively take into account students{\textquoteright} perceptions of CQA systems rather than relying solely on an analysis of their effective usage based on data available in system logs. This paper therefore systematically analyzes perspective of 182 computer science students from three universities located in three different countries on concept of educational CQA systems. Students{\textquoteright} opinions were collected using a questionnaire that was designed to assess conceptual issues of using CQA systems in university education, their core features as well as particular implementation of our CQA system Askalot. The analysis of collected responses based on non-parametric statistical tests revealed that there are various significant differences in the perception of CQA systems between different types of students (e.g. passive and active) and in different deployment settings (e.g. when using CQA in a small number of 1{\textendash}3 courses during one academic year or in 50 courses for 5 years). The obtained findings supported by content and usage analysis finally resulted into the summary of 12 main characteristics of CQA systems which describe their suitability for mediating online discussions in different deployment settings and for different types of students.}, keywords = {askalot, Community question answering, Computer-mediated communication, Learning communities, Qualitative study, SCOPES}, doi = {https://doi.org/10.1016/j.compedu.2019.02.017}, url = {https://authors.elsevier.com/a/1YioE1HucdHyDo}, author = {Ivan Srba and Milos Savic and Maria Bielikova and Mirjana Ivanovic and Cesare Pautasso} } @conference {2019:map:europlop, title = {Interface Evolution Patterns {\textemdash} Balancing Compatibility and Flexibility across Microservices Lifecycles}, booktitle = {24th European Conference on Pattern Languages of Programs (EuroPLoP 2019)}, year = {2019}, month = {July}, publisher = {ACM}, organization = {ACM}, address = {Irsee, Germany}, abstract = {Remote Application Programming Interfaces (APIs) are technology enablers for distributed system trends such as cloud-native application development. API providers find it hard to design their remote APIs so that they can be evolved easily; refactoring and extending an API while preserving backward compatibility is particularly challenging. If APIs are evolved poorly, clients are critically impacted; high costs to adapt and compensate for downtimes may result. For instance, if an API provider publishes a new incompatible API version, existing clients might break and not function properly until they are upgraded to support the new version. Hence, applying adequate strategies for evolving service APIs is one of the core problems in API governance, which in turn is a prerequisite for successfully integrating service providers with their clients in the long run. Although many patterns and pattern languages are concerned with API and service design and related integration technologies,patterns guiding the evolution of APIs are missing to date. Extending our pattern language on Microservice API Patterns (MAP), we introduce a set of patterns focusing on API evolution strategies in this paper: API Description, Version Identifier, Semantic Versioning, Eternal Lifetime Guarantee, Limited Lifetime Guarantee, Two in Production, Aggressive Obsolescence, and Experimental Preview.The patterns have been mined from public Web APIs and industry projects the authors have been involved in.}, keywords = {API, API Evolution, Microservices, patterns}, doi = {10.1145/3361149.3361164}, url = {https://dl.acm.org/citation.cfm?id=3361164}, author = {Daniel L{\"u}bke and Olaf Zimmermann and Cesare Pautasso and Uwe Zdun} } @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} } @article {2019:rest:sawq, title = {SAW-Q: a dynamic composition approach of REST services based on queue model}, journal = {International Journal of Web and Grid Services}, volume = {15}, year = {2019}, month = {January}, pages = {29 - 58}, abstract = {Service composition is one of the principles of service-oriented architecture; it enables reuse and allows developers to combine existing services in order to create new services that in turn can be part of another composition. Dynamic composition requires that service components are chosen from a set of services with equal or similar functionality at runtime and possibly automatically. The adoption of the REST services in the industry has led to a growing number of services of this type, many with similar functionality. The existing dynamic composition techniques are method-oriented whereas REST is resource-oriented and consider only traditional (WSDL/SOAP) services. We propose SAW-Q, an extension of simple additive weighting (SAW), as a novel dynamic composition technique that follows the principles of the REST style. Additionally, SAW-Q models quality attributes as a function of the actual service demand instead of the traditional constant values. Our model is much more accurate when compared to real implementation, positively improving the quality of dynamic service compositions.}, keywords = {automatic composition, dynamic composition, quality of service, REST, SOA, Web services}, doi = {10.1504/IJWGS.2019.096555}, author = {Bellido, Jesus and Rosa Alarc{\'o}n and Cesare Pautasso and Carla Vairetti} } @conference {2019:bpm, title = {Sketching Process Models by Mining Participant Stories}, booktitle = {BPM Forum}, year = {2019}, month = {September}, pages = {3-19}, publisher = {Springer}, organization = {Springer}, address = {Vienna, Austria}, abstract = {Producing initial process models currently requires gathering knowledge from multiple process participants and using modeling tools to produce a visual representation. With traditional tools this can require significant effort and thus delay the feedback cycle where the initial model is validated and refined based on participants{\textquoteright} feedback. In this paper we aim at reducing the effort required to obtain an initial process model by applying existing process mining techniques to sample process logs obtained directly from process participants. To that end, we specify a simple domain-specific language to represent process log fragments with natural language, and we illustrate the architecture of a live modeling tool, which produces a draft representation of the control flow which is updated in real-time as the logs are written down. The draft models generated by the tool can later be refined and completed by the business analysts using traditional tools. We argue that our synthesis of mining with modeling could provide benefits both in terms of efficiency in generating the initial draft model, as well as in terms of reducing the cognitive load of the business analyst during the requirements gathering phase. }, keywords = {Draft Process Model, Process Mining, Process Requirements, Textual Modelling DSL}, doi = {10.1007/978-3-030-26643-1_1}, author = {Ana Ivanchikj and Cesare Pautasso} } @conference {2019:icwe:cornucopia, title = {On the Web Platform Cornucopia}, booktitle = {19th International Conference on Web Engineering (ICWE 2019)}, year = {2019}, month = {June}, pages = {347-355}, publisher = {Springer}, organization = {Springer}, address = {Daejeon, Korea}, abstract = {The evolution of the Web browser has been organic, with new features introduced on a pragmatic basis rather than following a clear rational design. This evolution has resulted in a cornucopia of overlapping features and redundant choices for developing Web applications. These choices include multiple architecture and rendering models, different communication primitives and protocols, and a variety of local storage mechanisms. In this position paper we examine the underlying reasons for this historic evolution. We argue that without a sound engineering approach and some fundamental rethinking there will be a growing risk that the Web may no longer be a viable, open software platform in the long run.}, keywords = {Web Engineering; Web Platform}, doi = {10.1007/978-3-030-19274-7_25}, author = {Tommi Mikkonen and Cesare Pautasso and Kari Systa and Antero Taivalsaari} } @article {2018:ieeecloud:bac, title = {Consistent Disaster Recovery for Microservices: the BAC Theorem}, journal = {IEEE Cloud Computing}, volume = {5}, year = {2018}, month = {January/February}, pages = {49-59}, abstract = {How do you back up a microservice? You dump its database. But how do you back up an entire application decomposed into microservices? In this article, we discuss the tradeoff between the availability and consistency of a microservice-based architecture when a backup of the entire application is being performed. We demonstrate that service designers have to select two out of three qualities: backup, availability, and/or consistency (BAC). Service designers must also consider how to deal with consequences such as broken links, orphan state, and missing state.}, keywords = {availability, BAC theorem, consistency, disaster recovery, Microservices}, doi = {10.1109/MCC.2018.011791714}, url = {http://ieeexplore.ieee.org/document/8327550/}, author = {Guy Pardon and Cesare Pautasso and Olaf Zimmermann} } @proceedings {2018:icwe:workshops, title = {Current Trends in Web Engineering: ICWE 2018 Workshops MATWEP, EnWot, KD-WEB, WEOD, TourismKG}, volume = {11153}, year = {2018}, publisher = {Springer}, address = {C{\'a}ceres, Spain}, keywords = {Web Engineering; Proceedings; Workshops}, doi = {10.1007/978-3-030-03056-8}, url = {https://link.springer.com/book/10.1007\%2F978-3-030-03056-8}, editor = {Cesare Pautasso and Fernando S{\'a}nchez-Figueroa and Kari Systa and Juan Manuel Murillo Rodr{\'\i}guez} } @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} } @conference {2018:icpe, title = {A Declarative Approach for Performance Tests Execution in Continuous Software Development Environments}, booktitle = {9th ACM/SPEC International Conference on Performance Engineering (ICPE 2018)}, year = {2018}, month = {April}, publisher = {ACM}, organization = {ACM}, address = {Berlin, Germany}, abstract = {Software performance testing is an important activity to ensure quality in continuous software development environments. Current performance testing approaches are mostly based on scripting languages and frameworks where users implement, in a procedural way, the performance tests they want to issue to the system under test. However, existing solutions lack support for explicitly declaring the performance test goals and intents. Thus, while it is possible to express how to execute a performance test, its purpose and applicability context remain implicitly described. In this work, we propose a declarative domain specific language (DSL) for software performance testing and a model-driven framework that can be programmed using the mentioned language and drive the end-to-end process of executing performance tests. Users of the DSL and the framework can specify their performance intents by relying on a powerful goal-oriented language, where standard (e.g., load tests) and more advanced (e.g., stability boundary detection, and configuration tests) performance tests can be specified starting from templates. The DSL and the framework have been designed to be integrated into a continuous software development process and validated through extensive use cases that illustrate the expressiveness of the goal-oriented language, and the powerful control it enables on the end-to-end performance test execution to determine how to reach the declared intent.}, keywords = {BenchFlow, DevOps, Domain Specific Language}, doi = {10.1145/3184407.3184417}, author = {Vincenzo Ferme 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 {2018:benchflow:coopis, title = {Evaluating Multi-Tenant Live Migrations Effects on Performance}, booktitle = {26th International Conference on Cooperative Information Systems (CoopIS)}, year = {2018}, month = {October}, address = {Valletta, Malta}, abstract = {Multitenancy is an important feature for all Everything as a Service providers like Business Process Management as a Service. It allows to reduce the cost of the infrastructure since multiple tenants share the same service instances. However, tenants have dynamic workloads. The resource they share may not be sufficient at some point in time. It may require Cloud resource (re-)configurations to ensure a given Quality of Service. Tenants should be migrated without stopping the service from a configuration to another to meet their needs while minimizing operational costs on the provider side. Live migrations reveal many challenges: service interruption must be minimized and the impact on co-tenants should be minimal. In this paper, we investigate live tenants migrations duration and its effects on the migrated tenants as well as the co-located ones. To do so, we propose a generic approach to measure these effects for multi-tenant Software as a Service. Further, we propose a testing framework to simulate workloads, and observe the impact of live migrations on Business Process Management Systems. The experimental results highlight the efficiency of our approach and show that migration time depends on the size of data that have to be transferred and that the effects on co-located tenants should not be neglected. }, keywords = {BenchFlow, Multi-tenant, Performance Testing, workflow engine}, author = {Guillaume Rosinosky and Chahrazed Labba and Vincenzo Ferme and Samir Youcef and Fran{\c c}ois Charoy and Cesare Pautasso} } @conference {2018:map:icsoc, title = {Guiding Architectural Decision Making on Quality Aspects of Microservice APIs}, booktitle = {16th International Conference on Service-Oriented Computing (ICSOC 2018)}, volume = {11236}, year = {2018}, month = {November}, pages = {73-89}, publisher = {Springer}, organization = {Springer}, address = {Hangzhou, Zhejiang, China}, abstract = {Microservice APIs represent the client perspective on microservice-based software architecture design and related practices. Major issues in API design concern the quality aspects of the API. However, it is not well understood today what the established practices related to those quality aspects are, how these practices are related, and what the major decision drivers are. This leads to great uncertainty in the design process. In this paper, we report on a qualitative, in-depth study of 31 widely used APIs plus 24 API specifications, standards, and technologies. In our study we identified six recurring architectural design decisions in two API design contexts with a total of 40 decision options and a total of 47 decision drivers. We modelled our findings in a formal, reusable architectural decision model. We measured the uncertainty in the resulting design space with and without use of our model, and found that a substantial uncertainty reduction can be potentially achieved by applying our model. }, keywords = {API, Microservices, quality}, doi = {10.1007/978-3-030-03596-9_5}, author = {Uwe Zdun and Mirko Stocker and Olaf Zimmermann and Cesare Pautasso and Daniel L{\"u}bke} } @conference {2018:map:europlop, title = {Interface Quality Patterns --- Crafting and Consuming Message-Based Remote APIs}, booktitle = {23rd European Conference on Pattern Languages of Programs (EuroPLoP)}, year = {2018}, month = {July}, publisher = {ACM}, organization = {ACM}, address = {Kloster Irsee, Germany}, abstract = {The design and evolution of Application Programming Interfaces (APIs) in microservices architectures is challenging. General design issues in integration and programming have been covered in great detail in many pattern languages since the beginnings of the patterns movement, and service-oriented infrastructure design patterns have also been published in the last decade. However, the interface representations (i.e., the content of message payloads) have received less attention. We presented five structural representation patterns in our previous work; in this paper we continue our coverage of the API design space and propose five interface quality patterns that deal with the observable aspects of quality-attribute-driven interface design for efficiency, security, and manageability: An API Key allows API providers to identify clients. Providers may offer rich data contracts in their responses, which not all consumers might need. A Wish List allows the client to request only the attributes in a response data set that it is interested in. If a client makes many API calls, the provider can employ a Rate Limit and bill clients according to a specified Rate Plan . A provider has to provide a high-quality service while at the same time having to use its available resources economically. The resulting compromise is expressed in a provider{\textquoteright}s Service Level Agreement. }, keywords = {interfaces, Microservices, patterns, quality}, author = {Mirko Stocker and Olaf Zimmermann and Daniel L{\"u}bke and Uwe Zdun and Cesare Pautasso} } @conference {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 {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 {2018:blockchain:europlop, title = {A Pattern Collection for Blockchain-based Applications}, booktitle = {23rd European Conference on Pattern Languages of Programs (EuroPLoP)}, year = {2018}, month = {July}, publisher = {ACM}, organization = {ACM}, address = {Kloster Irrsee, Germany}, abstract = {Blockchain is an emerging technology that enables new forms of decentralized software architectures, where distributed components can reach agreements on shared system states without trusting a central integration point. Blockchain provides a shared infrastructure to execute programs, called smart contracts, and to store data. Since blockchains are at an early stage, there is a lack of a systematic and holistic view on designing software systems that use blockchain. We view blockchain as part of a bigger system, which requires patterns of using blockchain in the design of the bigger systems. In this paper, we collect a list of patterns for blockchain-based applications. The pattern collection is categorized into four types, including interaction with external world patterns, data management patterns, security patterns and contract structural patterns. Some patterns are designed specifically based on real-world blockchain-based applications considering the nature of blockchain. Others are variants of existing design patterns applied in the context of blockchain-based applications and smart contracts.}, keywords = {blockchain, patterns}, doi = {10.1145/3282308.3282312}, url = {https://dl.acm.org/citation.cfm?id=3282312}, author = {Xiwei Xu and Cesare Pautasso and Liming Zhu and Qinghua Lu and Ingo Weber} } @demo {2018:icsoc:demo:restalk, title = {RESTalk Miner: Mining RESTful Conversations, Pattern Discovery and Matching}, year = {2018}, month = {November}, publisher = {Springer}, address = {Hangzhou, Zhejiang, China}, abstract = {REST has become the architectural style of choice for APIs, where clients need to instantiate a potentially lengthy sequence of requests to the server in order to achieve their goal, effectively leading to a RESTful conversation between the client and the server. Mining the logs of such RESTful conversations can facilitate knowledge sharing among API designers regarding design best practices as well as API usage and optimization. In this demo paper, we present the RESTalk Miner, which takes logs from RESTful services as an input and uses RESTalk, a domain specific language, to visualize them. It provides interactive coloring to facilitate graph reading, as well as statistics to compare the relative frequency of conversations performed by different clients. Furthermore, it supports searching for predefined patterns as well as pattern discovery. }, keywords = {conversation patterns, mining, RESTalk, RESTful conversation}, author = {Ana Ivanchikj 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 {restalk:2016:jssm, title = {Visual modeling of RESTful conversations with RESTalk}, journal = {Journal of Software \& Systems Modeling}, volume = {17}, year = {2018}, month = {July}, pages = {1031-1051}, abstract = {The cost savings introduced by Web services through code re-use and integration opportunities have motivated many businesses to develop Web APIs, with ever increasing numbers opting for the REST architectural style. RESTful Web APIs are decomposed in multiple resources, which the client can manipulate through HTTP interactions with well defined semantics. Getting the resource in the desired state might require multiple client-server interactions, what we define as a RESTful conversation. RESTful conversations are dynamically guided by hypermedia controls, such as links. Thus, when deciding whether and how to use a given RESTful service, the client might not be aware of all the interactions which are necessary to achieve its goal. This is because existing documentation of RESTful APIs describe the static structure of the interface, exposing low-level HTTP details, while little attention has been given to conceptual, high-level, modeling of the dynamics of RESTful conversations. Low-level HTTP details can be abstracted from during the design phase of the API, or when deciding which API to use. We argue that, in these situations, visual models of the required client-server interactions might increase developers{\textquoteright} efficiency and facilitate their understanding. Thus, to capture all possible interaction sequences in a given RESTful conversation, we propose RESTalk, an extension to the BPMN Choreography diagrams to render them more concise and yet sufficiently expressive in the specific REST domain. We also report on the results obtained from an exploratory survey we have conducted to assess the maturity of the field for a domain specific language, and to obtain feedback for future improvements of RESTalk.}, keywords = {RESTalk, RESTful conversation}, issn = {1619-1366}, doi = {10.1007/s10270-016-0532-2}, url = {http://link.springer.com/article/10.1007/s10270-016-0532-2}, author = {Ana Ivanchikj and Cesare Pautasso and Silvia Schreier} } @article {2018:ieeesw, title = {The Web as a Software Connector: Integration Resting on Linked Resources}, journal = {IEEE Software}, volume = {35}, year = {2018}, month = {January/February}, pages = {93 - 98}, abstract = {The web, seen as a graph of linked resources shared between microservices, can serve as an integration style. It offers unique characteristics and possibilities regarding dataflow, control flow, and other qualities, compared to file transfer, shared databases, remote procedure calls, and asynchronous messaging. Carrying these insights in your toolbox will make you aware of all the options to consider next time you build loosely coupled integrated systems.}, keywords = {coupling, REST, software architecture}, doi = {10.1109/MS.2017.4541049}, url = {http://ieeexplore.ieee.org/document/8239944/}, author = {Cesare Pautasso and Olaf Zimmermann} } @conference {2018:webist, title = {Web User Interface Implementation Technologies: An Underview}, booktitle = {14th International Conference on Web Information Systems and Technologies (WEBIST 2018)}, year = {2018}, month = {September}, pages = {127-136}, address = {Seville, Spain}, abstract = {Over the years, the World Wide Web has evolved from a document distribution environment into a rich development platform that can run compelling, full-fledged software applications. However, the programming capabilities of the web browser {\textendash} designed originally for relatively simple scripting tasks {\textendash} have evolved organically in a rather haphazard fashion. Consequently, there are many ways to build applications on the Web today. Depending on one{\textquoteright}s viewpoint, current standards-compatible web browsers support three, four or even five built-in application rendering and programming models. In this paper, we provide an {\textquotedblright}underview{\textquotedblright} of the built-in client-side web application UI implementation technologies, i.e., a summary of those rendering models that are built into the standards-compatible web browser out-of-the-box. While the dominance of the base HTML/CSS/JS technologies cannot be ignored, we foresee Web Components and WebGL gaining popularity as the world moves towards more complex and even richer web applications, including systems supporting virtual and augmented reality.}, keywords = {Web application architecture}, doi = {10.5220/0006885401270136}, url = {http://insticc.org/node/TechnicalProgram/webist/presentationDetails/68854}, author = {Antero Taivalsaari and Tommi Mikkonen and Kari Systa and Cesare Pautasso} } @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} } @conference {2017:icsa:web, title = {Comparing the Built-In Application Architecture Models in the Web Browser}, booktitle = {1st IEEE International Conference on Software Architecture (ICSA 2017)}, year = {2017}, month = {April}, publisher = {IEEE}, organization = {IEEE}, address = {Gothenburg, Sweden}, abstract = {Depending on one{\textquoteright}s viewpoint, a generic standards-compatible web browser supports three, four or five built-in application rendering and programming models. In this paper, we provide an overview of the built-in client-side web application architectures. While the dominance of the base HTML/CSS/JS technologies cannot be ignored, we foresee Web Components and WebGL gaining popularity as the world moves towards more complex and even richer web applications, including systems supporting virtual and augmented reality.}, keywords = {Web application architecture, Web development, Web engineering}, author = {Antero Taivalsaari and Tommi Mikkonen and Cesare Pautasso and Kari Systa} } @inproceedings {2017:asq:pale, title = {Experiences Using an Interactive Presentation Platform in a Functional and Logic Programming Course.}, year = {2017}, month = {July}, publisher = {ACM}, address = {Bratislava, Slovakia}, abstract = {Modern constructivist approaches to education dictate active experimentation with the study material and have been linked with improved learning outcomes in STEM fields. During classroom time we believe it is important for students to experiment with the lecture material since active recall helps them to start the memory encoding process as well as to catch misconceptions early and to prevent them from taking root. In this paper, we report on our experiences using ASQ, a Web-based interactive presentation tool in a functional and logic programming course taught at the Faculty of Informatics and Information Technologies at the Slovak University of Technology in Bratislava. ASQ allowed us to collect immediate feedback from students and retain their attention by asking complex types of questions and aggregating student answers in real time. From our experience we identified several requirements and guidelines for successfully adopting ASQ. One of the most critical concerns was how to estimate the time when to stop collecting the students{\textquoteright} answers and proceed to their evaluation and discussion with the class. We also report the students{\textquoteright} feedback on the ASQ system that we collected in the form of the standard SUS questionnaire. }, keywords = {ASQ}, author = {Vasileios Triglianos and Martin Labaj and Robert Moro and Jakub Simko and Michal Hucko and Jozef Tvarozek and Cesare Pautasso and Maria Bielikova} } @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} } @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} } @conference {2017:europlop, title = {A Pattern Language for Workflow Engine Conformance and Performance Benchmarking}, booktitle = {22nd European Conference on Pattern Languages of Programs (EuroPLoP)}, year = {2017}, month = {July}, publisher = {ACM}, organization = {ACM}, address = {Kloster Irsee, Germany}, abstract = {Workflow engines are frequently used in the domains of business process management, service orchestration, and cloud computing, where they serve as middleware platforms for integrated business applications. Engines have a significant impact on the quality of service provided by hosted applications. Therefore, it is desirable to compare them and to select the most appropriate engine for a given task. To enable such a comparison, approaches for benchmarking workflow engines have emerged. Although these approaches deal with different quality attributes, i.e., performance or standard conformance, they face many reoccurring design and implementation problems, which have been solved in similar ways. In this paper, we present a pattern language that captures such common solutions to reoccurring problems (e.g., from test identification, benchmarking procedure validation, automatic engine interaction, and workflow execution observation) in the area of workflow engine conformance and performance benchmarking. Our aim is to help future benchmark authors with the pattern language presented in this paper to benefit from our experience with the design and implementation of workflow engine benchmarks and benchmarking tools}, keywords = {BenchFlow, pattern language}, doi = {10.1145/3147704.3147705}, author = {Simon Harrer and J{\"o}rg Lenhard and Oliver Kopp and Vincenzo Ferme and Cesare Pautasso} } @proceedings {2017:benchflow:bpmds, title = {Performance Comparison Between BPMN 2.0 Workflow Management Systems Versions}, year = {2017}, month = {June}, publisher = {Springer}, address = {Essen, Germany}, abstract = {Software has become a rapidly evolving artifact and Workflow Management Systems (WfMSs) are not an exception. WfMSs{\textquoteright} changes may impact key performance indicators or resource consumption levels may change among different versions. Thus, users considering a WfMS upgrade need to evaluate the extent of such changes for frequently issued workload. Deriving such information requires running performance experiments with appropriate workloads. In this paper, we propose a novel method for deriving a structurally representative workload from a given business process collection, which we later use to evaluate the performance and resource consumption over four versions of two open-source WfMSs, for different numbers of simulated users. In our case study scenario the results reveal relevant variations in the WfMSs{\textquoteright} performance and resource consumption, indicating a decrease in performance for newer versions.}, keywords = {BenchFlow, BPMN, Performance Regression, Performance Testing, workflow engine, Workflow Management Systems}, author = {Vincenzo Ferme and Marigianna Skouradaki and Ana Ivanchikj and Cesare Pautasso and Frank Leymann} } @conference {benchflow:2017:bpm, title = {On the Performance Overhead of BPMN Modeling Practices}, booktitle = {15th International Conference on Business Process Management (BPM2017)}, year = {2017}, month = {September}, pages = {216--232}, publisher = {Springer}, organization = {Springer}, address = {Barcelona, Spain}, abstract = {Business process models can serve different purposes, from discussion and analysis among stakeholders, to simulation and execution. While work has been done on deriving modeling guidelines to improve understandability, it remains to be determined how different modeling practices impact the execution of the models. In this paper we observe how semantically equivalent, but syntactically different, models behave in order to assess the performance impact of different modeling practices. To do so, we propose a methodology for systematically deriving semantically equivalent models by applying a set of model transformation rules and for precisely measuring their execution performance. We apply the methodology on three scenarios to systematically explore the performance variability of 16 different versions of parallel, exclusive, and inclusive control flows. Our experiments with two open-source business process management systems measure the execution duration of each model{\textquoteright}s instances. The results reveal statistically different execution performance when applying different modeling practices without total ordering of performance ranks. }, keywords = {BenchFlow, BPMN, performance}, doi = {10.1007/978-3-319-65000-5_13}, author = {Ana Ivanchikj and Vincenzo Ferme and Cesare Pautasso} } @proceedings {zeus2017, title = {Proceedings of the 9th Central European Workshop on Services and their Composition (ZEUS 2017)}, year = {2017}, month = {February}, publisher = {CEUR-WS.org}, address = {Lugano, Switzerland}, keywords = {Web service composition}, url = {http://ceur-ws.org/Vol-1826/}, author = {Oliver Kopp and J{\"o}rg Lenhard and Cesare Pautasso} } @conference {2017:icsa:blockchain, title = {A Taxonomy of Blockchain-based Systems for Architecture Design}, booktitle = {1st IEEE International Conference on Software Architecture (ICSA 2017)}, year = {2017}, month = {April}, publisher = {IEEE}, organization = {IEEE}, address = {Gothenburg, Sweden}, abstract = {Blockchain is an emerging technology for decentralised and transactional data sharing across a large network of untrusted participants. It enables new forms of distributed software architectures, where agreement on shared states can be established without trusting a central integration point. A major difficulty for architects designing applications based on blockchain is that the technology has many configurations and variants. Since blockchains are at an early stage, there is little product data or reliable technology evaluation available to compare different blockchains. In this paper, we propose how to classify and compare blockchains and blockchain-based systems to assist with the design and assessment of their impact on software architectures. Our taxonomy captures major architectural characteristics of blockchains and the impact of their principal design decisions. This taxonomy is intended to help with important architectural considerations about the performance and quality attributes of blockchain-based systems.}, keywords = {blockchain, software architecture}, author = {Xiwei Xu and Ingo Weber and Liming Zhu and Mark Staples and Jan Bosch and Len Bass and Cesare Pautasso and Paul Rimba} } @proceedings {bpm:2017:forum, title = {A Template for Sharing Empirical Business Process Metrics}, year = {2017}, month = {September}, pages = {36-52}, publisher = {Springer}, address = {Barcelona, Spain}, abstract = {Empirical Research is becoming increasingly important for understanding the practical uses and problems with business processes technology in the field. However, no standardization on how to report observations and findings exists. This sometimes leads to research outcomes which report partial or incomplete data and make published results of replicated studies on different data sets hard to compare. In order to help the research community improve reporting on business process models and collections and their characteristics, this paper defines a modular template with the aim of reports{\textquoteright} standardization, which could also facilitate the creation of shared business process repositories to foster further empirical research in the future. The template has been positively evaluated by representatives from both BPM research and industry. The survey feedback has been incorporated in the template. We have applied the template to describe a real-world executable WS-BPEL process collection, measured from a static and dynamic perspective.}, keywords = {BPM, empirical business process management}, author = {Daniel L{\"u}bke and Ana Ivanchikj and Cesare Pautasso} } @inproceedings {benchflow:2017:qudos, title = {Towards Holistic Continuous Software Performance Assessment}, year = {2017}, month = {April}, pages = {159-164}, publisher = {ACM}, address = {L{\textquoteright}Aquila, Italy}, abstract = {In agile, fast and continuous development lifecycles, software performance analysis is fundamental to confidently release continuously improved software versions. Researchers and industry practitioners have identified the importance of integrating performance testing in agile development processes in a timely and efficient way. However, existing techniques are fragmented and not integrated taking into account the heterogeneous skills of the users developing polyglot distributed software, and their need to automate performance practices as they are integrated in the whole lifecycle without breaking its intrinsic velocity. In this paper we present our vision for holistic continuous software performance assessment, which is being implemented in the BenchFlow tool. BenchFlow enables performance testing and analysis practices to be pervasively integrated in continuous development lifecycle activities. Users can specify performance activities (e.g., standard performance tests) by relying on an expressive Domain Specific Language for objective-driven performance analysis. Collected performance knowledge can be thus reused to speed up performance activities throughout the entire process. }, keywords = {BenchFlow, Continuous Software Performance Assessment, DevOps}, doi = {10.1145/3053600.3053636}, url = {http://qudos2017.fortiss.org/program/}, author = {Vincenzo Ferme 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 {benchflow:2016:closer, title = {A Container-centric Methodology for Benchmarking Workflow Management Systems}, booktitle = {6th International Conference on Cloud Computing and Service Science (CLOSER 2016)}, year = {2016}, month = {April}, pages = {74-84}, publisher = {SciTePress}, organization = {SciTePress}, address = {Rome, Italy}, abstract = {Trusted benchmarks should provide reproducible results obtained following a transparent and well-defined process. In this paper, we show how Containers, originally developed to ease the automated deployment of Cloud application components, can be used in the context of a benchmarking methodology. The proposed methodology focuses on Workflow Management Systems (WfMSs), a critical service orchestration middleware, which can be characterized by its architectural complexity, for which Docker Containers offer a highly suitable approach. The contributions of our work are: 1) a new benchmarking approach taking full advantage of containerization technologies; and 2) the formalization of the interaction process with the WfMS vendors described clearly in a written agreement. Thus, we take advantage of emerging Cloud technologies to address technical challenges, ensuring the performance measurements can be trusted. We also make the benchmarking process transparent, automated, and repeatable so that WfMS vendors can join the benchmarking effort.}, keywords = {BenchFlow, benchmarking, Docker}, doi = {10.5220/0005908400740084}, author = {Vincenzo Ferme and Ana Ivanchikj and Cesare Pautasso and Marigianna Skouradaki and Frank Leymann} } @article {swinsight:2016:janfeb, title = {A Decade of Enterprise Integration Patterns: A Conversation with the Authors}, journal = {IEEE Software}, volume = {1}, year = {2016}, month = {January-February}, pages = {13-19}, abstract = {Department editors Olaf Zimmerman and Cesare Pautasso interview Gregor Hohpe and Bobby Woolf, authors of Enterprise Integration Patterns. They discuss the book{\textquoteright}s impact, pattern language design, message-oriented middleware, integration technology{\textquoteright}s evolution, and the authors{\textquoteright} future plans. }, keywords = {Enterprise Integration Patterns}, doi = {http://doi.ieeecomputersociety.org/10.1109/MS.2016.11}, url = {http://ieeexplore.ieee.org/stamp/stamp.jsp?tp=\&arnumber=7368007}, author = {Olaf Zimmermann and Cesare Pautasso and Gregor Hohpe and Bobby Woolf} } @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} } @conference {benchflow:2016:bpm, title = {Estimating the Cost for Executing Business Processes in the Cloud}, booktitle = {BPM Forum}, year = {2016}, month = {September}, pages = {72--88}, publisher = {Springer}, organization = {Springer}, address = {Rio de Janeiro, Brazil}, abstract = {Managing and running business processes in the Cloud changes how Workflow Management Systems (WfMSs) are deployed. Consequently, when designing such WfMSs, there is a need of determining the sweet spot in the performance vs. resource consumption trade-off. While all Cloud providers agree on the pay-as-you-go resource consumption model, every provider uses a different cost model to gain a competitive edge. In this paper, we present a novel method for estimating the infrastructure costs of running business processes in the Cloud. The method is based on the precise measurement of the resources required to run a mix of business process in the Cloud, while accomplishing expected performance requirements. To showcase the method we use the BenchFlow framework to run experiments on a widely used open-source WfMS executing custom workload with a varying number of simulated users. The experiments are necessary to reliably measure WfMS{\textquoteright}s performance and resource consumption, which is then used to estimate the infrastructure costs of executing such workload on four different Cloud providers.}, keywords = {BenchFlow, cloud computing, cloud workflows}, doi = {10.1007/978-3-319-45468-9_5}, author = {Vincenzo Ferme and Ana Ivanchikj and Cesare Pautasso} } @conference {asq:2016:ectel, title = {Inferring student attention with ASQ}, booktitle = {11th European Conference on Technology Enhanced Learning (EC-TEL)}, year = {2016}, month = {September}, publisher = {Springer}, organization = {Springer}, address = {Lyon, France}, abstract = {ASQ is a Web application for broadcasting and tracking interactive presentations, which can be used to support active learning pedagogies during lectures, labs and exercise sessions. Students connect their smartphones, tablets or laptops to receive the current slide as it is being explained by the teacher. Slides can include interactive teaching elements (usually questions of different forms). In contrast to other existing platforms, ASQ does not only collect, aggregate and visualize the answers in real-time, it also supports the data analytics in the classroom paradigm by providing the teacher with a real-time analysis of student behaviour during the entire session. One vital aspect of student behaviour is (in)attention and in this paper we discuss how we infer --- in real-time --- student attention based on log traces ASQ collects.}, keywords = {analytics, ASQ}, author = {Vasileios Triglianos and Cesare Pautasso and Alessandro Bozzon and Claudia Hauff} } @demo {benchflow:2016:icpe, title = {Integrating Faban with Docker for Performance Benchmarking}, year = {2016}, month = {March}, pages = {129-130}, publisher = {ACM}, address = {Delft, The Netherlands}, abstract = {Reliability and repeatability are key requirements in performance benchmarking ensuring the trustworthiness of the obtained performance results. To apply a benchmark to multiple systems, the reusability of the load driver is essential. While Faban has been designed to ensure the reliability of the performance data obtained from a benchmark experiment, it lacks support for ensuring that the system under test is deployed in a known configuration. This is what Docker, a recently emerging containerization technology, excels at. In this demo paper we present how we integrated Faban with Docker as part of the BenchFlow framework to offer a complete and automated performance benchmarking framework that provides a reliable and reusable environment, ensuring the repeatability of the experiments. }, keywords = {BenchFlow, benchmarking, Docker, Faban}, doi = {10.1145/2851553.2858676}, author = {Vincenzo Ferme 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} } @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} } @conference {restalk:2016:europlop, title = {A Pattern Language for RESTful Conversations}, booktitle = {Proceedings of the 21st European Conference on Pattern Languages of Programs (EuroPLoP)}, year = {2016}, month = {July}, pages = {4:1{\textendash}4:22}, publisher = {ACM}, organization = {ACM}, address = {Kloster Irsee, Germany}, abstract = {As a good user interface design is important for the success of an app, so is a good API for the success of a Web service. Within the RESTful Web services community there is a need for a systematic approach in knowledge sharing, for which patterns are particularly suitable. Using a RESTful service to achieve a certain goal often requires multiple client-server interactions, i.e., to have a conversation. While patterns of such RESTful conversations can be uncovered from existing APIs{\textquoteright} usage scenarios, or the service engineering literature, they have never been gathered in a pattern language, nor properly visualized with a Domain Specific Modeling Language (DSML). These patterns provide valuable input for API designers, as well as API consumers, by establishing a common vocabulary to describe recurring conversations. To do so, this paper uses RESTalk, a DSML, to model the basic RESTful conversation patterns structured around the life cycle of a resource (create, discover, read, edit, delete, protect) by showing the corresponding sequences of HTTP request-response interactions. We show how the resulting pattern language can be applied to individual resources, or also collections of resources.}, keywords = {conversation composition, conversation patterns, pattern language, RESTalk, RESTful conversation, RESTful web services}, isbn = {978-1-4503-4074-8}, doi = {10.1145/3011784.3011788}, url = {http://doi.acm.org/10.1145/3011784.3011788}, author = {Cesare Pautasso and Ana Ivanchikj and Silvia Schreier} } @proceedings {icwe:2015:rmc, title = {Rapid Mashup Development Tools}, volume = {591}, year = {2016}, publisher = {Springer}, address = {Rotterdam, The Netherlands}, keywords = {mashup tools}, doi = {10.1007/978-3-319-28727-0}, url = {http://mashup.inf.usi.ch/challenge/2015/}, editor = {Florian Daniel and Cesare Pautasso} } @proceedings {2016:icwe, title = {Web Engineering}, volume = {9671}, year = {2016}, month = {June}, pages = {XXVI, 626}, publisher = {Springer}, address = {Lugano, Switzerland}, keywords = {Web engineering}, issn = {978-3-319-38790-1}, doi = {10.1007/978-3-319-38791-8}, url = {http://icwe2016.webengineering.org}, author = {Alessandro Bozzon and Philippe Cudr{\'e}-Mauroux and Cesare Pautasso} } @proceedings {2016:icwe:workshop, title = {Web Engineering Workshops}, volume = {9881}, year = {2016}, month = {June}, pages = {209}, publisher = {Springer}, address = {Lugano, Switzerland}, keywords = {Web engineering}, issn = {978-3-319-46962-1}, doi = {10.1007/978-3-319-46963-8}, url = {http://icwe2016.webengineering.org}, author = {Sven Casteleyn and Peter Dolog and Cesare Pautasso} } @conference {asq:icwe:2015, title = {asqium: A JavaScript Plugin Framework for Extensible Client and Server-side Components}, booktitle = {15th International Conference on Web Engineering (ICWE 2015)}, year = {2015}, month = {June}, pages = {81-98}, publisher = {Springer}, organization = {Springer}, address = {Rotterdam, NL}, abstract = {JavaScript has been growing from a language for embedding simple scripts into Web pages to a language for programming complex Web applications, whose logic is deployed across both Web browsers and Web servers. Current software packaging mechanisms for JavaScript enable a basic level of modularity and reuse. However, they have not yet reached full maturity in terms of enabling to extend a system with features contributed as third-party plugins, while encapsulating them adequately. In this paper we present a novel plugin system for JavaScript applications, which integrate Node.js modules with HTML5 Web Components. It provides abstractions for: real time and loosely coupled communication between front-end and back-end components, persistent state storage, and isomorphic usage of JavaScript. Plugins can use hooks and events to contribute functionality and embed it into the main application flow, while respecting the common asynchronous non-blocking programming paradigm of JavaScript. We demonstrate the expressiveness of the framework as it is used to build ASQ: an open and extensible educational Web platform. }, keywords = {ASQ, plugin architecture, web framework}, doi = {10.1007/978-3-319-19890-3_7}, author = {Vasileios Triglianos and Cesare Pautasso} } @conference {benchflow:2015:closer, title = {"BPELanon": Protect Business Processes on the Cloud}, booktitle = {5th International Conference on Cloud Computing and Service Science (CLOSER 2015)}, year = {2015}, month = {May}, pages = {241-250}, publisher = {SciTePress}, organization = {SciTePress}, address = {Lisbon, Portugal}, abstract = {The advent of Cloud computing supports the offering of many Business Process Management applications on a distributed, per-use basis environment through its infrastructure. Due to the fact that privacy is still an open issue in the Cloud, many companies are reluctant to move their Business Processes on a public Cloud. Since the Cloud environment can be beneficiary for the Business Processes, the investigation of privacy issues needs to be further examined. In order to enforce the Business Process sharing on the Cloud we propose a methodology ({\textquotedblleft}BPELanon{\textquotedblright}) for the anonymization of Business Processes expressed in the Web Service Business Process Execution Language (BPEL). The method transforms a process to preserve its original structure and run-time behavior, while completely anonymizing its business semantics. In this work we set the theoretical framework of the method and define a five management layers architecture to support its realization. We developed a tool that implements the {\textquotedblleft}BPELanon{\textquotedblright} method, validate its functionality and evaluate its performance against a collection of real-world process models that were conducted in the scope of research projects.}, keywords = {Anonymization, BenchFlow, BPEL}, doi = {10.5220/0005427502410250}, author = {Marigianna Skouradaki and Vincenzo Ferme and Frank Leymann and Cesare Pautasso and Dieter Roller} } @demo {benchflow:2015:bpmeter, title = {BPMeter: Web Service and Application for Static Analysis of BPMN 2.0 Collections}, year = {2015}, month = {August}, pages = {30-34}, publisher = {Springer}, address = {Innsbruck, Austria}, abstract = {The number of business process models is constantly increasing as companies realize the competitive advantage of managing their processes. Measuring their size and structural properties can give useful insights. With the BPMeter tool, process owners can quickly compare their process with company{\textquoteright}s process portfolio, researchers can statically analyze a process to see which modeling language features have been used in practice, while modelers can obtain an aggregated view over their processes. In this demonstration we show how to use BPMeter, which provides a simple Web application to visualize the results of applying over 100 different size and structure metrics to BPMN 2.0 process models. The visualization features measurements, statistics and the possibility to compare the measurements with the ones obtained from the entire portfolio. Moreover we show how to invoke its RESTful Web API so that the BPMeter analyzer can be easily integrated with existing process management tools.}, keywords = {BenchFlow, BPMN, Workflow Static Analysis}, author = {Ana Ivanchikj and Vincenzo Ferme and Cesare Pautasso} } @conference {rest:2015:wicsa, title = {A conversation based approach for modeling REST APIs}, booktitle = {12th Working IEEE / IFIP Conference on Software Architecture (WICSA 2015)}, year = {2015}, month = {May}, address = {Montreal, Canada}, abstract = {Conversations are a well-known concept in service design to describe complex interactions between a client and one or multiple services. The REST architectural style constrains the characteristics of clients, servers and their interactions in REST architectures which consequently has an impact on conversations in such systems. The relation between conversations and REST architectures and how such RESTful conversations can be characterized has not been studied in detail yet. In this paper we discuss the characteristics of conversations in REST architectures and introduce an initial set of commonly used conversation types. Based on this, we propose to use conversations as a modeling tool for the design of REST APIs at a higher level of abstraction. We also introduce a corresponding interaction centric metamodel for REST APIs. The characterization of RESTful conversations enables a new interaction centric viewpoint on REST architectures which can be also applied for modeling REST APIs on an abstraction level that enables users to focus on the essential functionality of their REST API.}, keywords = {conversation, model-driven engineering, REST, RESTful conversation}, url = {http://wicsa2015.org/wicsa-sessions.html$\#$WS5}, author = {Florian Haupt and Frank Leymann and Cesare Pautasso} } @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 {benchflow:2015:bpm, title = {A Framework for Benchmarking BPMN 2.0 Workflow Management Systems}, booktitle = {13th International Conference on Business Process Management (BPM 2015)}, year = {2015}, month = {August}, publisher = {Springer}, organization = {Springer}, address = {Innsbruck, Austria}, keywords = {BenchFlow, BPMN, Workflow Benchmarking}, doi = {10.1007/978-3-319-23063-4_18}, author = {Vincenzo Ferme and Ana Ivanchikj and Cesare Pautasso} } @inproceedings {wesoa2015, title = {From Choreography Diagrams to RESTful Interactions}, year = {2015}, month = {November}, publisher = {Springer}, address = {Goa, India}, abstract = {Today, business process management is a key approach to organize work, and many companies represent their operations in business process models. Recently, choreography diagrams have been introduced to represent interactions between business processes, run by different partners. While there is considerable work on using process models during process implementation, there is little work on using choreography models to implement interactions between business processes. In this paper, a novel approach to enhance choreography diagrams by execution information is introduced. The approach is based on the REST architecture style, which is the primary way for interacting systems. Using enhanced choreography diagrams allows us to develop REST-based interactions among business partners in an efficient manner. The approach is illustrated by an example of an accommodation reservation service.}, keywords = {BPMN Choreography, RESTful conversation}, author = {Adriatik Nikaj and Sankalita Mandal and Cesare Pautasso and Mathias Weske} } @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} } @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 {benchflow:2015:icpe, title = {On the Road to Benchmarking BPMN 2.0 Workflow Engines}, booktitle = {6th ACM/SPEC International Conference on Performance Engineering}, year = {2015}, month = {January}, publisher = {IEEE}, organization = {IEEE}, address = {Austin, TX, USA}, abstract = {Workflow Management Systems (WfMSs) provide platforms for delivering complex service-oriented applications that need to satisfy enterprise-grade quality of service requirements such as dependability and scalability. In this paper we focus on the case of benchmarking the performance of the core of WfMSs, Workflow Engines, that are compliant with the Business Process Model and Notation 2.0 (BPMN 2.0) standard. We first explore the main challenges that need to be met when designing such a benchmark and describe the approaches we designed for tackling them in the BenchFlow project. We discuss our approach to distill the essence of real-world processes to create from it processes for the benchmark, and to ensure that the benchmark finds wide applicability.}, keywords = {BenchFlow, benchmarking}, doi = {10.1145/2668930.2695527}, author = {Marigianna Skouradaki and Vincenzo Ferme and Frank Leymann and Cesare Pautasso and Dieter Roller} } @article {2015:ieeesoftware:insights, title = {Seeking Your Insights}, volume = {32}, year = {2015}, month = {March-April}, pages = {7--9}, keywords = {Software Engineering Practice}, issn = {0740-7459}, doi = {http://dx.doi.org/10.1109/MS.2015.47}, url = {https://ieeexplore.ieee.org/document/7057623/?arnumber=7057623}, author = {Cesare Pautasso and Olaf Zimmermann} } @conference {liquid:icwe:2015, title = {Towards Liquid Web Applications}, booktitle = {15th International Conference on Web Engineering (ICWE 2015)}, year = {2015}, month = {June}, pages = {134-143}, publisher = {Springer}, organization = {Springer}, address = {Rotterdam, NL}, abstract = {As the complexity of rich Web applications grows together with the power and number of Web browsers, the next Web engineering challenge to be addressed is to design and deploy Web applications to make coherent use of all devices. As users nowadays operate multiple personal computers, smart phones, tablets, and computing devices embedded into home appliances or cars, the architecture of current Web applications needs to be redesigned to enable what we call Liquid Software. Liquid Web applications not only can take full advantage of the computing, storage and communication resources available on all devices owned by the end user, but also can seamlessly and dynamically migrate from one device to another continuously following the user attention and usage context. In this paper we address the Liquid Software concept in the context of Web applications and survey to which extent and how current Web technologies can support its novel requirements.}, keywords = {liquid software, liquid web application, position paper}, doi = {10.1007/978-3-319-19890-3_10}, author = {Tommi Mikkonen and Kari Systa and Cesare Pautasso} } @conference {benchflow:2015:btw, title = {Towards Workflow Benchmarking: Open Research Challenges}, booktitle = {16. Fachtagung Datenbanksysteme f{\"u}r Business, Technologie und Web (BTW)}, year = {2015}, month = {March}, pages = {331-350}, publisher = {Gesellschaft f{\"u}r Informatik}, organization = {Gesellschaft f{\"u}r Informatik}, address = {Hamburg, Germany}, keywords = {BenchFlow, benchmarking, workflow}, url = {http://www.btw-2015.de/?programm_main}, author = {Cesare Pautasso and Dieter Roller and Frank Leymann and Vincenzo Ferme and Marigianna Skouradaki} } @inproceedings {tcc:2014:wsrest, title = {Atomic Distributed Transactions: a RESTful Design}, year = {2014}, month = {April}, publisher = {ACM}, address = {Seoul, Korea}, abstract = {The REST architectural style supports the reliable interaction of clients with a single server. However, no guarantees can be made for more complex interactions which require to atomically transfer state among resources distributed across multiple servers. In this paper we describe a lightweight design for transactional composition of RESTful services. The approach -- based on the Try-Cancel/Confirm (TCC) pattern -- does not require any extension to the HTTP protocol. The design assumes that resources are designed to comply with the TCC pattern and ensures that the resources involved in the transaction are not aware of it. It delegates the responsability of achieving the atomicity of the transaction to a coordinator which exposes a RESTful API.}, keywords = {atomic transactions, REST, TCC}, author = {Guy Pardon and Cesare Pautasso} } @inproceedings {benchflow:zeus2014, title = {"BPELanon": Anonymizing BPEL Processes}, year = {2014}, month = {February}, address = {Potsdam, Germany}, abstract = {We are currently developing a performance benchmark for Workflow Management System. As a first activity we are collecting real-world processes. However, to protect their competitive advantage, some companies are not willing to share their corporate assets. This work{\textquoteright}s objective is to propose a method ("BPELanon") for BPEL process anonymization in order to deal with the problem. The method transforms a process to preserve its original structure and runtime behaviour, while completely anonymizing its business semantics. Anonymization is a complicated task that must meet the requirements we outline in this paper. Namely, we need to preserve the structural and executional information while anonymizing information such as namespaces, names (activity names, variable names, partner link names etc.), and XPATH expressions that may reveal proprietary information. Furthermore, the names contained in the anonymized process should be chosen carefully in order to avoid conflicts, preserve privacy, and file-readability. Multiple dependency relations among process artifacts raise the challenge of fulfilling the aforementioned requirements, as a unique change in a file potentially leads to a flow of changes to other related process artifacts. }, keywords = {Anonymization, BenchFlow, BPEL, business process modeling}, author = {Marigianna Skouradaki and Dieter Roller and Cesare Pautasso and Frank Leymann} } @article {naturalmash:2014, title = {End-User Development of Mashups with NaturalMash}, journal = {Journal of Visual Languages \& Computing}, volume = {25}, year = {2014}, month = {August}, pages = {414{\textendash}432}, abstract = {Context: The emergence of the long-tail in the market of software applications is shifting the role of end-users from mere consumers to becoming developers of applications addressing their unique, personal, and transient needs. On the Web, a popular form of such applications is called mashup, built out of the lightweight composition of Web APIs (reusable software components delivered as a service through the Web). To enable end-users to build mashups, there is a key problem that must be overcome: End-users lack programming knowledge as well as the interest to learn how to master the complex set of Web technologies required to develop mashups. End-User Development (EUD) is an emerging research field dealing with this type of problems. Its main goal is to design tools and techniques facilitating the development of software applications by non-programmers. Objective: The paper describes the design and evaluation of NaturalMash, an innovative EUD tool for mashups (a mashup tool). NaturalMash aims at enabling non-professional users without any knowledge of programming languages and skills to create feature-rich, interactive, and useful mashups. Methods: The design of NaturalMash adopts a formative evaluation approach, and has completed three design and evaluation iterations. The formative evaluations utilize usability testing, think aloud protocol, questionnaires, observation, and unstructured interviews. Additionally, we compare the expressive power of naturalmash with the state-of-the-art mashup tools. Results: The results from the formative evaluations helped us identify important usability problems. From an assessment point of view, the results were promising and sggested that the proposed tool has a short and gentle learning curve in a way that even non-programmers are able to rapidly build useful mashups. Also, the comparative evaluation results showed that NaturalMash offers a competitive level of expressive power compared with existing mashup tools targeting non-programmers. Conclusion: As the evaluation results indicate, NaturalMash provides a high level of expressive power while it is still highly usable by non-programmers. These suggest that we have successfully achieved the objective of the proposed tool, distinguishing it from existing mashup tools that are either too limited or highly specialized for non-professional users.}, keywords = {mashup tools, mashups, natural language programming, NaturalMash, programming by demonstration, wysiwyg}, doi = {http://dx.doi.org/10.1016/j.jvlc.2013.12.004}, author = {Saeed Aghaee and Cesare Pautasso} } @article {peternier2012CPE, title = {High Performance Execution of Service Compositions: a Multicore-aware Engine Design}, journal = {Concurrency and Computation: Practice and Experience (CPE)}, volume = {26}, year = {2014}, month = {January}, pages = {71-97}, publisher = {Wiley}, abstract = {Although modern computer hardware offers an increasing number of processing elements organized in nonuniform memory access (NUMA) architectures, prevailing middleware engines for executing business processes, workflows, and Web service compositions have not been optimized for properly exploiting the abundant processing resources of such machines. Amongst others, factors limiting performance are inefficient thread scheduling by the operating system, which can result in suboptimal use of system memory and CPU caches, and sequential code sections that cannot take advantage of multiple available cores. In this article, we study the performance of the JOpera process execution engine on recent multicore machines. We first evaluate its performance without any dedicated optimization for multicore hardware, showing that additional cores do not significantly improve performance, although the engine has a multithreaded design. Therefore, we apply optimizations on the basis of replication together with an improved, hardware-aware usage of the underlying resources such as NUMA nodes and CPU caches. Thanks to our optimizations, we achieve speedups from a factor of 2 up to a factor of 20 (depending on the target machine) when compared with a baseline execution {\textquoteleft}as is{\textquoteright}. }, keywords = {JOpera, multicores, nonuniform memory access architecture, performance optimization, service composition and execution}, doi = {10.1002/cpe.2948}, author = {Achille Peternier and Walter Binder and Cesare Pautasso and Daniele Bonetta} } @article {105, title = {Improving execution unit occupancy on SMT-based processors through hardware-aware thread scheduling}, journal = {Future Generation Computer Systems}, volume = {30}, year = {2014}, month = {January}, pages = {229 - 241}, abstract = {Modern processor architectures are increasingly complex and heterogeneous, often requiring software solutions tailored to the specific hardware characteristics of each processor model. In this article, we address this problem by targeting two processors featuring Simultaneous MultiThreading (SMT) to improve the occupancy of their internal execution units through a sustained stream of instructions coming from more than one thread. We target the AMD Bulldozer and IBM POWER7 processors as case studies for specific hardware-oriented performance optimizations that increase the variety of instructions sent to each core to maximize the occupancy of all its execution units. WorkOver, presented in this article, improves thread scheduling by increasing the performance of floating point-intensive workloads on Linux-based operating systems. WorkOver is a user-space monitoring tool that automatically identifies FPU-intensive threads and schedules them in a more efficient way without requiring any patches or modifications at the kernel level. Our measurements using standard benchmark suites show that speedups of up to 20\% can be achieved by simply allowing WorkOver to monitor applications and schedule their threads, without any modification of the workload.}, keywords = {multicores, Overseer}, issn = {0167739X}, doi = {10.1016/j.future.2013.06.015}, author = {Achille Peternier and Danilo Ansaloni and Daniele Bonetta and Cesare Pautasso and Walter Binder} } @demo {asq:icwe2014, title = {Interactive Scalable Lectures with ASQ}, year = {2014}, month = {July}, pages = {515-518}, publisher = {Springer}, address = {Toulouse, France}, abstract = {Taking full advantage of the Web technology platform dur- ing in-class lectures requires a shift from the established scheme of online education delivery that utilizes the video channel to embed all types of content and gathers student feedback via multiple choice questions or textual answers. In this paper we present the design of ASQ to deliver interactive content for use in heterogeneous educational settings with a large number of students, taking advantage of the co-location of students and instructors and building upon the latest capabilities of the Web platform. ASQ is centered around interactive HTML5 presentations coupled with a versatile microformat to create and deliver various types quizzes and scalable, synchronous/asynchronous feedback mechanisms.}, keywords = {hybrid MOOC}, author = {Vasileios Triglianos and Cesare Pautasso} } @book {rest:2014, title = {REST: Advanced Research Topics and Practical Applications}, year = {2014}, pages = {1-214}, publisher = {Springer}, organization = {Springer}, keywords = {REST}, isbn = {978-1-4614-9298-6}, url = {http://ws-rest.org/book/2/}, editor = {Cesare Pautasso and Erik Wilde and Rosa Alarc{\'o}n} } @inproceedings {lisa:wsrest2014, title = {A RESTful API for Controlling Dynamic Streaming Topologies}, year = {2014}, month = {April}, address = {Seoul, Korea}, abstract = {Streaming applications have become more and more dynamic and heterogeneous thanks to new technologies which enable platforms like microcontrollers and Web browsers to be able to host part of a streaming topology. A dynamic heterogeneous streaming application should support load balancing and fault tolerance while being capable of adapting and rearranging topologies to user needs at runtime. In this paper we present a REST API to control dynamic heterogeneous streaming applications. By means of resources, their uniform interface and hypermedia we show how it is possible to monitor, change and adapt the deployment configuration of a streaming topology at runtime.}, keywords = {REST, streaming}, author = {Masiar Babazadeh and Cesare Pautasso} } @conference {lisa:wicsa2014, title = {The Stream Software Connector Design Space: Frameworks and Languages for Distributed Stream Processing}, booktitle = {11th Working IEEE/IFIP Conference on Software Architecture (WICSA 2014)}, year = {2014}, month = {April}, address = {Sydney, Australia}, abstract = {In recent years we witnessed the rise of applications in which data is continuously generated and pushed towards consumers in real time through complex processing pipelines. Software connectors like remote procedure call (RPC) do not fit with the needs of such applications, for which the publish/subscribe and the stream connectors are more suitable. This paper introduces the design space of the stream software connector by analyzing recent stream processing engine frameworks and domain specific languages featuring native streaming support. On the one side, we want to classify and compare streaming systems based on a taxonomy derived from the wide range of features they offer (i.e., pipeline dynamicity and representation, load balancing and deployment flexibility). On the other side, the gaps in the design space we identify point at future research directions in the area of distributed stream processing. To do so, we gather valuable architectural knowledge in terms of architectural issues and alternatives, elicited by surveying the most important architectural decisions made by the designers of several representative streaming framework architectures.}, keywords = {design space, software connector, streaming, survey}, author = {Masiar Babazadeh and Cesare Pautasso} } @conference {benchflow:2014:sosp, title = {Technical Open Challenges on Benchmarking Workflow Management Systems}, booktitle = {Symposium on Software Performance}, year = {2014}, month = {November}, pages = {105-112}, address = {Stuttgart, Germany}, abstract = {The goal of the BenchFlow project is to design the first benchmark for assessing and comparing the performance of BPMN 2.0 Workflow Management Systems (WfMSs). WfMSs have become the platform to build composite service-oriented applications, whose performance depends on two factors: the performance of the workflow system itself and the performance of the composed services (which could lie outside of the control of the workflow). Our main goal is to present to the community the state of our work, and the open challenges of a complex industry-relevant benchmark}, keywords = {BenchFlow, benchmarking, workflow engine}, url = {http://www.performance-symposium.org/2014/proceedings/}, author = {Marigianna Skouradaki and Dieter Roller and Frank Leymann and Vincenzo Ferme and Cesare Pautasso} } @article {triglianos2013www, title = {ASQ: Interactive Web Presentations for Hybrid MOOCs}, year = {2013}, month = {May}, address = {Rio de Janeiro, Brazil}, abstract = {ASQ is a Web application for creating and delivering interactive HTML5 presentations. It is designed to support teachers that need to gather real-time feedback from the students while delivering their lectures. Presentation slides are delivered to viewers that can answer the questions embedded in the slides. The objective is to maximize the efficiency of bi-directional communication between the lecturer and a large audience. More specifically, in the context of a hybrid MOOC classroom, a teacher can use ASQ to get feedback in real time about the level of comprehension of the presented material while reducing the time for gathering survey data, monitoring attendance and assessing solutions.}, keywords = {ASQ, hybrid MOOC, Web engineering}, url = {http://dl.acm.org/citation.cfm?id=2487894}, author = {Vasileios Triglianos and Cesare Pautasso} } @article {babazadeh2013www, title = {The Atomic Web Browser}, year = {2013}, month = {May}, pages = {217-218}, address = {Rio de Janeiro, Brazil}, abstract = {The Atomic Web Browser achieves atomicity for distributed transactions across multiple RESTful APIs. Assuming that the participant APIs feature support for the Try-Confirm/Cancel pattern, the user may navigate with the Atomic Web Browser among multiple Web sites to perform local resource state transitions (e.g., reservations or bookings). Once the user indicates that the navigation has successfully completed, the Atomic Web browser takes care of confirming the local transitions to achieve the atomicity of the global transaction.}, keywords = {REST, REST transactions, try-confirm-cancel, Web engineering}, url = {http://dl.acm.org/citation.cfm?id=2487788.2487899}, author = {Cesare Pautasso and Masiar Babazadeh} } @article {rest:tweb:2013, title = {Control-Flow Patterns for Decentralized RESTful Service Composition}, journal = {ACM Transactions on the Web (TWEB)}, volume = {8}, year = {2013}, month = {December}, pages = {5:1{\textendash}5:30}, abstract = {The REST architectural style has attracted a lot of interest from industry due to the nonfunctional properties it contributes to Web-based solutions. SOAP/WSDL-based services, on the other hand, provide tools and methodologies that allow the design and development of software supporting complex service arrangements, enabling complex business processes which make use of well-known control-flow patterns. It is not clear if and how such patterns should be modeled, considering RESTful Web services that comply with the statelessness, uniform interface and hypermedia constraints. In this article, we analyze a set of fundamental control-flow patterns in the context of stateless compositions of RESTful services. We propose a means of enabling their implementation using the HTTP protocol and discuss the impact of our design choices according to key REST architectural principles. We hope to shed new light on the design of basic building blocks for RESTful business processes.}, keywords = {business process management, control flow, control-flow patterns, REST, service composition, Web services}, issn = {1559-1131}, doi = {10.1145/2535911}, url = {http://doi.acm.org/10.1145/2535911}, author = {Bellido, Jesus and Rosa Alarc{\'o}n and Cesare Pautasso} } @conference {aghaee2013iseud, title = {Guidelines for Efficient and Effective End-User Development of Mashups}, booktitle = {Fourth International Symposium on End-User Development (IS-EUD 2013)}, year = {2013}, month = {June}, pages = {260-265}, address = {Copenhagen, Denmark}, abstract = {End-User Development (EUD) is an emerging research area aiming at empowering non-technical users to somehow create or design software artifacts. Mashups provide a high potential for EUD activities on the Web. Users on the Web can tap into a vast resource of off-the-shelf components in order to rapidly compose new lightweight software applications called mashups. In this paper, we provide a set of guidelines to design EUD systems for mashups that are widely referred to as mashup tools. The guidelines are derived from our experience with the (ongoing) design and evaluation of NaturalMash, a novel mashup tool targeted for a wide range of users to create feature-rich mashups.}, keywords = {end-user software engineering, NaturalMash, Web mashups}, doi = {10.1007/978-3-642-38706-7_23}, author = {Saeed Aghaee 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 {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} } @conference {naturalmash:vlhcc:2013, title = {Natural End-User Development of Web Mashups}, booktitle = {IEEE Symposium on Visual Languages and Human-Centric Computing (VL/HCC 2013)}, year = {2013}, month = {September}, pages = {111 - 118 }, publisher = {IEEE}, organization = {IEEE}, address = {San Jose, CA, USA}, abstract = {End-User Development (EUD) can be exploited on the Web, where users have the opportunity to create niche {\textquotedblleft}Web Mashup{\textquotedblright} applications as a means to address their long tail of situational needs in different domains of application. In this paper, we describe the design and evaluation of NaturalMash, an innovative EUD system for mashups. NaturalMash provides a high level of expressive power while it is still usable by non-professional users. This clearly distinguishes NaturalMash from existing mashup EUD tools that are either too limited or highly specialized for inexperienced users. The NaturalMash user interface efficiently combines different techniques such as live programming, natural language programming, What You See Is What You Get (WYSIWYG), and Programming by Demonstration (PbD). The design of NaturalMash adopts a formative evaluation approach, and has completed two design and evaluation iterations. The paper reports the results of the last formative evaluation and discusses the implications of the findings. The results are promising and suggest that the proposed system has a short and gentle learning curve and enables even non-professional users to rapidly build useful mashups.}, keywords = {end-user software engineering, natural language processing, NaturalMash, service composition, Web mashups}, doi = {10.1109/VLHCC.2013.6645253}, author = {Saeed Aghaee and Cesare Pautasso and Antonella De Angeli} } @proceedings {icsoc2013, title = {Proceedings of the 11th International Conference on Service-Oriented Computing (ICSOC 2013)}, volume = {8274}, year = {2013}, month = {December}, publisher = {Springer}, address = {Berlin, Germany}, keywords = {proceedings, service oriented computing}, isbn = {978-3-642-45004-4}, issn = {0302-9743}, doi = {10.1007/978-3-642-45005-1}, url = {http://link.springer.com/10.1007/978-3-642-45005-1}, editor = {Basu, Samik and Cesare Pautasso and Zhang, Liang and Fu, Xiang} } @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} } @inbook {pautasso2013rest, title = {RESTful Web Services: Principles, Patterns and Emerging Technologies}, booktitle = {Web Services Foundations}, year = {2013}, pages = {31-51}, publisher = {Springer}, organization = {Springer}, abstract = {RESTful Web services are software services which are published on the Web, taking full advantage and making correct use of the HTTP protocol. This chapter gives an introduction to the REST architectural style and how it can be used to design Web service APIs. We summarize the main design constraints of the REST architectural style and discuss how they impact the design of so-called RESTful Web service APIs. We give examples on how the Web can be seen as a novel kind of software connector, which enables the coordination of distributed, stateful and autonomous software services. We conclude the chapter with a critical overview of a set of emerging technologies which can be used to support the development and operation of RESTful Web services. }, keywords = {REST, Web services}, isbn = {978-1-4614-7517-0}, doi = {10.1007/978-1-4614-7518-7_2}, url = {http://www.springer.com/computer/database+management+\%26+information+retrieval/book/978-1-4614-7517-0}, author = {Cesare Pautasso} } @book {soawithrest:2013, title = {SOA with REST - Principles, Patterns and Constraints for Building Enterprise Solutions with REST}, series = {The Prentice Hall service technology series}, year = {2013}, pages = {I-XXXII, 1-577}, publisher = {Prentice Hall}, organization = {Prentice Hall}, keywords = {REST, service oriented architectures, Web services}, isbn = {978-0-13-701251-0}, author = {Thomas Erl and Benjamin Carlyle and Cesare Pautasso and Raj Balasubramanian} } @conference {saw:2013:ecsa, title = {Team Situational Awareness and Architectural Decision Making with the Software Architecture Warehouse}, booktitle = {7th European Conference on Software Architecture (ECSA 2013)}, year = {2013}, month = {July}, pages = {146-161}, publisher = {Springer}, organization = {Springer}, address = {Montpellier, France}, abstract = {The core of the design of software architecture is all about architectural decision making. A high-quality design outcome sets high requirements, not only on the skills and knowledge of the design team members, but also on the management of the decision making process. We claim that in order to deliver high quality decisions, the design team needs to obtain a high level of situational awareness. To address this, we present an analysis of the problem of team situational awareness in design workshops and propose a model on how stakeholder positions help to build consensus within the argumentation viewpoint of architectural decisions. We show how the Software Architecture Warehouse tool has been extended to support the argumentation viewpoint within its live design document metaphor to provide support for co-located and distributed design workshops.}, keywords = {architectural decisions, collaborative design, SAW}, doi = {10.1007/978-3-642-39031-9_13}, author = {Marcin Nowak and Cesare Pautasso} } @conference {pjs:2014:ppopp, title = {TigerQuoll: parallel event-based JavaScript}, booktitle = {Proceedings of the 18th ACM SIGPLAN symposium on Principles and practice of parallel programming (PPoPP {\textquoteright}13)}, year = {2013}, month = {February}, pages = {251{\textendash}260}, publisher = {ACM}, organization = {ACM}, address = {Shenzhen, China}, abstract = {JavaScript, the most popular language on the Web, is rapidly moving to the server-side, becoming even more pervasive. Still, JavaScript lacks support for shared memory parallelism, making it challenging for developers to exploit multicores present in both servers and clients. In this paper we present TigerQuoll, a novel API and runtime for parallel programming in JavaScript. TigerQuoll features an event-based API and a parallel runtime allowing applications to exploit a mutable shared memory space. The programming model of TigerQuoll features automatic consistency and concurrency management, such that developers do not have to deal with shared-data synchronization. TigerQuoll supports an innovative transaction model that allows for eventual consistency to speed up high-contention workloads. Experiments show that TigerQuoll applications scale well, allowing one to implement common parallelism patterns in JavaScript.}, keywords = {JavaScript, Parallel JavaScript, TigerQuoll}, isbn = {978-1-4503-1922-5}, doi = {http://doi.acm.org/10.1145/2442516.2442541}, author = {Daniele Bonetta and Walter Binder and Cesare Pautasso} } @inproceedings {naturalmash:cweb:2012, title = {EnglishMash: Usability Design for a Natural Mashup Composition Environment}, volume = {7703}, year = {2012}, month = {July}, pages = {109-120}, publisher = {Springer}, address = {Berlin, Germany}, abstract = {The design of mashup tools combines elements from end-user development and software composition in the context of the Web. The challenge for mashup tool designers is to provide end-users with suitable abstractions, programming models and tool support for easily composing mashups out of existing Web services and Web data sources. In this paper we describe the design of a natural mashup composition environment based on the EnglishMash controlled natural language. The environment proactively supports users as they are learning the syntax of the EnglishMash language with features such as auto-completion, immediate feedback, live preview of the mashup execution and component discovery and selection based on natural language descriptions.}, keywords = {NaturalMash, Web mashups}, doi = {10.1007/978-3-642-35623-0_12}, author = {Saeed Aghaee and Cesare Pautasso} } @conference {peternier2012ICPADS, title = {Hardware-aware thread scheduling: the case of asymmetric multicore processors}, booktitle = {18th International Conference on Parallel and Distributed Systems (ICPADS)}, year = {2012}, month = {December}, pages = {400-407}, address = {Singapore}, abstract = {Modern processor architectures are increasingly complex and heterogeneous, often requiring solutions tailored to the specific characteristics of each processor model. In this paper we address this problem by targeting the AMD Bulldozer processor as case study for specific hardware-oriented performance optimizations. The Bulldozer architecture features an asymmetric simultaneous multithreading implementation with shared floating point units (FPUs) and per-core arithmetic logic units (ALUs). Bulld Over, presented in this paper, improves thread scheduling by exploiting this hardware characteristic to increase performance of floating point-intensive workloads on Linux-based operating systems. Bulld Over is a user-space monitoring tool that automatically identifies FPU-intensive threads and schedules them in a more efficient way without requiring any patches or modifications at the kernel level. Our measurements using standard benchmark suites show that speedups of up to 10\% can be achieved by simply allowing Bulld Over to monitor applications, without any modification of the workload.}, doi = {http://doi.ieeecomputersociety.org/10.1109/ICPADS.2012.62}, author = {Achille Peternier and Danilo Ansaloni and Daniele Bonetta and Cesare Pautasso and Walter Binder} } @conference {bonetta2012EuroPar, title = {Node.Scala: Implicit Parallel Programming for High-Performance Web Services}, booktitle = {International European Conference on Parallel and Distributed Computing (EuroPar 2012)}, volume = {7484}, year = {2012}, month = {August}, pages = {626{\textendash}637}, publisher = {Springer}, organization = {Springer}, address = {Rhodes Island, Greece}, keywords = {Node.JS, REST, Scala, scalability, Web services}, isbn = {978-3-642-32819-0}, url = {http://sosoa.inf.unisi.ch/files/sosoa_europar2012.pdf}, author = {Daniele Bonetta and Danilo Ansaloni and Achille Peternier and Cesare Pautasso and Walter Binder} } @article {DBLP:journals/internet/VitvarVP12, title = {Programmatic Interfaces for Web Applications}, journal = {IEEE Internet Computing}, volume = {16}, number = {4}, year = {2012}, pages = {11-14}, keywords = {programmable web, REST, Web APIs, Web services}, doi = {http://doi.ieeecomputersociety.org/10.1109/MIC.2012.86}, author = {Tomas Vitvar and Steve Vinoski 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 {DBLP:conf/eics/AghaeeNP12, title = {Reusable decision space for mashup tool design}, booktitle = {4th ACM SIGCHI symposium on Engineering interactive computing systems (EICS 2012)}, year = {2012}, month = {June}, pages = {211-220}, address = {Copenhagen, Denmark}, abstract = {Mashup tools are a class of integrated development environments that enable rapid, on-the-fly development of mashups - a type of lightweight Web applications mixing content and services provided through the Web. In the past few years there have been growing number of projects, both from academia and industry, aimed at the development of innovative mashup tools. From the software architecture perspective, the massive effort behind the development of these tools creates a large pool of reusable architectural decisions from which the design of future mashup tools can derive considerable benefits. In this paper, focusing on the design of mashup tools, we explore a design space of decisions comprised of design issues and alternatives. The design space knowledge not only is broad enough to explain the variability of existing tools, but also provides a road-map towards the design of next generation mashup tools.}, keywords = {architectural decisions, design space, survey, Web mashups}, doi = {10.1145/2305484.2305520}, author = {Saeed Aghaee and Marcin Nowak and Cesare Pautasso} } @conference {s:2012:ppopp, title = {S: a scripting language for high-performance RESTful web services}, booktitle = {17th ACM SIGPLAN symposium on Principles and Practice of Parallel Programming (PPoPP 2012)}, year = {2012}, month = {February}, pages = {97{\textendash}106}, publisher = {ACM}, organization = {ACM}, address = {New Orleans, USA}, abstract = {There is an urgent need for novel programming abstractions to leverage the parallelism in modern multicore machines. We introduce S, a new domain-specific language targeting the server-side scripting of high-performance RESTful Web services. S promotes an innovative programming model based on explicit (control-flow) and implicit (process-level) parallelism control, allowing the service developer to specify which portions of the control-flow should be executed in parallel. For each service, the choice of the best level of parallelism is left to the runtime system. We assess performance and scalability by implementing two non-trivial composite Web services in S. Experiments show that S-based Web services can handle thousands of concurrent client requests on a modern multicore machine.}, keywords = {REST, scripting, Web service composition}, isbn = {978-1-4503-1160-1}, doi = {10.1145/2145816.2145829}, author = {Daniele Bonetta and Achille Peternier and Cesare Pautasso and Walter Binder} } @demo {2012:wicsa:saw, title = {Software Architecture Warehouse: live and collaborative architectural decision making}, year = {2012}, address = {Helsinki, Finland}, author = {Marcin Nowak 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} } @proceedings {wsrest2012, title = {Third International Workshop on RESTful Design (WS-REST 2012)}, year = {2012}, month = {March}, publisher = {ACM}, address = {Lyon, France}, keywords = {proceedings, REST}, isbn = {978-1-4503-1190-8}, doi = {10.1145/2307819.2307821}, url = {http://dl.acm.org/citation.cfm?id=2307819}, editor = {Rosa Alarc{\'o}n and Cesare Pautasso and Erik Wilde} } @proceedings {ecows2011, title = {9th IEEE European Conference on Web Services (ECOWS 2011)}, year = {2011}, month = {September}, publisher = {IEEE}, address = {Lugano, Switzerland}, keywords = {proceedings, Web services}, isbn = {978-1-4577-1532-7}, url = {http://ieeexplore.ieee.org/xpl/mostRecentIssue.jsp?punumber=6059529}, editor = {Gianluigi Zavattaro and Ulf Schreier and Cesare Pautasso} } @conference {5959776, title = {An Architectural Style for Liquid Web Services}, booktitle = {9th Working IEEE/IFIP Conference on Software Architecture (WICSA 2011)}, year = {2011}, month = {June}, pages = {232-241}, address = {Boulder, CO, USA}, abstract = {Just as liquids adapt their shape to the one of their container, liquid architectures feature a high degree of adaptability so that they can provide scalability to applications as they are executed on a wide variety of heterogeneous deployment environments. In this paper we enumerate the properties to be guaranteed by so-called liquid service-oriented architectures and define a set of design constraints that make up a novel architectural style for liquid architectures. These constraints drive the careful construction of a pattern, the Restful Actor (Reactor), which enables to deliver the required scalability by means of replication of its constituent parts. Reactors feature a Restful Web service interface and a composable architecture which is capable of delivering scalability and high performance in a way that is independent from the chosen deployment infrastructure. We discuss how the Reactor can be deployed to run on distributed (shared-nothing) execution environments typical of virtualized Cloud computing environments as well as on modern multicore processors with shared memory architectures.}, keywords = {architectural styles, cloud computing, design constraints, liquid service oriented architectures, liquid Web services, multicores, patterns, performance, REST, RESTful actor, RESTful Web service interface, scalability, shared memory architectures, virtualized cloud computing environments, Web services}, doi = {10.1109/WICSA.2011.38}, author = {Daniele Bonetta and Cesare Pautasso} } @conference {rest:bpmn2011, title = {BPMN for REST}, booktitle = {Third International Business Process Modeling Notation Workshop (BPMN 2011)}, year = {2011}, month = {November}, pages = {74-87}, address = {Lucerne, Switzerland}, abstract = {The Representational State Transfer (REST) architectural style has seen substantial growth and adoption for the design of modern Resource-Oriented Architectures. However, the impact of fundamental constraints such as stateful resources, stateless interactions, and the uniform interface have had only limited uptake and impact in the Business Process Modeling (BPM) community in general, and in the standardization activities revolving around the BPMN notation. In this paper we propose a simple and minimal extension of the BPMN 2.0 notation to provide first-class support for the concept of resource. We show several examples of how the extended notation can be used to externalize the state of a process as a resource, as well as to describe process-driven composition of resources.}, keywords = {business process modeling notation, REST, RESTful business process management}, doi = {10.1007/978-3-642-25160-3_6}, author = {Cesare Pautasso} } @article {DBLP:conf/icwe/AghaeeP11a, title = {End-User Programming for Web Mashups - Open Research Challenges}, volume = {7059}, year = {2011}, month = {June}, pages = {347-351}, publisher = {Springer}, address = {Paphos, Cyprus}, abstract = {Mashup is defined as the practice of lightweight composition, serendipitous reuse, and user-centric development on the Web. In spite of the fact that the development of mashups is rather simple due to the reuse of all the required layers of a Web application (functionality, data, and user interface), it still requires programming experience. This is a significant hurdle for non-programmers (end-users with minimal or no programming experience), who constitute the majority of Web users. To cope with this, an End-User Programming (EUP) tool can be designed to reduce the barriers of mashup development, in a way that even non-programmers will be able to create innovative, feature-rich mashups. In this paper, we give an overview of the existing EUP approaches for mashup development, as well as a list of open research challenges.}, keywords = {end-user software engineering, Web mashups}, doi = {10.1007/978-3-642-27997-3_38}, author = {Saeed Aghaee and Cesare Pautasso} } @inproceedings {icwe:2011:naturalmash, title = {An Evaluation of Mashup Tools Based on Support for Heterogeneous Mashup Components}, volume = {7059}, year = {2011}, month = {June}, pages = {1-12}, publisher = {Springer}, address = {Paphos, Cyprus}, abstract = {Mashups are built by combining building blocks, which are commonly referred to as mashup components. These components are characterized by a high level of heterogeneity in terms of technologies, access methods, and the behavior they may exhibit within a mashup. Abstracting away this heterogeneity is the mission of the so-called mashup tools aiming at automating or semi-automating mashup development to serve non-programmers. The challenge is to ensure this abstraction mechanism does not limit the support for heterogeneous mashup components. In this paper, we propose a novel evaluation framework that can be applied to assess the degree to which a given mashup tool addresses this challenge. The evaluation framework can serve as a benchmark for future improved design of mashup tools with respect to heterogeneous mashup components support. In order to demonstrate the applicability of the framework, we also apply it to evaluate some existing tools.}, doi = {10.1007/978-3-642-27997-3_1}, author = {Saeed Aghaee and Cesare Pautasso} } @inproceedings {saw:2011:shark, title = {Goals, questions and metrics for architectural decision models}, year = {2011}, month = {May}, pages = {21{\textendash}28}, publisher = {ACM}, address = {Waikiki, Hawaii, USA}, abstract = {Architectural decisions are the key element behind the design process leading to a software architecture. Making software architects aware of the implications of their decisions is only the beginning of what can be achieved by capturing the rationale and the constraints influencing the decision making process in a reusable body of architectural knowledge. In this paper we propose a metric-based approach to the analysis of architectural decision models. Using a hierarchically-structured approach we identify a number of useful goals and stakeholders involved in the architectural design process. Next, we sketch a set of metrics to provide data for the evaluation of the aforementioned goals. Our aim is to stimulate a discussion on how to find indicators relevant for software architects by measuring the intrinsic properties of architectural knowledge.}, keywords = {architectural decision modeling, metrics, SAW, software architecture, visualization}, isbn = {978-1-4503-0596-9}, doi = {10.1145/1988676.1988682}, author = {Marcin Nowak and Cesare Pautasso} } @proceedings {icsoc:2011:phd, title = {ICSOC2011 Phd Symposium Preface}, volume = {7221}, year = {2011}, month = {December}, pages = {162-163}, publisher = {Springer}, address = {Paphos, Cyprus}, keywords = {proceedings, service oriented computing}, doi = {10.1007/978-3-642-31875-7_16}, author = {Quan Z. Sheng and Cesare Pautasso and Sonia Ben Mokhtar} } @inbook {DBLP:books/sp/wilde2011/PautassoW11, title = {Introduction to REST: From Research to Practice}, booktitle = {REST: From Research to Practice}, year = {2011}, pages = {1-18}, publisher = {Springer}, organization = {Springer}, chapter = {1}, keywords = {REST}, doi = {10.1007/978-1-4419-8303-9_0}, url = {http://ws-rest.org/book/}, author = {Cesare Pautasso and Erik Wilde} } @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} } @conference {overseer:2011:pppj, title = {Overseer: low-level hardware monitoring and management for Java}, booktitle = {9th International Conference on Principles and Practice of Programming in Java (PPPJ {\textquoteright}11)}, year = {2011}, pages = {143{\textendash}146}, publisher = {ACM}, organization = {ACM}, address = {New York, NY, USA}, abstract = {The high-level and portable nature of the Java platform allows applications to be written once and executed on all the supported systems. However, such a feature comes at the cost of hardware abstraction, making it more difficult or even impossible to access several low-level functionalities. Overseer is a Java framework that makes it possible on Linux systems by simplifying access to real-time measurement of low-level data such as Hardware Performance Counters (HPCs), IPMI sensors, and Java VM internal events. Overseer supports functionalities such as HPC-management, process/thread affinity settings, hardware topology identification, as well as power-consumption and temperature monitoring. In this paper we describe Overseer and how to use it to extend Java applications with functionalities not provided by the default runtime. A public release of Overseer is available.}, keywords = {hardware performance counters, Java, monitoring, Overseer}, isbn = {978-1-4503-0935-6}, doi = {http://doi.acm.org/10.1145/2093157.2093179}, author = {Achille Peternier and Daniele Bonetta and Walter Binder and Cesare Pautasso} } @conference {rest:bpm:icsoc2011, title = {Push-Enabling RESTful Business Processes}, booktitle = {9th International Conference on Service-Oriented Computing (ICSOC 2011)}, volume = {7084}, year = {2011}, month = {December}, pages = {32-46}, publisher = {Springer}, organization = {Springer}, address = {Paphos, Cyprus}, abstract = {Representational State Transfer (REST) as an architectural style for service design has seen substantial uptake in the past years. However, some areas such as Business Process Modeling (BPM) and push services so far have not been addressed in the context of REST principles. In this work, we look at how both BPM and push can be combined so that business processes can be modeled and observed in a RESTful way. Based on this approach, clients can subscribe to be notified when certain states in a business process are reached. Our goal is to design an architecture that brings REST{\textquoteright}s claims of loose coupling and good scalability to the area of BPM, and still allow process-driven composition and interaction between resources to be modeled.}, keywords = {business process management, REST, RESTful business process management}, doi = {10.1007/978-3-642-25535-9_3}, author = {Cesare Pautasso and Erik Wilde} } @book {rest:2011, title = {REST: From Research to Practice}, year = {2011}, publisher = {Springer}, organization = {Springer}, address = {New York, NY}, keywords = {REST}, isbn = {978-1-4419-8302-2}, doi = {10.1007/978-1-4419-8303-9}, url = {http://ws-rest.org/book/}, editor = {Erik Wilde and Cesare Pautasso} } @conference {www:wsrest2011, title = {Second international workshop on RESTful design (WS-REST 2011)}, booktitle = {WWW (Companion Volume)}, year = {2011}, month = {March}, pages = {311-312}, publisher = {ACM}, organization = {ACM}, address = {Hyderabad, India}, keywords = {proceedings, REST}, isbn = {978-1-4503-0637-9}, doi = {http://doi.acm.org/10.1145/1963192.1963327}, author = {Cesare Pautasso and Erik Wilde and Rosa Alarc{\'o}n} } @inbook {DBLP:books/sp/wilde2011/PardonP11, title = {Towards Distributed Atomic Transactions over RESTful Services}, booktitle = {REST: From Research to Practice}, year = {2011}, pages = {507-524}, publisher = {Springer}, organization = {Springer}, abstract = {There is considerable debate in the REST community whether or not transaction support is needed and possible. This chapter{\textquoteright}s contribution to this debate is threefold: we define a business case for transactions in REST based on the Try-Cancel/Confirm (TCC) pattern; we outline a very light-weight protocol that guarantees atomicity and recovery over distributed REST resources; and we discuss the inherent theoretical limitations of our approach. Our TCC for REST approach minimizes the assumptions made on the individual services that can be part of a transaction and does not require any extension to the HTTP protocol. A very simple but realistic example helps to illustrate the applicability of the approach.}, keywords = {atomic transactions, REST, RESTful Web service interface, try-confirm-cancel}, doi = {10.1007/978-1-4419-8303-9_23}, author = {Guy Pardon and Cesare Pautasso} } @article {DBLP:conf/www/BonettaP11, title = {Towards liquid service oriented architectures}, year = {2011}, month = {April}, pages = {337-342}, publisher = {ACM}, address = {Hyderabad, India}, abstract = {The advent of Cloud computing platforms, and the growing pervasiveness of Multicore processor architectures have revealed the inadequateness of traditional programming models based on sequential computations, opening up many challenges for research on parallel programming models for building distributed, service-oriented systems. More in detail, the dynamic nature of Cloud computing and its virtualized infrastructure pose new challenges in term of application design, deployment and dynamic reconfiguration. An application developed to be delivered as a service in the Cloud has to deal with poorly understood issues such as elasticity, infinite scalability and portability across heterogeneous virtualized environments. In this position paper we define the problem of providing a novel parallel programming model for building application services that can be transparently deployed on multicore and cloud execution environments. To this end, we introduce and motivate a research plan for the definition of a novel programming framework for Web service-based applications. Our vision called "Liquid Architecture" is based on a programming model inspired by core ideas tied to the REST architectural style coupled with a self-configuring runtime that allows transparent deployment of Web services on a broad range of heterogeneous platforms, from multicores to clouds.}, doi = {http://doi.acm.org/10.1145/1963192.1963340}, author = {Daniele Bonetta and Cesare Pautasso} } @inproceedings {sosoa:2011, title = {Towards Self-Organizing Service-Oriented Architectures}, year = {2011}, month = {July}, pages = {115-121}, publisher = {IEEE}, address = {Washington, DC, USA}, abstract = {Service-oriented architectures (SOAs) provide a successful model for structuring complex distributed software systems, as they reduce the cost of ownership and ease the creation of new applications by composing existing services. However, currently, the development of service-oriented applications requires many manual tasks and prevailing infrastructure is often based on centralized components that are central points of failure and easily become bottlenecks. In this paper, we promote self-organizing SOA as a new approach to overcome these limitations. Self-organizing SOA integrates research results in the areas of autonomic and service oriented computing. We consider self-organizing features for the whole life-cycle of a service-oriented application, from the creation to the execution, optimization, and monitoring.}, keywords = {autonomic computing, monitoring, self-organizing service-oriented architecture, service composition, service oriented computing, Web services}, doi = {10.1109/SERVICES.2011.44}, author = {Walter Binder and Daniele Bonetta and Cesare Pautasso and Achille Peternier and Diego Milano and Heiko Schuldt and Nenad Stojnic and Boi Faltings and Immanuel Trummer} } @proceedings {ecows2010, title = {8th IEEE European Conference on Web Services (ECOWS 2010)}, year = {2010}, month = {December}, publisher = {IEEE}, address = {Ayia Napa, Cyprus}, keywords = {proceedings, Web services}, isbn = {978-1-4244-9397-5}, url = {http://ieeexplore.ieee.org/xpl/mostRecentIssue.jsp?punumber=5691022}, editor = {Antonio Brogi and Cesare Pautasso and George Angelos Papadopoulos} } @inproceedings {saw:2010:shark, title = {Architectural decision modeling with reuse}, year = {2010}, month = {May}, pages = {13 - 20}, publisher = {ACM}, address = {Cape Town, South Africa}, abstract = {Architectural decision modeling aims at supporting the software architecture design process by capturing a reusable body of architectural knowledge. Whereas significant progress has been made towards this vision, there still remains a number of open problems. This paper outlines selected research challenges and opportunities related to knowledge capturing and sharing, model evolution and verification, and the integration of the architectural design process with existing software development methodologies. Our goal is to start a discussion on a roadmap for future research on reusable modeling of architectural decisions.}, keywords = {architectural decisions, SAW}, isbn = {9781605589671}, doi = {10.1145/1833335.1833338}, author = {Marcin Nowak and Cesare Pautasso and Olaf Zimmermann} } @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} } @conference {jopera:2010:soca, title = {Exploiting multicores to optimize business process execution}, booktitle = {International Conference on Service-Oriented Computing and Applications (SOCA 2010)}, year = {2010}, month = {December}, pages = {1-8}, publisher = {IEEE}, organization = {IEEE}, address = {Perth, Australia}, abstract = {While modern CPUs offer an increasing number of cores with shared caches, prevailing execution engines for business processes, workflows, or Web service compositions have not been optimized for properly exploiting the abundant processing resources of such CPUs. One factor limiting performance is the inefficient thread scheduling by the operating system, which can result in suboptimal use of shared caches. In this paper we study performance of the JOpera business process execution engine on a recent multicore machine. By analyzing the engine{\textquoteright}s architecture and by binding threads that are likely to access shared data to cores with a common cache, we achieve speedups up to 13\% for a variety of workloads, without modifying the engine{\textquoteright}s architecture and implementation, apart from binding threads to CPUs. As the engine is implemented in Java, we provide a new Java library to manage thread bindings and hardware performance counters. We also leverage hardware performance counters to explain the observed speedup in our performance analysis.}, keywords = {business data processing, business process execution engines, business process execution optimization, hardware performance counters, Java, JOpera, multicores, performance optimization, thread-CPU bindings, Web service composition, Web services, workflow}, doi = {10.1109/SOCA.2010.5707156}, author = {Achille Peternier and Daniele Bonetta and Cesare Pautasso and Walter Binder} } @proceedings {wsrest2010, title = {First International Workshop on RESTful Design (WS-REST 2010)}, year = {2010}, month = {April}, publisher = {ACM}, address = {Raleigh, NC, USA}, doi = {http://doi.acm.org/10.1145/1798354.1798375}, url = {http://portal.acm.org/beta/citation.cfm?id=1798354}, editor = {Cesare Pautasso and Erik Wilde and Alexandros Marinos} } @article {5453330, title = {Information Quality in Mashups}, journal = {Internet Computing}, volume = {14}, number = {4}, year = {2010}, month = {July-August}, pages = {14-22}, abstract = {Modern Web 2.0 applications are characterized by high user involvement: users receive support for creating content and annotations as well as "composing" applications using content and functions from third parties. This latter phenomenon is known as Web mashups and is gaining popularity even with users who have few programming skills, raising a set of peculiar information quality issues. Assessing a mashup{\textquoteright}s quality, especially the information it provides, requires understanding how the mashup has been developed, how its components look alike, and how quality propagates from basic components to the final mashup application.}, keywords = {component quality, information quality, mashup patterns, mashups, quality metrics, Web 2.0 applications, Web mashups}, issn = {1089-7801}, doi = {10.1109/MIC.2010.60}, author = {Cinzia Cappiello and Florian Daniel and Maristella Matera 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} } @inproceedings {1948635, title = {Towards scalable service composition on multicores}, year = {2010}, month = {October}, pages = {655{\textendash}664}, publisher = {Springer}, address = {Crete}, abstract = {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 service composition engines in order to take full advantage of the underlying hardware resources. In this paper we introduce an innovative service composition engine architecture, which takes into account specific features of multicore machines while not being constrained to run on any particular processor architecture. Our preliminary performance evaluation results show that the system can scale to run thousands of concurrent business process instances per second.}, keywords = {JOpera, multicore, Web service composition}, isbn = {3-642-16960-0}, doi = {10.1007/978-3-642-16961-8_90}, author = {Daniele Bonetta and Achille Peternier and Cesare Pautasso and Walter Binder} } @inbook {jopera:2009:compiler, title = {Compiling Business Process Models into Executable Code}, booktitle = {Handbook of Research in Business Process Management}, year = {2009}, pages = {218-337}, publisher = {IGI Global}, organization = {IGI Global}, chapter = {15}, abstract = {Model-driven architecture (MDA), design and transformation techniques can be applied with success to the domain of business process modeling (BPM) with the goal of making the vision of business-driven development a reality. This chapter is centered around the idea of compiling business process models for executing them, and how this idea has been driving the design of the JOpera for Eclipse workflow management tool. JOpera presents users with a simple, graph-based process modeling language with a visual representation of both control and data-flow aspects. As an intermediate representation, the graphs are converted into Event-Condition-Action rules, which are further compiled into Java bytecode for efficient execution. These transformations of process models are performed by the JOpera process compiler in a completely transparent way, where the generated executable artifacts are kept hidden from users at all times (i.e., even for debugging process executions, which is done by augmenting the original, high level notation). We evaluate our approach by discussing how using a compiler has opened up the several possibilities for performing optimization on the generated code and also simplified the design the corresponding workflow engine architecture.}, keywords = {business process execution engines, model-driven engineering}, issn = {978-1-60566-288-6}, url = {http://www.igi-global.com/book/handbook-research-business-process-modeling/445}, author = {Cesare Pautasso} } @conference {jopera:2009:sc, title = {Composing RESTful Services with JOpera}, booktitle = {8th International Conference on Software Composition}, volume = {5634}, year = {2009}, month = {July}, pages = {142-159}, publisher = {Springer}, organization = {Springer}, address = {Zurich, Switzerland}, abstract = {The REST architectural style is emerging as an alternative technology platform for the realization of service-oriented architectures. In this paper, we apply the notion of composition to RESTful services and derive a set of language features that are required by composition languages for RESTful services: dynamic late binding, dynamic typing, content-type negotiation, state inspection, and compliance with the uniform interface principle. To show how such requirements can be satisfied by an existing composition language, we include a case-study using the JOpera visual composition language. In it, we present how to build a composite application (DoodleMap) out of some well-known, public and currently existing RESTful service APIs.}, keywords = {JOpera, REST, Web service composition}, doi = {10.1007/978-3-642-02655-3_11}, author = {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} } @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} } @article {DBLP:journals/dke/Pautasso09, title = {RESTful Web service composition with BPEL for REST}, journal = {Data Knowl. Eng.}, volume = {68}, number = {9}, year = {2009}, month = {September}, pages = {851-866}, abstract = {Current Web service technology is evolving towards a simpler approach to define Web service APIs that challenges the assumptions made by existing languages for Web service composition. RESTful Web services introduce a new kind of abstraction, the resource, which does not fit well with the message-oriented paradigm of the Web service description language (WSDL). RESTful Web services are thus hard to compose using the Business Process Execution Language (WS-BPEL), due to its tight coupling to WSDL. The goal of the BPEL for REST extensions presented in this paper is twofold. First, we aim to enable the composition of both RESTful Web services and traditional Web services from within the same process-oriented service composition language. Second, we show how to publish a BPEL process as a RESTful Web service, by exposing selected parts of its execution state using the REST interaction primitives. We include a detailed example on how BPEL for REST can be applied to orchestrate a RESTful e-Commerce scenario and discuss how the proposed extensions affect the architecture of a process execution engine. }, keywords = {BPEL, REST, Web service composition}, doi = {http://dx.doi.org/10.1016/j.datak.2009.02.016}, author = {Cesare Pautasso} } @proceedings {mashups09, title = {Third international workshop on web APIs and services Mashups (Mashups{\textquoteright}09)}, year = {2009}, pages = {695-696}, address = {Orlando, Florida}, keywords = {proceedings, Web mashups}, doi = {http://doi.acm.org/10.1145/1639950.1639969}, url = {http://mashup.inf.unisi.ch/mashups09/index.php}, author = {Cesare Pautasso and Stefan Tai and E. Michael Maximilien} } @conference {tie:2009:gpc, title = {The Tiny Instrument Element}, booktitle = {4th International Conference on Advances in Grid and Pervasive Computing (GPC 2009)}, year = {2009}, month = {May}, pages = {293-304}, publisher = {Springer}, organization = {Springer}, address = {Geneva, Switzerland}, abstract = {In the past few years, the idea of extending the Grid to cover also the remote access, control, management of instrument devices has been explored in a few initiatives. Existing tools lack in generality and require advanced specialized computer science knowledge, thus making them difficult to be broadly adopted in the scientific community. In this paper we present a new open source initiative that is designed to overcome these problems. The Tiny Instrument Element project defines a high level architecture for plugging instruments into the Grid and provides the corresponding skeleton implementation. This lightweight approach, as opposed to existing middleware-based solutions, reduces the effort required to Gridify existing instruments. The paper evaluates the proposed abstraction with a case study from a pervasive computing scenario.}, keywords = {pervasive computing, REST, Web of Things}, doi = {10.1007/978-3-642-01671-4_27}, author = {Francesco Lelli and Cesare Pautasso} } @conference {restws:2009:www, title = {Why is the Web Loosely Coupled? A Multi-Faceted Metric for Service Design}, booktitle = {18th World Wide Web Conference (WWW2009)}, year = {2009}, month = {April}, pages = {911-920}, publisher = {ACM}, organization = {ACM}, address = {Madrid, Spain}, abstract = {Loose coupling is often quoted as a desirable property of systems architectures. One of the main goals of building systems using Web technologies is to achieve loose coupling. However, given the lack of a widely accepted definition of this term, it becomes hard to use coupling as a criterion to evaluate alternative Web technology choices, as all options may exhibit, and claim to provide, some kind of "loose" coupling effects. This paper presents a systematic study of the degree of coupling found in service-oriented systems based on a multi-faceted approach. Thanks to the metric introduced in this paper, coupling is no longer a one-dimensional concept with loose coupling found somewhere in between tight coupling and no coupling. The paper shows how the metric can be applied to real-world examples in order to support and improve the design process of service-oriented systems.}, keywords = {coupling, REST, RESTful Web service interface}, doi = {10.1145/1526709.1526832}, author = {Cesare Pautasso and Erik Wilde} } @conference {jopera:2008:icac, title = {Automatic Configuration of an Autonomic Controller: An Experimental Study with Zero-Configuration Policies}, booktitle = {5th International Conference on Autonomic Computing (ICAC 2008)}, year = {2008}, month = {June}, pages = {67-76}, publisher = {IEEE}, organization = {IEEE}, address = {Chicago, IL, USA}, abstract = {Autonomic control managers can remove the need for manual system configuration in order to achieve good performance and efficient resource utilization. However, simple controllers based on reconfiguration actions tied to thresholds, or {\textquoteright}if-then{\textquoteright} rules, themselves need to be configured and tuned in order to adapt the controller behavior to the expected workload characteristic. In this paper we present an experimental study of zero-configuration policies that can be automatically tuned based on analytical models of the system under control. In particular, we have designed and implemented a threshold-free self-configuration policy for a distributed workflow execution engine and compared it with a standard PID controller. The experimental results included in the paper show that using such a policy the controller can tune itself in addition to reconfiguring the distributed engine and the proposed policy out-performs simpler policies that require manual and error-prone tuning of their parameters.}, keywords = {analytical models, automatic configuration, automatic control, autonomic controller, control system synthesis, distributed workflow execution engine, PID control, resource management, resource utilization, workload characteristic, zero-configuration policies}, doi = {10.1109/ICAC.2008.29}, author = {Thomas Heinis and Cesare Pautasso} } @conference {bpel4rest:2008:bpm, title = {BPEL for REST}, booktitle = {7th International Conference on Business Process Management (BPM08)}, volume = {5240}, year = {2008}, month = {September}, pages = {278-293}, publisher = {Springer}, organization = {Springer}, address = {Milan, Italy}, abstract = {Novel trends in Web services technology challenge the assumptions made by current standards for process-based service composition. Most RESTful Web service APIs, which do not rely on the Web service description language (WSDL), cannot easily be composed using the BPEL language. In this paper we propose a lightweight BPEL extension to natively support the composition of RESTful Web services using business processes. We also discuss how to expose the execution state of a business process so that it can be manipulated through REST primitives in a controlled way.}, keywords = {BPEL, REST, RESTful business process management}, doi = {10.1007/978-3-540-85758-7_21}, author = {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 {ccgrid2008, title = {Initializing a National Grid Infrastructure Lessons Learned from the Swiss National Grid Association Seed Project}, booktitle = {8th IEEE International Symposium on Cluster Computing and the Grid (CCGRID 2008)}, year = {2008}, month = {May}, pages = {169-176}, publisher = {IEEE}, organization = {IEEE}, address = {Lyon, France}, abstract = {In addition to multi-national Grid infrastructures, several countries operate their own national Grid infrastructures to support science and industry within national borders. These infrastructures have the benefit of better satisfying the needs of local, regional and national user communities. Although Switzerland has strong research groups in several fields of distributed computing, only recently a national Grid effort was kick-started to integrate a truly heterogeneous set of resource providers, middleware pools, and users. In the following article we discuss our efforts to start Grid activities at a national scale to combine several scientific communities and geographical domains. We make a strong case for the need of standards that have to be built on top of existing software systems in order to provide support for a heterogeneous Grid infrastructure.}, keywords = {distributed computing, grid computing, middleware, national grid infrastructure}, doi = {10.1109/CCGRID.2008.62}, author = {Nabil Abdennadher and Peter Engel and Derek Feichtinger and Dean Flanders and Placi Flury and Sigve Haug and Pascal Jermini and Sergio Maffioletti and Cesare Pautasso and Heinz Stockinger and Wibke Sudholt and Michela Thi{\'e}mard and Nadya Williams and Christoph Witzig} } @proceedings {mashups:2008, title = {Introduction: Second International Workshop on Web APIs and Services Mashups (Mashups 2008)}, volume = {5472}, year = {2008}, month = {December}, pages = {133-135}, publisher = {Springer}, address = {Sidney, Australia}, keywords = {Web mashups}, doi = {10.1007/978-3-642-01247-1_12}, author = {Cesare Pautasso and Stefan Tai and E. Michael Maximilien} } @proceedings {bpm:2008:mde4bpm, title = {Introduction to the First International Workshop on Model-Driven Engineering for Business Process Management (MDE4BPM 2008)}, year = {2008}, month = {September}, pages = {173-175}, publisher = {Springer}, address = {Milano, Italy}, doi = {10.1007/978-3-642-00328-8_17}, url = {http://www.inf.usi.ch/mde4bpm08/}, author = {Cesare Pautasso and Jana Koehler} } @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 {www08restsoap, title = {RESTful Web Services vs. Big Web Services: Making the Right Architectural Decision}, booktitle = {17th World Wide Web Conference (WWW 2008)}, year = {2008}, month = {April}, pages = {805-814}, publisher = {ACM}, organization = {ACM}, address = {Beijing, China}, abstract = {Recent technology trends in the Web Services (WS) domain indicate that a solution eliminating the presumed complexity of the WS-* standards may be in sight: advocates of REpresentational State Transfer (REST) have come to believe that their ideas explaining why the World Wide Web works are just as applicable to solve enterprise application integration problems and to simplify the plumbing required to build service-oriented architectures. In this paper we objectify the WS-* vs. REST debate by giving a quantitative technical comparison based on architectural principles and decisions. We show that the two approaches differ in the number of architectural decisions that must be made and in the number of available alternatives. This discrepancy between freedom-from-choice and freedom-of-choice explains the complexity difference perceived. However, we also show that there are significant differences in the consequences of certain decisions in terms of resulting development and maintenance costs. Our comparison helps technical decision makers to assess the two integration styles and technologies more objectively and select the one that best fits their needs: REST is well suited for basic, ad hoc integration scenarios, WS-* is more flexible and addresses advanced quality of service requirements commonly occurring in enterprise computing. }, keywords = {architectural decisions, REST, SOAP, Web services}, doi = {10.1145/1367497.1367606}, author = {Cesare Pautasso and Olaf Zimmermann and Frank Leymann} } @article {DBLP:journals/bioinformatics/QuandtHMHMPAL08, title = {swissPIT: a novel approach for pipelined analysis of mass spectrometry data}, journal = {Bioinformatics}, volume = {24}, number = {11}, year = {2008}, pages = {1416-1417}, abstract = {The identification and characterization of peptides from tandem mass spectrometry (MS/MS) data represents a critical aspect of proteomics. Today, tandem MS analysis is often performed by only using a single identification program achieving identification rates between 10-50\% (Elias and Gygi, 2007). Beside the development of new analysis tools, recent publications describe also the pipelining of different search programs to increase the identification rate (Hartler et al., 2007; Keller et al., 2005). The Swiss Protein Identification Toolbox (swissPIT) follows this approach, but goes a step further by providing the user an expandable multi-tool platform capable of executing workflows to analyze tandem MS-based data. One of the major problems in proteomics is the absent of standardized workflows to analyze the produced data. This includes the pre-processing part as well as the final identification of peptides and proteins. The main idea of swissPIT is not only the usage of different identification tool in parallel, but also the meaningful concatenation of different identification strategies at the same time. The swissPIT is open source software but we also provide a user-friendly web platform, which demonstrates the capabilities of our software and which is available at http://swisspit.cscs.ch upon request for account.}, keywords = {bioinformatics, scientific workflow management}, doi = {10.1093/bioinformatics/btn139}, url = {http://www.ncbi.nlm.nih.gov/pubmed/18436540}, author = {Andreas Quandt and Patricia Hernandez and Alexandre Masselot and C{\'e}line Hernandez and Sergio Maffioletti and Cesare Pautasso and Ron D. Appel and Fr{\'e}d{\'e}rique Lisacek} } @conference {adkwik:2007:seke, title = {ADkwik: Web 2.0 Collaboration System for Architectural Decision Engineering}, booktitle = {Nineteenth International Conference on Software Engineering and Knowledge Engineering (SEKE 2007)}, year = {2007}, month = {July}, pages = {255-260}, address = {Boston, USA}, abstract = {Capturing and sharing software architecture design rationale has always been particularly challenging in complex application domains such as enterprise computing. Facing the ongoing acceleration of technology innovation and economic forces such as outsourcing and offshoring, conservative knowledge management practices and existing tools are no longer sufficient, offering only rudimentary support for knowledge exchange and collaboration on the Internet. In this paper, we present ADkwik, a Web 2.0 collaboration system supporting the cooperative decision making work of software architects. We describe the realization of ADkwik as a situational application wiki and discuss initial evaluation results. Thanks to its ease of use, ADkwik has already shown concrete benefits to its users, including rapid team orientation, tangible decision making advice, and simplification of asset harvesting.}, keywords = {architectural decisions}, author = {Nelly Schuster and Olaf Zimmermann and Cesare Pautasso} } @article {jopjauto07, title = {Autonomic resource provisioning for software business processes}, journal = {Information and Software Technology}, volume = {49}, year = {2007}, month = {January}, pages = {65-80}, abstract = {Software development nowadays involves several levels of abstraction: starting from the programming of single objects, to their combination into components, to their publication as services and the overall architecture linking elements at each level. As a result, software engineering is dealing with a wider range of artifacts and concepts (i.e., in the context of this paper: services and business processes) than ever before. In this paper we explore the importance of having an adequate engine for executing business processes written as compositions of Web services. The paper shows that, independently of the composition language used, the overall scalability of the system is determined by how the run-time engine treats the process execution. This is particularly relevant at the service level because publishing a process through a Web service interface makes it accessible to an unpredictable and potentially very large number of clients. As a consequence, the process developer is confronted with the difficult question of resource provisioning. Determining the optimal configuration of the distributed engine that runs the process becomes sensitive both to the actual number of clients and to the kinds of processes to be executed. The main contribution of the paper is to show how resource provisioning for software business processes can be solved using autonomic computing techniques. The engine separates execution in two stages (navigation and dispatching) and uses a controller to allocate the node of a cluster of computers to each one of those stages as the workload changes. The controller can be configured with different policies that define how to reconfigure the system. To prove the feasibility of the concept, we have implemented the autonomic controller and evaluated its performance with an extensive set of experiments.}, keywords = {autonomic computing, distributed business process execution engines, service oriented architectures, Web service composition}, doi = {10.1016/j.infsof.2006.08.010}, author = {Cesare Pautasso and Thomas Heinis and Gustavo Alonso} } @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} } @book {wewst:2007, title = {Emerging Web Services Technology}, volume = {1}, year = {2007}, pages = {182}, publisher = {Birkh{\"a}user}, organization = {Birkh{\"a}user}, keywords = {Web services}, isbn = {978-3-7643-8448-7}, url = {http://www.springer.com/birkhauser/computer+science/book/978-3-7643-8447-0}, editor = {Cesare Pautasso and Christoph Bussler} } @conference {jophealthgrid07, title = {Grid-based Analysis of Tandem Mass Spectrometry Data in Clinical Proteomics}, booktitle = {Health Grid 2007}, year = {2007}, address = {Geneva, Switzerland}, abstract = {Biomarker detection is one of the greatest challenges in Clinical Proteomics. Today, great hopes are placed into tandem mass spectrometry (MS/MS) to discover potential biomarkers. MS/MS is a technique that allows large scale data analysis, including the identification, characterization, and quantification of molecules. Especially the identification process, that implies to compare experimental spectra with theoretical amino acid sequences stored in specialized databases, has been subject for extensive research in bioinformatics since many years. Dozens of identification programs have been developed addressing different aspects of the identification process but in general, clinicians are only using a single tools for their data analysis along with a single set of specific parameters. Hence, a significant proportion of the experimental spectra do not lead to a confident identification score due to inappropriate parameters or scoring schemes of the applied analysis software. The swissPIT (Swiss Protein Identification Toolbox) project was initiated to provide the scientific community with an expandable multi-tool platform for automated and in-depth analysis of mass spectrometry data. The swissPIT uses multiple identification tools to automatic analyze mass spectra. The tools are concatenated as analysis workflows. In order to realize these calculation-intensive workflows we are using the Swiss Bio Grid infrastructure. A first version of the web-based front-end is available (http://www.swisspit.cscs.ch) and can be freely accessed after requesting an account. The source code of the project will be also made available in near future.}, keywords = {grid computing, JOpera, scientific workflow management}, url = {http://www.ncbi.nlm.nih.gov/pubmed/17476043}, author = {Andreas Quandt and Patricia Hernandez and Peter Kunzst and Cesare Pautasso and Marc Tuloup and Ron D. Appel} } @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} } @inbook {116, title = {Autonomic Computing for Virtual Laboratories}, booktitle = {Dependable Systems: Software, Computing, Networks}, number = {4028}, year = {2006}, pages = {211-230}, publisher = {Springer}, organization = {Springer}, abstract = {Virtual laboratories can be characterized by their long-lasting, large-scale computations, where a collection of heterogeneous tools is integrated into data processing pipelines. Such virtual experiments are typically modeled as scientific workflows in order to guarantee their reproduceability. In this chapter we present JOpera, one of the first autonomic infrastructures for managing virtual laboratories. JOpera provides a sophisticated Eclipse-based graphical environment to design, monitor and debug distributed computations at a high level of abstraction. The chapter describes the architecture of the workflow execution environment, emphasizing its support for the integration of heterogeneous tools and evaluating its autonomic capabilities, both in terms of reliable execution (self-healing) and automatic performance optimization (self-tuning).}, keywords = {autonomic computing, JOpera, scientific workflow management}, isbn = {3-540-36821-3}, doi = {10.1007/11808107_10}, author = {Cesare Pautasso and Win Bausch and Gustavo Alonso}, editor = {J{\"u}rg Kohlas and Bertrand Meyer and Andr{\'e} Schiper} } @conference {jopera:2006:scc, title = {Control the Flow: How to Safely Compose Streaming Services into Business Processes}, booktitle = {2006 IEEE International Conference on Services Computing}, year = {2006}, pages = {206 - 213}, publisher = {IEEE}, organization = {IEEE}, address = {Chicago, USA}, abstract = {Although workflow languages are widely used for composing discrete services, these are not suitable for stream based interactions. In this paper we address the problem of how to extend a conventional Web service composition language with the ability to deal with data streaming services. The paper discusses several modeling alternatives and presents a marker based semantics for safely dealing with pipelined processing in service compositions. The paper also presents application examples that illustrate the advantages of the proposed approach}, keywords = {JOpera, streaming, Web service composition}, doi = {10.1109/SCC.2006.38}, author = {Bi{\"o}rn Bi{\"o}rnstad and Cesare Pautasso and Gustavo Alonso} } @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} } @article {115, title = {Enforcing Web Services Business Protocols at Run-Time: a Process Driven Approach}, journal = {International Journal of Web Engineering and Technology (IJWET)}, volume = {2}, year = {2006}, pages = {396-411}, abstract = {Business processes provide abstractions for modelling business protocols that define the correct interactions between two or more Web services (WS). It has been shown that it is possible to automatically derive role-specific processes from a global protocol definition and also statically verify the compliance of a local process with the corresponding global business process. In this paper, we show that a similar approach can be used at run-time. We propose to employ process-based tools to enforce that the messages exchanged between different WS comply with a given business protocol, both in terms of sequencing constraints and data flow characteristics. Our solution simplifies the implementation of WS because it helps to separate the concern of business protocol compliance from the actual service implementation. To do so, we show how to transparently add a protocol enforcement layer to the WS messaging stack. Our experimental results indicate that this imposes a minimal overhead.}, keywords = {business process modeling, business protocols, choreography, conversation controller, data flow, JOpera, Web services}, issn = {1476-1289}, doi = {10.1504/IJWET.2006.010422}, url = {http://www.inderscience.com/info/inarticle.php?artid=10422}, author = {Bi{\"o}rn Bi{\"o}rnstad and Cesare Pautasso and Gustavo Alonso} } @article {117, title = {JOpera: Autonomic Service Orchestration}, journal = {IEEE Data Engineering Bulletin}, volume = {29}, year = {2006}, month = {September}, pages = {32-39}, keywords = {autonomic computing, JOpera, Web service composition}, url = {ftp://ftp.research.microsoft.com/pub/debull/A06sept/issue1.htm}, author = {Cesare Pautasso and Thomas Heinis and Gustavo Alonso} } @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} } @inproceedings {jopera:2006:works, title = {Parallel Computing Patterns for Grid Workflows}, year = {2006}, month = {June}, address = {Paris, France}, abstract = {Whereas a consensus has been reached on defining the set of workflow patterns for business process modeling languages, no such patterns exists for workflows applied to scientific computing on the Grid. By looking at different kinds of parallelism, in this paper we identify a set of workflow patterns related to parallel and pipelined execution. The paper presents how these patterns can be represented in different Grid workflow languages and discusses their implications for the design of the underlying workflow management and execution infrastructure. A preliminary classification of these patterns is introduced by surveying how they are supported by several existing advanced scientific and Grid workflow languages.}, keywords = {grid computing, scientific workflow management, survey, workflow patterns}, author = {Cesare Pautasso and Gustavo Alonso} } @inbook {jopera:2006:acbook, title = {A Self-Configuring Service Composition Engine}, booktitle = {Autonomic Computing: Concepts, Infrastructure, and Applications}, year = {2006}, pages = {237-252}, publisher = {CRC Press}, organization = {CRC Press}, chapter = {12}, keywords = {autonomic computing}, isbn = {0-8493-9367-1}, doi = {10.1201/9781420009354.ch12}, author = {Thomas Heinis and Cesare Pautasso and Gustavo Alonso}, editor = {Manish Parashar and Salim Hariri} } @conference {jopera:2005:icws, title = {Autonomic Execution of Service Compositions}, booktitle = {3rd International Conference on Web Services (ICWS 2005)}, year = {2005}, month = {July}, publisher = {IEEE}, organization = {IEEE}, address = {Orlando, Florida}, abstract = {An increasing amount of Web services are being implemented using process management tools and languages (BPML, BPEL, etc.). The main advantage of processes is that designers can express complex business conversations at a high level of abstraction, even reusing standardized business protocols. The downside is that the infrastructure behind the Web service becomes more complex. This is particularly critical for Web services that may be subjected to high variability in demand and suffer from unpredictable peaks of heavy load. In this paper we present a flexible architecture for process execution that has been designed to support autonomic scalability. The system runs on a cluster of computers and reacts to workload variations by altering its configuration in order to optimally use the available resources. Such changes happen automatically and without any human intervention. This feature completely removes the need for the manual monitoring and reconfiguration of the system, which in practice is a difficult and time-consuming operation. In the paper we describe the architecture of the system and present an extensive performance evaluation of its autonomic capabilities.}, keywords = {autonomic computing, JOpera, Web service composition}, doi = {10.1109/ICWS.2005.28}, author = {Cesare Pautasso and Thomas Heinis and Gustavo Alonso} } @conference {jopera:2005:icac, title = {Design and Evaluation of an Autonomic Workflow Engine}, booktitle = {2nd International Conference on Autonomic Computing (ICAC-05)}, year = {2005}, month = {June}, pages = {27 - 38}, publisher = {IEEE}, organization = {IEEE}, address = {Seattle, Washington}, abstract = {In this paper we present the design and evaluate the performance of an autonomic workflow execution engine. Although there exist many distributed workflow engines, in practice, it remains a difficult problem to deploy such systems in an optimal configuration. Furthermore, when facing an unpredictable workload with high variability, manual reconfiguration is not an option. Thanks to its autonomic controller, the engine features self-configuration, self-tuning and self-healing properties. The engine runs on a cluster of computers using a tuple space to coordinate its various components. Its autonomic controller monitors its performance and responds to workload variations by altering the configuration. In case failures occur, the controller can recover the workflow execution state from persistent storage and migrate it to a different node of the cluster. Such interventions are carried out without any human supervision. As part of the results of our performance evaluation, we compare different autonomic control strategies and discuss how they can automatically tune the system}, keywords = {automatic configuration, autonomic computing, JOpera, Web service composition}, doi = {10.1109/ICAC.2005.21}, author = {Thomas Heinis and Cesare Pautasso and Gustavo Alonso} } @inproceedings {jopera:2005:sc, title = {Flexible Binding for Reusable Composition of Web Services}, year = {2005}, month = {April}, pages = {151-166}, publisher = {Springer}, address = {Edinburg, Scotland}, abstract = {In addition to publishing composite services as reusable services, compositions can also be reused by applying them to orchestrate different component services. To do so, it is important to describe compositions using flexible bindings, which define only the minimal constraints on the syntax and semantics of the services to be composed. This way, the choice of which service to invoke can be delayed to later stages in the life cycle of the composition. In the context of Web service composition, we refine the concept of binding beyond the basic distinction of static and dynamic binding. Bindings can be evaluated during the design, the compilation, the deployment, the beginning of the execution of a composition, or just before the actual service invocation takes place. Considering the current limited support of dynamic binding in the BPEL service composition language, we show how we addressed the problem in JOpera, where modeling bindings does not require a specific language construct as it can be considered a special application of reflection.}, keywords = {dynamic binding, JOpera, Web service composition}, doi = {10.1007/11550679_12}, author = {Cesare Pautasso and Gustavo Alonso} } @conference {jopera:2005:vlhcc, title = {JOpera: an Agile Environment for Web Service Composition with Visual Unit Testing and Refactoring}, booktitle = {2005 IEEE Symposium on Visual Languages and Human Centric Computing (VL/HCC{\textquoteright}05)}, year = {2005}, month = {September}, pages = {311 - 313}, publisher = {IEEE}, organization = {IEEE}, address = {Dallas, TX}, abstract = {Agile methodologies employ light-weight development practices emphasizing a test-driven approach to the development of software systems. Modern agile development environments support this approach by providing tools that automate most of the work required to effectively deal with change, including unit testing and different forms of refactoring. In this paper we discuss how to apply such techniques within the JOpera Visual Composition Language. More precisely, we show how we used the visual language to implement a regression testing framework for compositions written in the language itself and how we introduced support in the visual environment for refactorings such as renaming, synchronization of service interface changes, and extraction/inlining across different levels of nesting. This is done in the context of the Web service composition tools provided with the JOpera for Eclipse research platform.}, keywords = {agile, JOpera, refactoring, visual composition languages}, doi = {10.1109/VLHCC.2005.48}, author = {Cesare Pautasso} } @article {106, title = {The JOpera visual composition language}, journal = {J. Vis. Lang. Comput.}, volume = {16}, year = {2005}, month = {February}, pages = {119{\textendash}152}, abstract = {Composing Web services into a coherent application can be a tedious and error-prone task when using traditional textual scripting languages or emerging XML-based approaches. As an alternative, complex interactions patterns and data exchanges between different Web services can be effectively modeled using a visual language. In this paper, we discuss the requirements of such an application scenario and we fully describe the JOpera Visual Composition Language. An extensive set of visual editing tools, a compiler and a debugger for the language have been implemented as part of the JOpera system with the goal of providing a true visual environment for Web service composition with usability features emphasizing rapid development and visual scalability. }, keywords = {data flow, JOpera, visual composition languages, Web service composition, Web services}, issn = {1045-926X}, doi = {10.1016/j.jvlc.2004.08.004}, author = {Cesare Pautasso and Gustavo Alonso} } @conference {jopera:2005:escience, title = {Publishing Persistent Grid Computations as WS Resources}, booktitle = {1st IEEE International Conference on e-Science and Grid Computing (e-Science 2005)}, year = {2005}, month = {December}, publisher = {IEEE}, organization = {IEEE}, address = {Melbourne, Australia}, abstract = {Grid services can be composed into processes, providing a high level definition of the computations involved in terms of their data exchanges and control flow dependencies. We show how processes themselves can be efficiently published as Grid services by mapping the persistent state of the process executions to standard compliant interfaces as defined by the Web Services Resource Framework (WS-RF). Mapping processes to resources is a fundamental step to enable recursive Grid service composition, where composite Grid services are themselves published as services. This gives processes a standardized and wellunderstood interface that enables their management, monitoring, steering and adaptation. Additionally it eases their reusability and simplifies integration into existing Grid applications and portals. In order to determine the mapping{\textquoteright}s overhead, we include the results of a comprehensive performance evaluation.}, keywords = {grid computing, JOpera, scientific workflow management}, doi = {10.1109/E-SCIENCE.2005.67}, author = {Thomas Heinis and Cesare Pautasso and Oliver Deak and Gustavo Alonso} } @phdthesis {97, title = {A Flexible System for Visual Service Composition}, volume = {PhD}, year = {2004}, school = {ETH Zurich, Computer Science Department}, type = {PhD Thesis}, abstract = {This dissertation brings together ideas of different research areas. First of all, we propose the application of visual languages to service composition. In order to connect basic services of various kinds into a larger system, their interactions along the time dimension are defined with the JOpera Visual Composition Language. As opposed to the textual or XML-based syntax of existing approaches, our language features a very simple graphical notation. This visual syntax is used to specify the data flow and control flow graphs linking the various service invocations. This way, it becomes possible to rapidly build distributed applications out of a set of reusable services by literally drawing the interactions between them. To achieve this, we present how usability features such as automatic, incremental graph layout and visual scalability features such as multiple views have been driving the design of JOpera{\textquoteright}s visual service composition environment. To provide support for realistic application scenarios, we have also included recursion, iteration and reflection constructs with minimal changes to the syntax of the visual language. Supported by the JOpera system, our visual language for service composition has been applied to many scenarios, as documented by the examples shown throughout the dissertation. Underneath the visual syntax, our approach to modeling service composition is based on the concept of process. In this dissertation we borrow the notion of business process so that it can be extended to model service oriented architectures. Thus, the structure of a process defines the partial order of invocation of its services, the data exchanges between them and the necessary failure handling behavior. In this context, an important contribution of this dissertation is the idea that a composition language should be orthogonal with respect to the types of components that are employed. More precisely, in our approach, composition is defined at the level of service interfaces. Therefore, a process is completely independent from the mechanisms and protocols used to access the implementation of its services. In other words, we introduce a composition language which is not limited to describing how components of a specific type (e.g., Web services) should be composed. Instead, in our open component meta-model, we generalize the notion of service by abstracting common features among a large set of different component types. This abstraction has several important implications. By supporting a large and open set of types of services, the composition language is simplified because many constructs (e.g., modeling synchronous or asynchronous service invocation) can be shifted from the composition language to the component meta-model. Also, the service composer is free to choose the most appropriate mechanism to access the functionality of an existing service. Thus, the runtime overhead of a service invocation can be minimized as it becomes possible to choose the most effcient access mechanism. This optimization regarding the service access mechanism would not make much of a difference regarding the overall system{\textquoteright}s performance if the execution of the visual language would incur in a high overhead, as typically process-based languages are executed by an interpreter. On the contrary, in this dissertation we propose to compile the visual specification of a process into executable code. One of the challenges of doing so is that the resulting code should still support the concurrent execution of multiple process instances. The choice of applying compilation to the execution of processes brings the following benefits. In addition to the potential for providing better performance through the optimization of the generated code, compiling processes also helps to simplify the design of the corresponding runtime system. As opposed to having a full-blown process interpreter, it is enough to design and build a flexible container of compiled processes. Following this approach, in the last part of the dissertation we present the design of a flexible architecture for a process support system. Flexibility is an important aspect of our design which, according to our experimental results, does not contradict the goal of building an efficient system. First, flexibility enables JOpera to support heterogeneous types of services. To do so, plug-ins are used to map the invocation of a service to the corresponding protocol in the most effcient manner. Second, the flexible architecture of JOpera{\textquoteright}s kernel can be deployed in a variety of configurations. This way, costly features such as reliable process execution can be added only if they are truly needed. Likewise, the system shows good scalability when deployed in a cluster-based configuration, as large workloads are shared among multiple cluster nodes. Thanks to a wise choice of architectural abstractions, the code generated by the compiler is kept independent of the actual configuration of the kernel into which it is loaded. Third, flexibility is also a fundamental property for an autonomic system, where the optimal configuration is determined automatically at runtime.}, keywords = {JOpera, visual service composition, Web service composition}, doi = {10.3929/ethz-a-004860667}, url = {https://www.research-collection.ethz.ch/handle/20.500.11850/72796}, author = {Cesare Pautasso} } @inproceedings {95, title = {From Web Service Composition to Megaprogramming}, volume = {3324}, year = {2004}, month = {August}, pages = {39 - 53}, publisher = {Springer}, address = {Toronto, Canada}, abstract = {With the emergence of Web service technologies, it has become possible to use high level megaprogramming models and visual tools to easily build distributed systems using Web services as reusable components. However, when attempting to apply the Web service composition paradigm in practical settings, some limitations become apparent. First of all, all kinds of existing {\textquotedblleft}legacy{\textquotedblright} components must be wrapped as Web services, incurring in additional development, maintenance, and unnecessary runtime overheads. Second, current implementations of Web service protocols guarantee interoperability at high runtime costs, which justifies the composition of only coarse-grained Web services. To address these limitations and support the composition of also fine-grained services, in this paper we generalize the notion of service by introducing an open service meta-model. This offers freedom of choice between different types of services, which also include, but are not limited to, Web services. As a consequence, we argue that service composition {\textendash} defined at the level of service interfaces {\textendash} should be orthogonal from the mechanisms and the protocols which are used to access the actual service implementations.}, keywords = {heterogeneity, JOpera, megaprogramming, Web services}, isbn = {978-3-540-25049-4}, doi = {10.1007/b10662610.1007/978-3-540-31811-8_4}, author = {Cesare Pautasso and Gustavo Alonso} } @article {96, title = {JOpera: a Toolkit for Efficient Visual Composition of Web Services}, journal = {International Journal of Electronic Commerce (IJEC)}, volume = {9}, year = {2004}, month = {Winter 2004/2005}, pages = {107-141}, abstract = {Web services are attracting attention because of their ability to provide standard interfaces to heterogeneous distributed services. Standard interfaces make it possible to compose more complex services out of basic ones. This paper tackles the problem of visual service composition and the efficient and scalable execution of the resulting composite services. The effort revolves around the JOpera system, which combines a visual programming environment for Web services with a flexible execution engine that interacts with Web services through the simple object access protocol (SOAP), described with Web services language description (WSDL) and registered with a universal description discovery and integration (UDDI) registry. The paper explains the syntax and implementation of the JOpera Visual Composition Language (JVCL) and its ability to provide different quality of service (QoS) levels in the execution of composite services. }, keywords = {JOpera, Scalable Process Execution, visual languages, Web service composition}, issn = {1086-4415 }, url = {http://www.ijec-web.org/past-issues/volume-9-number-2-winter-2004-05/ijecv9n2-6/}, author = {Cesare Pautasso and Gustavo Alonso} } @article {98, title = {JOpera: Visual Composition of Grid Services}, year = {2004}, month = {October}, pages = {46-47}, abstract = {The recent shift to service-based Grids enables the use of service composition tools for rapidly building and efficiently running distributed computations. At ETH Zurich, we have developed JOpera, a visual composition language and a set of integrated software development tools for composing Grid services. The system can be freely downloaded and has been successfully tested with data-intensive bioinformatics applications as well as large-scale, Monte-Carlo network simulations.}, keywords = {grid computing, JOpera, scientific workflow management}, url = {http://www.ercim.eu/publication/Ercim_News/enw59/pautasso.html}, author = {Cesare Pautasso} } @conference {93, title = {Programming for dependability in a service-based grid}, booktitle = {3rd IEEE/ACM International Symposium on Cluster Computing and the Grid, 2003 (CCGrid 2003)}, year = {2003}, month = {May}, pages = {164 - 171}, publisher = {IEEE}, organization = {IEEE}, address = {Tokyo, Japan}, abstract = {Service-based Grid infrastructures emphasize service composition rather than sharing of low level resources. The idea is to build Grid applications out of computational services provided by the different sites of the Grid. Recent developments in the area of Web services have strengthened this idea by standardizing procedures like service description, publication and invocation. What is still missing is the infrastructure necessary to support the complete life cycle of applications running on service based Grids, i.e., suitable programming paradigms, execution infrastructure, and the ability to monitor and control such computations. Moreover, once computations are made of composable services, dependability becomes a key issue that needs to be addressed by the infrastructure as it cannot be addressed separately by each individual service. To address these concerns, we have developed the BioOpera Grid computing platform. BioOpera is a process support system for dependable cluster computing that has been extended with additional functionality to provide adequate support for service-based Grids. In this paper we describe how BioOpera can be used to develop, execute, and administer highly dependable computations over service-based Grids.}, keywords = {BioOpera, distributed business process execution engines, grid computing, Web services}, isbn = {0-7695-1919-9}, doi = {10.1109/CCGRID.2003.1199365}, url = {http://ieeexplore.ieee.org/lpdocs/epic03/wrapper.htm?arnumber=1199365}, author = {Win Bausch and Cesare Pautasso and Gustavo Alonso} } @conference {94, title = {Visual composition of Web services}, booktitle = {IEEE Symposium on Human Centric Computing Languages and Environments (HCC 2003)}, year = {2003}, month = {October}, pages = {92 - 99}, publisher = {IEEE}, organization = {IEEE}, address = {Auckland, New Zealand}, abstract = {Composing Web services into a coherent application can be a tedious and error prone task when using traditional textual scripting languages. As an alternative, complex interactions patterns and data exchanges between different Web services can be effectively modeled using a visual language. In this paper we discuss the requirements of such an application scenario and we present the design of the BioOpera Flow Language. This visual composition language has been fully implemented in a development environment for Web service composition with usability features emphasizing rapid development and visual scalability.}, keywords = {JOpera, visual languages, visual service composition, Web service composition, Web services}, doi = {10.1109/HCC.2003.1260208}, url = {http://ieeexplore.ieee.org/lpdocs/epic03/wrapper.htm?arnumber=1260208}, author = {Cesare Pautasso and Gustavo Alonso} } @conference {92, title = {BioOpera: cluster-aware computing}, booktitle = {IEEE International Conference on Cluster Computing (CLUSTER 2002)}, year = {2002}, month = {September}, pages = {99 - 106}, publisher = {IEEE}, organization = {IEEE}, address = {Chicago, IL, USA}, abstract = {In this paper we present BioOpera, an extensible process support system for cluster-aware computing. It features an intuitive way to specify computations, as well as improved support for running them over a cluster providing monitoring, persistence, fault tolerance and interaction capabilities without sacrificing efficiency and scalability.}, keywords = {BioOpera, cluster computing, scientific workflow management}, doi = {10.1109/CLUSTR.2002.1137734}, url = {http://ieeexplore.ieee.org/lpdocs/epic03/wrapper.htm?arnumber=1137734}, author = {Win Bausch and Cesare Pautasso and Reto Schaeppi and Gustavo Alonso} } @conference {91, title = {Dependable computing in virtual laboratories}, booktitle = {17th IEEE International Conference on Data Engineering (ICDE 2001)}, year = {2001}, month = {April}, pages = {235 - 242}, publisher = {IEEE}, organization = {IEEE}, address = {Heidelberg, Germany}, abstract = {Many scientific disciplines are shifting from in vitro to in silico research as more physical processes and natural phenomena are examined in a computer (in silico) instead of being observed (in vitro). In many of these virtual laboratories, the computations involved are very complex and long lived. Currently, users are required to manually handle almost all aspects of such computations, including their dependability. Not surprisingly, this is a major bottleneck and a significant source of inefficiencies. To address this issue, we have developed BioOpera, an extensible process support management system for virtual laboratories. The authors briefly discuss the architecture and functionality of BioOpera and show how it can be used to efficiently manage long lived computations}, keywords = {bioinformatics, BioOpera, scientific workflow management, virtual laboratories}, doi = {10.1109/ICDE.2001.914834}, url = {http://ieeexplore.ieee.org/lpdocs/epic03/wrapper.htm?arnumber=914834}, author = {Gustavo Alonso and Win Bausch and Cesare Pautasso and Ari Kahn} }