@article {2026:jiot,
	title = {BPSmart-CARE: a framework for managing contextualized actions in IoT systems through the integration of business process modelling and complex event processing},
	journal = {Internet of Things},
	volume = {36},
	year = {2026},
	month = {March},
	chapter = {101887},
	abstract = {The exponential growth of Internet of Things (IoT) sensors and data has led to multiple software applications which aim at collecting, monitoring, controlling, and automating decisions based on such data in several domains such as smart cities. Even though early IoT frameworks and software architectures relied on correlating data from a single application domain, missing opportunities to improve contextualisation; in the last years several Complex Event Processing (CEP)-based frameworks and applications have been provided to improve the correlation of data from heterogenous domains, facilitating context-aware decision making. However, several issues remain unsolved: on the one hand, frameworks should not only provide the means for data correlation and contextualisation, but also for the definition of customisable real-time actions based on the context. On the other hand, CEP patterns update remains static in these frameworks, while there is a need for dynamically updating CEP pattern logic to adapt to changing contexts in real time. Even more, CEP patterns logic understanding might also be a handicap for developers. To face these challenges, in this paper, we enhance an existent CEP-based framework and software architecture by incorporating Business Process Modelling (BPM) to facilitate the definition of CEP patterns rationale, manage interdependencies between patterns, define and handle contextualised user actions, and enable real-time updating of CEP pattern logic based on detected situations. The proposed approach is illustrated through a case study, assessed via usability and performance evaluations, which show improvements in comprehensibility, maintainability, and updatability of CEP-based software applications for context-aware IoT scenarios.},
	keywords = {BPMN, Complex Event Processing, Internet of Things},
	doi = {10.1016/j.iot.2026.101887},
	author = {Adrian Bazan-Mu{\~n}oz and Cesare Pautasso and Guadalupe Ortiz and Alfonso Garcia- de-Prado}
}
@conference {2025:europlop:academic,
	title = {Towards a Pattern Language for Academic Conferences},
	booktitle = {31st European Conference on Pattern Languages of Programs, People, and Practices (EuroPLoP)},
	year = {2025},
	month = {July},
	pages = {421{\textendash}433},
	publisher = {Springer},
	organization = {Springer},
	address = {Kloster Irsee, Germany},
	abstract = {This short paper reports on the focus group about academic conferences, organized at EuroPLoP 2025. It lists the methodology for running the focus group, discusses the results and suggests next steps towards the pattern language for academic conferences. The main findings suggest that the community and financial aspects are the most important for conference organizers, followed by the program.},
	keywords = {pattern language},
	doi = {10.1007/978-3-032-19157-1_20},
	author = {Aliaksandr Birukou and Cesare Pautasso and Michael Weiss}
}
@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}
}
@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}
}
@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}
}
@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 {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}
}
@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}
}
@phdthesis {2017:phd:lws,
	title = {Liquid stream processing on the web: a JavaScript framework},
	year = {2017},
	month = {November},
	school = {USI},
	type = {PhD},
	address = {Lugano, Switzerland},
	abstract = {The Web is rapidly becoming a mature platform to host distributed applications. Pervasive computing application running on the Web are now common in the era of the Web of Things, which has made it increasingly simple to integrate sensors and microcontrollers in our everyday life. Such devices are of great interest to Makers with basic Web development skills. With them, Makers are able to build small smart stream processing applications with sensors and actuators without spending a fortune and without knowing much about the technologies they use. Thanks to ongoing Web technology trends enabling real-time peer-to-peer communication between Web-enabled devices, Web browsers and server- side JavaScript runtimes, developers are able to implement pervasive Web applications using a single programming language. These can take advantage of direct and continuous communication channels going beyond what was possible in the early stages of the Web to push data in real-time. Despite these recent advances, building stream processing applications on the Web of Things remains a challenging task. On the one hand, Web-enabled devices of different nature still have to communicate with different protocols. On the other hand, dealing with a dynamic, heterogeneous, and volatile environment like the Web requires developers to face issues like disconnections, unpredictable workload fluctuations, and device overload. To help developers deal with such issues, in this dissertation we present the Web Liquid Streams (WLS) framework, a novel streaming framework for JavaScript. Developers implement streaming operators written in JavaScript and may interactively and dynamically define a streaming topology. The framework takes care of deploying the user-defined operators on the available devices and connecting them using the appropriate data channel, removing the burden of dealing with different deployment environments from the developers. Changes in the semantic of the application and in its execution environment may be applied at runtime without stopping the stream flow. Like a liquid adapts its shape to the one of its container, the Web Liquid Streams framework makes streaming topologies flow across multiple heterogeneous devices, enabling dynamic operator migration without disrupting the data flow. By constantly monitoring the execution of the topology with a hierarchical controller infrastructure, WLS takes care of parallelising the operator execution across multiple devices in case of bottlenecks and of recovering the execution of the streaming topology in case one or more devices disconnect, by restarting lost operators on other available devices.},
	keywords = {JavaScript, liquid software, stream processing},
	url = {https://doc.rero.ch/record/306887},
	author = {Masiar Babazadeh}
}
@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}
}
@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 {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}
}
@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}
}
@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}
}
@conference {lisa:2015:esocc,
	title = {Decentralized Stream Processing over Web-enabled devices},
	booktitle = {4th European Conference on Service-Oriented and Cloud Computing},
	volume = {9306},
	year = {2015},
	month = {September},
	pages = {3-18},
	publisher = {Springer},
	organization = {Springer},
	address = {Taormina, Italy},
	keywords = {liquid software, stream processing},
	doi = {10.1007/978-3-319-24072-5_1},
	author = {Masiar Babazadeh and Andrea Gallidabino and Cesare Pautasso}
}
@conference {lws:icwe:2015,
	title = {Liquid Stream Processing across Web browsers and Web servers},
	booktitle = {15th International Conference on Web Engineering (ICWE 2015)},
	year = {2015},
	month = {June},
	pages = {24-33},
	publisher = {Springer},
	organization = {Springer},
	address = {Rotterdam, NL},
	abstract = {The recently proposed API definition WebRTC introduced peer-to-peer real time communication between Web browsers, allowing streaming systems to be deployed on browsers in addition to traditional server-side execution environments. While streaming applications can be adapted to run on Web browsers, it remains difficult to deal with temporary disconnections, energy consumption on mobile devices and a potentially very large number of heterogeneous peers that join and leave the execution environment affecting the quality of the stream. In this paper we present the decentralized control approach followed by the Web Liquid Streams (WLS) framework, a novel framework for streaming applications running on Web browsers, Web servers and smart devices. Given the heterogeneity of the deployment environment and the volatility of Web browsers, we implemented a control infrastructure which is able to take operator migration decisions keeping into account the deployment constraints and the unpredictable workload.},
	keywords = {liquid software, stream processing, web liquid streams},
	doi = {10.1007/978-3-319-19890-3_3},
	author = {Masiar Babazadeh and Andrea Gallidabino and Cesare Pautasso}
}
@article {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}
}
@phdthesis {phd:2014:daniele.bonetta,
	title = {A Parallel Programming Model and Runtime System for Safe Event-based Parallel Programming},
	year = {2014},
	month = {September},
	pages = {179},
	school = {USI},
	type = {PhD},
	address = {Lugano, Switzerland},
	abstract = {Recent trends in programming models for server-side development have shown an increasing popularity of event-based single-threaded programming models based on the combination of dynamic languages such as JavaScript and event-based runtime systems for asynchronous I/O management such as Node.JS. Reasons for the success of such models are the simplicity of the single-threaded event-based programming model as well as the growing popularity of the Cloud as a deployment platform for Web applications. Unfortunately, the popularity of single-threaded models comes at the price of performance and scalability, as single-threaded event-based models present limitations when parallel processing is needed, and traditional approaches to concurrency such as threads and locks don{\textquoteright}t play well with event-based systems.

This Dissertation proposes a programming model and a runtime system to overcome such limitations by enabling single-threaded event-based applications with support for speculative parallel execution.
The model, called Parallel event loop, has the goal of bringing parallel execution to the domain of single-threaded event-based programming without relaxing the main characteristics of the single-threaded model, and therefore providing developers with the impression of a safe, single-threaded, runtime. Rather than supporting only pure single-threaded programming, however, the parallel event loop can also be used to derive safe, high-level, parallel programming models characterized by a strong compatibility with single-threaded runtimes. We describe three distinct implementations of speculative runtimes enabling the parallel execution of event-based applications. The first implementation we describe is a pessimistic runtime system based on locks to implement speculative parallelization. The second and the third implementations are based on two distinct optimistic runtimes using software transactional memory. Each of the implementations supports the parallelization of applications written using an asynchronous single-threaded programming style, and each of them enables applications to benefit from parallel execution.},
	keywords = {Parallel JavaScript},
	author = {Daniele Bonetta}
}
@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}
}
@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}
}
@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}
}
@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 {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}
}
@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}
}
@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}
}
@conference {6227125,
	title = {Specification patterns from research to industry: A case study in service-based applications},
	booktitle = {Proc. of the 34th International Conference on Software Engineering (ICSE2012), SeIP track},
	year = {2012},
	month = {June},
	pages = {968-976},
	address = {Zurich, Switzerland},
	abstract = {Specification patterns have proven to help developers to state precise system requirements, as well as formalize them by means of dedicated specification languages. Most of the past work has focused its applicability area to the specification of concurrent and real-time systems, and has been limited to a research setting. In this paper we present the results of our study on specification patterns for service-based applications (SBAs). The study focuses on industrial SBAs in the banking domain. We started by performing an extensive analysis of the usage of specification patterns in published research case studies - representing almost ten years of research in the area of specification, verification, and validation of SBAs. We then compared these patterns with a large body of specifications written by our industrial partner over a similar time period. The paper discusses the outcome of this comparison, indicating that some needs of the industry, especially in the area of requirements specification languages, are not fully met by current software engineering research.},
	keywords = {banking case study, formal specification, industry research, pattern matching, real-time systems, requirements specifications, service contracts, software engineering, specification patterns, Web services},
	issn = {0270-5257},
	doi = {10.1109/ICSE.2012.6227125},
	author = {Domenico Bianculli and Carlo Ghezzi and Cesare Pautasso and Patrick Senti}
}
@conference {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}
}
@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}
}
@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}
}
@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}
}
@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}
}
@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}
}
@inproceedings {clavos:2009:pesos,
	title = {Embedding continuous lifelong verification in service life cycles},
	year = {2009},
	month = {May},
	pages = {99-102},
	address = {Vancouver, Canada},
	abstract = {Service-oriented systems are an instantiation of open world software, which is characterized by high dynamism and decentralization. These properties strongly impact on how service-oriented systems are engineered, built, and operated, as well as verified. To address the challenges of applying verification to open service-oriented systems, in this position paper we propose to apply verification across the entire life cycle of a service and introduce a verification-oriented service life cycle.},
	keywords = {continuous lifelong verification, formal verification, monitoring, service contracts, service life cycles, service-oriented systems, software architecture, software engineering},
	doi = {10.1109/PESOS.2009.5068828},
	author = {Domenico Bianculli and Carlo Ghezzi and Cesare Pautasso}
}
@book {wewst: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}
}
@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}
}
@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 {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}
}
