@conference {2024:plop,
	title = {Dark Patterns for Unethical Software Engineering},
	booktitle = {31st International Conference on Pattern Languages of Programs, People \& Practices (PLoP)},
	year = {2024},
	month = {October},
	publisher = {ACM},
	organization = {ACM},
	address = {Portland, OR},
	abstract = {Unethical software engineers write software to satisfy harmful requirements. While patterns promote beneficial solutions to recurring problems, dark patterns intentionally introduce harmful solutions. In this paper we present a collection of 16 dark patterns widely used by unethical software engineers to violate users privacy (email pixel injector, stealthy input logger), pursue monetization at all costs (aggressive advertiser, ad-blocker detector, pay to win, artificial scarcity hoarder, DRM rug puller, obsolescence planner), commit digital frauds (cybersquatter, sneaky terms degrader, interoperability breaker), manipulate search rankings (fake review generator, search ranking kickbacker), and engage in unethical artificial intelligence practices (training data harvester, bot pretender, deceptive deepfaker). By discussing the ethical consequences of each pattern we aim to raise awareness about them and encourage their avoidance by ethical software engineers, architects and practitioners.},
	keywords = {Ethics; Dark Patterns},
	doi = {10.64346/PLoP2024p20},
	author = {Cesare Pautasso}
}
@proceedings {2024:asianplop,
	title = {Decentralized Task Execution Patterns},
	year = {2024},
	month = {March},
	address = {Fujisawa City, Kanagawa Prefecture, Japan},
	abstract = {Decentralized task execution requires to assign planning, execution and control roles and responsibilities to at least two distinct parties. These include making decisions about {\textquoteleft}{\textquoteleft}who does what when{\textquoteright}{\textquoteright} so that one party can track the progress and the outcome of tasks executed by another party. In this paper we outline the design space for decentralized task execution by presenting 18 different patterns, going from imperative task execution all the way to autonomous task execution. We will distinguish how decisions about who performs a task, what needs to be done and when to do it can be made by different parties and how these alternative decision-making locations impact the interactions between the parties responsible to plan, execute and control the task execution. The patterns are applicable within human organizations with many actors delegating or performing multiple tasks but also to fully automated systems, e.g., distributed operating systems, intelligent autonomous vehicles, blockchain-based workflow engines or high throughput job schedulers.},
	keywords = {patterns, Workflow Management Systems, workflow patterns},
	author = {Cesare Pautasso}
}
@conference {2018:icwe:liquid,
	title = {Decentralized Computation Offloading on the Edge with Liquid WebWorkers},
	booktitle = {18th International Conference On Web Engineering  (ICWE 2018)},
	year = {2018},
	month = {June},
	publisher = {Springer},
	organization = {Springer},
	address = {C{\'a}ceres, Spain},
	abstract = {Liquid Web applications seamlessly flow across any kind of device ranging from powerful desktop and laptop devices to smaller devices, such as tablets, smart phones or any device capable of running a Web browser. In this context, there is the opportunity to reduce the execution time of CPU-intensive tasks or limit their energy consumption by offloading them across the set of machines running the liquid Web application. To do so, in this paper we present Liquid WebWorkers, which build upon the standard HTML5 WebWorker API and transparently offload the task execution to other devices and manage the corresponding data transfer. This way, Web developers can reuse their existing WebWorker scripts without any changes. We present how to create a pool of paired devices and compare different policies for choosing the target device that have been implemented in the Liquid.js framework.},
	keywords = {liquid software, offloading},
	author = {Andrea Gallidabino and Cesare Pautasso}
}
@conference {2018:icpe,
	title = {A Declarative Approach for Performance Tests Execution in Continuous Software Development Environments},
	booktitle = {9th ACM/SPEC International Conference on Performance Engineering (ICPE 2018)},
	year = {2018},
	month = {April},
	publisher = {ACM},
	organization = {ACM},
	address = {Berlin, Germany},
	abstract = {Software performance testing is an important activity to ensure quality in continuous software development environments. Current performance testing approaches are mostly based on scripting languages and frameworks where users implement, in a procedural way, the performance tests they want to issue to the system under test. However, existing solutions lack support for explicitly declaring the performance test goals and intents. Thus, while it is possible to express how to execute a performance test, its purpose and applicability context remain implicitly described. In this work, we propose a declarative domain specific language (DSL) for software performance testing and a model-driven framework that can be programmed using the mentioned language and drive the end-to-end process of executing performance tests. Users of the DSL and the framework can specify their performance intents by relying on a powerful goal-oriented language, where standard (e.g., load tests) and more advanced (e.g., stability boundary detection, and configuration tests) performance tests can be specified starting from templates. The DSL and the framework have been designed to be integrated into a continuous software development process and validated through extensive use cases that illustrate the expressiveness of the goal-oriented language, and the powerful control it enables on the end-to-end performance test execution to determine how to reach the declared intent.},
	keywords = {BenchFlow, DevOps, Domain Specific Language},
	doi = {10.1145/3184407.3184417},
	author = {Vincenzo Ferme and Cesare Pautasso}
}
@article {swinsight:2016:janfeb,
	title = {A Decade of  Enterprise  Integration Patterns: A Conversation with the Authors},
	journal = {IEEE Software},
	volume = {1},
	year = {2016},
	month = {January-February},
	pages = {13-19},
	abstract = {Department editors Olaf Zimmerman and Cesare Pautasso interview Gregor Hohpe and Bobby Woolf, authors of Enterprise Integration Patterns. They discuss the book{\textquoteright}s impact, pattern language design, message-oriented middleware, integration technology{\textquoteright}s evolution, and the authors{\textquoteright} future plans. },
	keywords = {Enterprise Integration Patterns},
	doi = {http://doi.ieeecomputersociety.org/10.1109/MS.2016.11},
	url = {http://ieeexplore.ieee.org/stamp/stamp.jsp?tp=\&arnumber=7368007},
	author = {Olaf Zimmermann and Cesare Pautasso and Gregor Hohpe and Bobby Woolf}
}
@conference {liquidjs:2016:cbse,
	title = {Deploying Stateful Web Components on Multiple Devices with Liquid.js for Polymer},
	booktitle = {19th International ACM Sigsoft Symposium on Component-Based Software Engineering (CBSE 2016)},
	year = {2016},
	month = {April},
	pages = {85-90},
	address = {Venice, Italy},
	abstract = {Nowadays, the average users owns two or more Web-enabled devices (smart phones, personal computers and tablets), while more are coming: watches, cars, glasses. While responsive Web applications can adapt to the specific device (e.g., screen size or input method) on which they are deployed, they only provide limited support when one user connects from more than one device at the same time. In this paper we present Liquid.js for Polymer, a framework whose goal is to support developers that need to build liquid Web applications taking full advantage of multiple heterogeneous devices. It extends emerging Web components standards to enable the liquid user experience, whereby any device can be used sequentially or concurrently with applications that can roam from one device to another with no effort required by users controlling them. This way, users do not need to stop and resume their work on their Web application as they switch devices. Developers using Liquid.js do not need to worry about the underlying connectivity, pairing and synchronization issues of their stateful Web components. 
},
	keywords = {liquid software},
	author = {Andrea Gallidabino and Cesare Pautasso}
}
@conference {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}
}
@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}
}
@conference {jopera:2005:icac,
	title = {Design and Evaluation of an Autonomic Workflow Engine},
	booktitle = {2nd International Conference on Autonomic Computing (ICAC-05)},
	year = {2005},
	month = {June},
	pages = {27 - 38},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Seattle, Washington},
	abstract = {In this paper we present the design and evaluate the performance of an autonomic workflow execution engine. Although there exist many distributed workflow engines, in practice, it remains a difficult problem to deploy such systems in an optimal configuration. Furthermore, when facing an unpredictable workload with high variability, manual reconfiguration is not an option. Thanks to its autonomic controller, the engine features self-configuration, self-tuning and self-healing properties. The engine runs on a cluster of computers using a tuple space to coordinate its various components. Its autonomic controller monitors its performance and responds to workload variations by altering the configuration. In case failures occur, the controller can recover the workflow execution state from persistent storage and migrate it to a different node of the cluster. Such interventions are carried out without any human supervision. As part of the results of our performance evaluation, we compare different autonomic control strategies and discuss how they can automatically tune the system},
	keywords = {automatic configuration, autonomic computing, JOpera, Web service composition},
	doi = {10.1109/ICAC.2005.21},
	author = {Thomas Heinis and Cesare Pautasso and Gustavo Alonso}
}
@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}
}
