@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} } @article {2024:ieeesw:insight, title = {Continuous Integration and Delivery in Open Source Development and Pattern Publishing: Lessons Learned With Tool Setup and Pipeline Evolution}, journal = {IEEE Software}, volume = {41}, year = {2024}, month = {Jan-01-2024}, pages = {9 - 18}, abstract = {Every software project that aims to deliver high quality output needs a continuous integration setup. However, once the build pipeline is working, one cannot rest and take things for granted. Over long periods of time, tools come and go, and even if they remain the same, vendors often tinker with their pricing model. Lacking standardized and portable build configurations, it is critical to minimize the coupling between what needs to be built, how and where it gets built.}, keywords = {continuous integration}, issn = {0740-7459}, doi = {10.1109/MS.2023.3322312}, url = {https://ieeexplore.ieee.org/document/10372466}, author = {Zimmermann, Olaf and Pautasso, Cesare and Kapferer, Stefan and Stocker, Mirko} } @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} } @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} } @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} } @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} } @conference {2021:europlop:api-fragments, title = {From OpenAPI Fragments to API Pattern Primitives and Design Smells}, booktitle = {European Conference on Pattern Languages of Programs (EuroPLoP{\textquoteright}21)}, year = {2021}, month = {July}, publisher = {ACM}, organization = {ACM}, address = {Virtual Kloster Irsee, Germany}, abstract = {In the past few years, the OpenAPI Specification (OAS) has emerged as a standard description language for accurately modeling Web APIs. Today, thousands of OpenAPI descriptions can be found by mining open source repositories. In this paper, we attempt to exploit these artifacts to extract commonly occurring building blocks used in Web API structures, in order to assist Web API designers in their modelling task. Our work is based on a fragmentation mechanism, that starts from OpenAPI descriptions of Web APIs to extract their structures, then fragment these structures into smaller blocks. This approach enabled us to extract a large dataset of reoccurring fragments from a collection of 6619 API specifications. Such fragments have been found multiple times in the same or across different APIs. We have classified the most reoccurring fragments into four pattern primitives used to expose in the API access to collections of items. We distinguish for each primitive variants from design smells. This classification is based on the specific combinations of operations associated with the collection items and on an in-depth analysis of their natural language labels and descriptions. The resulting pattern primitives are intended to support designers who would like to introduce one or more collections for a specific class of items in their HTTP-based API.}, keywords = {API, API fragments, design smells, OpenAPI, patterns}, doi = {10.1145/3489449.3489998}, url = {https://zenodo.org/record/5727094$\#$.YZ97mFMo-0o}, author = {Souhaila Serbout and Cesare Pautasso and Uwe Zdun and Olaf Zimmermann} } @conference {2021:icwe:fullstack, title = {Full Stack is Not What It Used to Be}, booktitle = {21st International Conference on Web Engineering (ICWE2021)}, year = {2021}, month = {May}, publisher = {Springer}, organization = {Springer}, address = {Biarritz, France}, abstract = {The traditional definition of full stack development refers to a skill set that is required for writing software both for the frontend and backend of a web application or site. In recent years, the scope of full stack development has expanded significantly, though. Today, a full stack software developer is assumed to master various additional areas especially related to cloud infrastructure and deployment, message brokers and data analytics technologies. In addition, the emergence of Internet of Things (IoT) and the rapidly spreading use of AI/ML technologies are introducing additional skill set requirements. In this paper, we discuss the expectations for a modern full stack developer based on our industry observations, and argue that these expectations have significant implications for software and web engineering education.}, keywords = {Cloud, Education, Internet of Things, IoT, Programmable World, software architecture, software engineering, Web engineering}, doi = {10.1007/978-3-030-74296-6_28}, author = {Antero Taivalsaari and Tommi Mikkonen and Cesare Pautasso and Kari Systa} } @conference {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 {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 {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} } @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: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} } @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: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} } @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} } @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} } @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 {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} } @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 {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} } @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} } @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} } @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} } @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 {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} } @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} } @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 {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} } @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} } @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} } @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} } @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} } @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 {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} }