The growing environmental impact of the ICT sector calls for sustainable computing, including software services designed to minimise their carbon footprint, without compromising on quality of service. In particular, software services should be carbon-aware by design - leveraging alternative configurations to reduce emissions while featuring the required quality of service. In this work, we present a carbon-aware approach to realise dynamically adaptive software services. We propose an optimisation scheme that enables serving incoming requests with different implemented versions of software services, by minimising carbon emissions, combining service adaptability and time-shifting. Finally, to demonstrate the feasibility of our proposal, we introduce CarbonShift, an open-source prototype implementation.

Context: Quantum computing is rapidly evolving, offering new opportunities for solving problems in optimization, cryptography, and simulation. However, the limited availability of quantum resources makes efficient utilization of quantum hardware a current challenge. Today’s paradigms often lead to under-utilization of qubits, increased costs, and execution delays, especially in the NISQ era. Objective: This work aims to improve the utilization of quantum hardware by introducing an execution model that integrates multiprogramming at circuit level with quantum shot-wise distribution in a single policy-driven pipeline. Methods: An architecture has been implemented that combines circuit scheduling and shot distribution techniques to aggregate multiple circuits and distribute their shots across heterogeneous QPUs. The approach was empirically validated on actual IBM Quantum devices using a diverse set of reference circuits. Results: The proposal achieved a reduction in cost of 95% and a reduction in tasks 92%. Moreover, the fidelity analysis of the results showed an increase in noise, with an average increase of approximately 20% using different statistical distances. Conclusions: This research provides a usable and extensible solution to increase the efficiency, cost effectiveness, and resilience of quantum workload execution in heterogeneous and dynamic cloud environments. These results obtained suggest that users should weigh the implications of fidelity versus cost (and time) savings based on the application requirements and their goals.

Cloud-Edge application deployment involves placing multiple software components on infrastructural topologies of heterogeneous nodes, ranging from Cloud servers to Internet-of-Things (IoT) edge devices. When multiple versions (or “ flavours ”) of a component are available, application managers must select a flavour for each deployed component, and assign these components to specific nodes, all while considering constraints such as dependencies, quality of service (QoS), budget, operational costs, and carbon emissions. In complex scenarios, finding the optimal deployment is often infeasible for human operators without automated tools to systematically explore the solution space. To address this challenge, we introduce FREEDA, a first constraint optimisation approach for deploying constrained and multi-flavoured applications on Cloud-Edge infrastructure topologies. We demonstrate the practical feasibility of FREEDA through experiments on a variety of realistic Cloud-Edge infrastructural topologies and component architectures. Furthermore, we benchmark FREEDA against Zephyrus, a comparable tool employing the same underlying solving technology. Empirical results show that FREEDA achieves strong scalability across a broad spectrum of realistic configurations and consistently outperforms Zephyrus.

Abstract Architecture recovery tools help software engineers obtain an overview of the structure of their software systems during all phases of the software development life cycle. This is especially important for microservice applications because they consist of multiple interacting microservices, which makes it more challenging to oversee the architecture. Various tools and techniques for architecture recovery (also called architecture reconstruction) have been presented in academic and gray literature sources, but no overview and comparison of their accuracy exists. This paper presents the results of a multivocal literature review with the goal of identifying architecture recovery tools for microservice applications and a comparison of the identified tools’ architectural recovery accuracy. We focused on static tools since they can be integrated into fast-paced CI/CD pipelines. 13 such tools were identified from the literature and nine of them could be executed and compared on their capability of detecting different system characteristics. The best-performing tool exhibited an overall F1-score of 0.86. Additionally, the possibility of combining multiple tools to increase the recovery correctness was investigated, yielding a combination of four individual tools that achieves an F1-score of 0.91.

ABSTRACT Context Identifying the possible root causes of observed failures is crucial in microservice applications, as much as explaining how such possible root failures propagated across the microservices forming an application. This can indeed help pick countermeasures avoiding observed failures to happen again, e.g., by introducing circuit breakers or bulkheads avoiding the root failures to propagate and cause those observed. Objective This paper aims at enabling to explain observed failures in microservice applications, either searching for all possible cascading failures or focusing only on those starting in a known root cause. Method We propose a log‐based root cause analysis technique, which declaratively determines the cascading failures that possibly caused an observed failure. We also enable exploiting our proposed technique in practice, by introducing a logging methodology to instrument applications to log their failures and service interactions, and by enabling to analyse such logs through yRCA, a prototype implementation of our proposed root cause analysis technique. Results The practical usability of our proposed technique is assessed by means of a case study and controlled experiments. The case study shows the low effort for instrumenting a third‐party application to produce the logs needed by our technique and its effectiveness in explaining injected failures. The controlled experiments further assess our technique's effectiveness and performances in explaining failures obtained with an existing chaos testbed. Conclusion Our proposed technique can help to identify the cascading failures that possibly caused an observed failure in a microservice application. It can be used to determine all possible cascading failures, or to explain how cascading failures propagated from a known root cause (e.g., identified with some other existing root cause analyser).

As quantum computers advance, the complexity of the software they can execute increases as well. To ensure this software is efficient, maintainable, reusable, and cost-effective—key qualities of any industry-grade software—mature software engineering practices must be applied throughout its design, development, and operation. However, the significant differences between classical and quantum software make it challenging to directly apply classical software engineering methods to quantum systems. This challenge has led to the emergence of Quantum Software Engineering (QSE) as a distinct field within the broader software engineering landscape. In this work, a group of active researchers analyze in depth the current state of QSE research. From this analysis, the key areas of QSE are identified and explored in order to determine the most relevant open challenges that should be addressed in the next years. These challenges help identify necessary breakthroughs and future research directions for advancing QSE.

Placing virtual machines so to minimize the number of used physical hosts is an utterly important problem in cloud computing and next-generation virtualized networks.This article proposes a declarative reasoning methodology, and its open-source prototype, including four heuristic strategies to tackle this problem.Our proposal is extensively assessed over real data from an industrial case study and compared to state-of-the-art approaches, both in terms of execution times and solution optimality.As a result, our declarative approach determines placements that are only 6% far from optimal, outperforming a state-of-the-art genetic algorithm in terms of execution times, and a first-fit search for optimality of found placements.Last, its pipelining with a mathematical programming solution improves execution times of the latter by one order of magnitude on average, compared to using a genetic algorithm as a primer.

Microservice Architecture (MSA) is a popular approach to designing, implementing, and deploying complex software systems. However, MSA introduces inherent challenges associated with distributed systems—one of them is the detection and mitigation of security smells. This paper draws on recent works that identified and categorized security smells in MSAs to propose a novel end-to-end approach for resolving security smells in existing MSAs. To this end, the presented approach extends a modeling ecosystem for MSAs with (i) reconstruction capabilities that automatically map MSA source code to viewpoint-specific architecture models; (ii) validations that detect security smells from reconstructed models; and (iii) model refactorings that support the interactive resolution of security smells and solutions’ reflection back to source code. Our approach allows for (i) uncovering security smells, which originate from the combination of different places in source code with possibly heterogeneous purposes, technologies, and software languages; as well as (ii) clustering, reifying, and fixing smells using a level of abstraction that is directed towards MSA stakeholders. The applicability and effectiveness of our approach are evaluated utilizing a standard case study from MSA research.

Securing microservice applications is crucial. Security smells denote symptoms of bad –often unintentional– design decisions, which may result in violating security properties, and that can be resolved via refactoring. Stakeholders take into account the services’ business value, problem criticality, and available resources to decide which smells to resolve or leave alone, but making such decisions is inherently complex for microservice applications with many services, possibly affected by multiple security smell instances. Borrowing from hospital emergency room triage practices, which assign an urgency code to incoming patients, this paper introduces the notion of urgency for microservice security smell instances, and proposes the TriSS method to triage them. TriSS enables assigning to each security smell instance with an urgency code based on combining the services’ business relevance and the smells’ impacts on security and other quality attributes, e.g., performance and maintainability. The practical applicability of TriSS is illustrated with a use case based on a third-party microservice application, and its usefulness is evaluated with a controlled experiment involving 26 practitioners. The experiment’s results suggest that TriSS eases the triage process and yields urgency codes on which practitioners are more confident.

The Network Function Virtualisation (NFV) paradigm has revolutionised the way networks are designed, deployed, operated and managed by leveraging the flexibility, scalability and cost efficiencies of the cloud. The emergence of the Cloud-Edge Continuum allows network services, or parts of them, to be delivered close to the end user, especially when latency and throughput requirements are stringent. However, this perspective also poses several resource orchestration challenges, such as the need to cope with rapid changes in the infrastructure status, network and computing resource shortage, and diverse service requirements. In a previous paper, we demonstrated through simulations that a more flexible matching of network service requests with available resources can be enabled by the concept of multi-flavoured network services, i.e. services whose specifications include a full-fledged version and possibly alternative, less demanding versions (with less stringent resource requirements and/or fewer offered features). Since the VNF chain placement problem is known to be NP-hard, we propose a genetic algorithm-based metaheuristic to efficiently solve this variant of the VNF chain placement problem. Simulation results suggest that our genetic algorithm can achieve a profit improvement over a greedy solution of up to 8% in a 28-node topology and up to 6.6% in a 50-node topology.

Abstract The problem of managing multi‐service applications on top of Cloud‐Edge networks in a quality of service (QoS)‐aware manner has been thoroughly studied in recent years from a decision‐making perspective. However, only a few studies addressed the problem of actively enforcing such decisions while orchestrating multi‐service applications and considering infrastructure and application variations. In this article, we propose a next‐gen orchestrator prototype based on Docker to achieve the continuous and QoS‐compliant management of multiservice applications on top of geographically distributed Cloud‐Edge resources, in continuity with CI/CD pipelines and infrastructure monitoring tools. Finally, we assess our proposal over a geographically distributed testbed across Italy.

The advent of the Internet of Things has increased the interest in automating mission-critical processes from domains such as smart cities. These applications’ stringent Quality of Service (QoS) requirements motivate their deployment through the Cloud-IoT Continuum, which requires solving the NP-hard problem of placing the application's services onto the infrastructure's devices. Moreover, as the infrastructure and application change over time, the placement needs to continuously adapt to these changes to maintain an acceptable QoS. While continuous reasoning techniques have enabled the creation of tools for these scenarios, they can have some trouble finding a feasible adaptation for abrupt and sharp changes, requiring non-adaptive techniques in those cases. Furthermore, for scenarios with smoother changes, it would be desirable to have faster algorithms to perform this placement. To explore the trade-off of effectiveness and execution times of different methods while ensuring that an application placement is found, we propose Multi-Layered Continuous Reasoning (MLCR) as an autonomic framework to adapt application placements through multiple continuous reasoning-based methods. We also present an MLCR prototype based on three methods: Faustum, MigDADO, and ConDADO. An evaluation in a realistic use case shows that MLCR is faster than traditional methods for application placement and maintains an acceptable QoS.

This article proposes an approach to the data-aware multi-service application placement problem in Cloud-Edge settings. We propose both declarative programming and a Mixed-Integer Linear Programming (MILP) approach to determine eligible placements that minimise operational costs and reduce the number of used nodes to contain the amount of data transfers. After assessing the performance of both approaches, we reconcile them into a methodology that combines the best of the two worlds by exploiting a declarative pre-processing step to boost the MILP solver while determining optimal solutions. We open-sourced the methodology into a prototype that is l0x faster than pure MILP, determines optimal results, and easily accommodates non-numerical constraints on application placements.

Microservices gained momentum in enterprise IT, as they enable building cloud-native applications. At the same time, they come with new security challenges, including security smells, viz., symptoms of bad (though often unintentional) design decisions that might affect application security. This study aims to explore the impacts of microservice security smells- and of the refactorings known to mitigate their effects-beyond security. In particular, we systematically elicit possible impacts of smells and refactorings on applications' maintainability, performance efficiency, and adherence to microservices' key design principles. We then validate the elicited impacts by means of an online survey targeting experienced practitioners and researchers. Our main contributions include 35 validated impacts, and a discussion of the survey results geared towards analyzing the (mis)alignment between practitioners and researchers.

Monitoring the proper functioning and performance of an infrastructure spanning multiple Cloud datacentres is challenging. It requires continuously aggregating monitored data across multiple source machines and processing them so to obtain useful alerts and insights. In this article, we propose a simple open-source prototype tool to perform highly customisable fault and performance monitoring across multiple Clouds. Differently from commercial tools, our prototype is simpler to deploy and it can be configured through a declarative approach, by simply specifying data monitoring tasks and aggregation policies. We illustrate such peculiarities over a use case relying on three datacentres under the Italian Research and Education Network Consortium.

Microservices are getting commonplace, as their design principles enable obtaining cloud-native applications. Ensuring that applications adheres to microservices’ design principles is hence crucial, and this includes resolving architectural smells possibly denoting violations of such principles. To this end, in this paper we propose a semi-automated methodology for resolving architectural smells in microservices applications deployed with Kubernetes. Our methodology indeed automatically detects architectural smells by analyzing the Kubernetes manifest files specifying an application’s deployment, and it can also generate the refactoring templates for resolving such smells. We also introduce KubeFreshener, an open-source prototype of our methodology, which we use to assess it in practice based on a controlled experiment and a case study.

This paper proposes a continuum-aware programming model enabling the execution of application workflows across the compute continuum: cloud, fog and edge resources. It simplifies the management of heterogeneous nodes while alleviating the burden of programmers and unleashing innovation. This model optimizes the continuum through advanced development experiences by transforming workflows into autonomous service collaborations. It reduces complexity in positioning/interconnecting services across the continuum. A meta-model introduces high-level workflow descriptions as service networks with defined contracts and quality of service, thus enabling the deployment/management of workflows as first-class entities. It also provides automation based on policies, monitoring and heuristics. Tailored mechanisms orchestrate/manage services across the continuum, optimizing performance, cost, data protection and sustainability while managing risks. This model facilitates incremental development with visibility of design impacts and seamless evolution of applications and infrastructures. In this work, we explore this new computing paradigm showing how it can trigger the development of a new generation of tools to support the compute continuum progress.

Intent-based Networking (IBN) aims at simplifying network configuration and management by using high-level objectives that express the desired state of the network rather than the details of how to implement it. In this article, we propose a declarative methodology and an associated open-source Prolog prototype (i) to model IBN intents related to the provisioning of Virtual Network Function (VNF) chains, and (ii) to process those intents to assemble and place a VNF chain that fulfils them. Our prototype is assessed over a lifelike motivating scenario.

Monitoring resource availability along Cloud-IoT networks in a lightweight and fault-resilient manner is a challenging research problem due to scarce resource availability, infrastructure dynamics, and platform heterogeneity. In this article, we illustrate a thorough experimental assessment of a self-organising and fault-tolerant monitoring service, FogMon, especially targeting Cloud-IoT settings and capable of probing hardware resource, latency and bandwidth. The assessment is carried out over networks made up of 20 to 40 nodes across two testbeds within the Fed4Fire+ federation. As a result of the assessment, we agilely improved and refined FogMon into FogMon 2, which settles at TRL5 and improves on monitoring accuracy and fault-resiliency. Experimental results show how FogMon 2 can promptly and suitably handle different types of infrastructure failure, with an average relative error of 10% on measurements and limited footprint on hardware and network resources.

Abstract The sustainable management of smart environments enabled by the Internet of Things (IoT) requires new methodologies and tools to suitably handle potentially many users and their objectives on cyber-physical systems, e.g. smart lighting, smart A/C. In this article, we propose a declarative framework to model IoT-enabled smart environments. Our methodology permits (i) expressing user roles and hierarchical environments, (ii) declaring customized policies to mediate user objectives into a target state and (iii) determining valid settings for IoT actuators to achieve such a target also reducing energy consumption. An open-source Prolog prototype of the framework is showcased over two lifelike motivating examples and its scalability is assessed at increasing sizes of the managed smart environment.

Placing applications composed as orchestrated serverless functions onto Cloud-loT infrastructures is a chal-lenging problem as it must consider hardware, software, network Quality of Service, and service interactions constraints. In this paper, we propose a novel declarative methodology that handles all of the above, also relying on information-flow analyses and padding techniques to prevent information leaks through side channels. A motivating use case from augmented reality is used to showcase the open-source prototype implementing our proposal.

Designing, implementing, and operating microservices is known to be complex and costly, mainly due to the multitude of heterogeneous software services forming a microservice-based application. Such tasks can be simpler if a specification of the microservice-based architecture (MSA) of an application is available. At the same time, due to the number of services and service interactions in a MSA, manually generating a specification of such MSA is complex and costly. For this reason, in this paper we present a novel technique for automatically mining the specification of a MSA from its Kubernetes deployment. The obtained MSA specification is in mu TOSCA, a microservice-oriented profile of the human- and machine-readable OASIS standard TOSCA. We also present a prototype implementation of our technique, which we use to assess it by means of case studies based on third-party applications.

Abstract Developing and releasing multiservice applications rely upon a pipeline of automation tools known as Continuous Integration/Continuous Deployment. Among those tools, continuous reasoning is exploited by large companies to perform incremental static analyses on their code commits as soon as they are integrated into a shared codebase. In this article, we extend continuous reasoning towards the continuous QoS- and context-aware management of multiservice applications in Cloud-IoT scenarios. We propose a novel continuous reasoning methodology that supports runtime decision on service placement by reacting both to changes in the infrastructure and in the application requirements, and capable of suggesting migrations only for services affected by such changes. The methodology is prototyped in Prolog and assessed through simulations over a realistic use case and over a lifelike motivating scenario at increasing infrastructure sizes. Experimental results show that our approach brings considerable speed-up in comparison with an exhaustive search employing non-incremental reasoning.

Abstract Osmotic computing encompasses emerging Cloud‐Internet of Things (IoT) computing paradigms, by featuring the possibility for application services to adapt into different functionally equivalent flavours, depending on the contextually available resources and on specific requirements of running applications. This article proposes a fully decentralised declarative framework that enables both application and infrastructure operators to declare management policies for the service instances and the nodes they manage, respectively. Policies are composed of a simple and well‐defined set of management operations, declared in Prolog, which trigger based on locally available contextual information on application requests and infrastructure resources. A prototype implementation of the framework is showcased and assessed via simulation over a lifelike Smart Campus use case with multiple applications, at increasing infrastructure sizes and number of mobile users. Experimental results show that the proposed management framework scales to large infrastructure sizes and suits the needs of multiflavoured Osmotic applications in dynamic deployment conditions, by improving the trade‐off between their response times and suitable service usage.

Abstract The management of modern enterprise applications is automated by coordinating the deployment, configuration, enactment, and termination of their components. Choosing among different candidate implementations for a specified application component requires such implementations to conform to the specified management behaviour. This holds especially if we wish to ensure that the overall application management can continue as planned, or that no additional (potentially undesired) management activity gets enabled. To this end, we introduce a formal framework for testing “management conformance”, i.e., to test whether a candidate implementation can be managed according to the management protocol specifying the allowed management for a component. We also illustrate how our framework enables to run four different conformance tests, each providing a different trade-off between implementation freedom and guarantees on the overall application management. We formally prove that testing management conformance with constraints reducing implementation freedom results in preserving all already allowed management activities when implementing a specification by choosing a conforming implementation and that no additional (potentially undesired) management activity gets enabled. Finally, we assess our framework by means of a prototype implementation and its use in an experimental evaluation.

Modern enterprise applications integrate multiple interdependent software components, whose management must be suitably coordinated. This must be done by taking into account all inter-component dependencies, the faults potentially affecting them, and the fact that each component can be horizontally scaled, i.e., that multiple instances of each component can be spawned or destroyed, depending on application needs. In this article, we introduce a novel solution for suitably modelling and analysing the replica- and fault-aware management of multi-component applications, based on topology graphs and management protocols. More precisely, we first introduce a compositional model of the management behaviour of the (possibly multiple) instances of the components forming an application, faults included. We then show how this model enables automating various useful analyses, from checking the validity of management plans to automatically determining management plans allowing the instance of an application to reach and maintain a desired target configuration.

Abstract Deploying Internet of Things (IoT)-enabled virtual network function (VNF) chains to Cloud-Edge infrastructures requires determining a placement for each VNF that satisfies all set deployment requirements as well as a software-defined routing of traffic flows between consecutive functions that meets all set communication requirements. In this article, we present a declarative solution, EdgeUsher, to the problem of how to best place VNF chains to Cloud-Edge infrastructures. EdgeUsher can determine all eligible placements for a set of VNF chains to a Cloud-Edge infrastructure so to satisfy all of their hardware, IoT, security, bandwidth, and latency requirements. It exploits probability distributions to model the dynamic variations in the available Cloud-Edge infrastructure and to assess output eligible placements against those variations.

Various deployment technologies have been released to support automating the deployment of distributed applications. Although many of these technologies provide general-purpose functionalities to deploy applications as well as infrastructure components, different technologies provide specific capabilities making them suited for different environments and application types. As a result, the deployment of complex distributed applications often requires to combine several deployment technologies expressed by different deployment models. Thus, multiple deployment models are processed by different technologies and must be either orchestrated manually or the automated orchestration must be developed individually. To address these challenges, we present an approach (i) to annotate parts of a holistic deployment model that should be deployed with different deployment technologies, (ii) to automatically transform an annotated model to multiple technology-specific models for different technolo gies, and (iii) to automatically coordinate the deployment execution with different technologies by employing a centralized orchestrator component. To prove the practical feasibility of the approach, we describe a case study based on a third-party application.

The diversity of available cloud service models yields multiple hosting variants for application components. Moreover, the overall trend of reducing control over the infrastructure and scaling configuration makes it non-trivial to decide which hosting variant suits more a certain software component. In this work, we introduce a spectrum of component hosting patterns that covers various combinations of management responsibilities related to (i) the deployment stack required by a given component as well as (ii) required infrastructure resources and component’s scaling rules. We validate the presented patterns by identifying and showing at least three real world occurrences of each pattern following the well-known Rule of Three.

Smart environments enabled by the Internet of Things aim at improving our daily lives by automatically tuning ambient parameters and by achieving energy savings through self-managing cyber-physical systems. Commercial solutions, however, only permit setting simple target goals on those parameters and do not mediate between conflicting goals among different users and/or system administrators, nor across different IoT verticals. In this article, we propose a declarative approach (and its open-source Prolog prototype) to represent smart environments, user-set goals and customisable mediation policies to reconcile contrasting goals across multiple IoT systems.

Abstract Orchestrating next-gen applications over heterogeneous resources along the Cloud-IoT continuum calls for new strategies and tools to enable scalable and application-specific managements. Inspired by the self-organisation capabilities of bacteria colonies, we propose a declarative, fully decentralised application management solution, targeting pervasive opportunistic Cloud-IoT infrastructures. We present a customisable declarative implementation of the approach and validate its scalability through simulation over motivating scenarios, also considering end-user’s mobility and the possibility to enforce application-specific management policies for different (classes of) applications.

Function-as-a-Service (FaaS) is a cloud service model enabling developers to offload event-driven executable snippets of code. The execution and management of such functions becomes a FaaS provider’s responsibility, therein included their on-demand provisioning and automatic scaling. Key enablers for this cloud service model are FaaS platforms, e.g., AWS Lambda, Microsoft Azure Functions, or OpenFaaS. At the same time, the choice of the most appropriate FaaS platform for deploying and running a serverless application is not trivial, as various organizational and technical aspects have to be taken into account. In this work, we present (i) a FaaS platform classification framework derived using a multivocal review and (ii) a technology review of the ten most prominent FaaS platforms, based on the proposed classification framework. We also present a FaaS platform selection support system, called FaaStener, which can help researchers and practitioners to choose the FaaS platform most suited for their requirements.

Summary Exploiting microservices to architect enterprise applications is becoming commonplace. This makes it crucial to provide some support for designing and analyzing microservice‐based applications, for example, for understanding whether a microservice‐based application adheres to the main design principles of microservices and for choosing how to refactor it when this is not the case. To provide such support, in this article we present the TOSCA toolchain. More precisely, we first introduce the TOSCA model to represent the architecture of microservice‐based applications with the OASIS standard TOSCA. We then describe a technique to automatically mine the architecture of a microservice‐based application and represent it with TOSCA, given the Kubernetes deployment of the application. We also present a methodology to analyze the TOSCA representation of a microservice‐based architecture to systematically identify the architectural smells potentially affecting the corresponding application and to resolve them. Finally, we present two prototype tools, Miner and Freshener , implementing our mining solution and the support for identifying and resolving architectural smells in microservice‐based applications, respectively. We then assess —by discussing some case studies— how effectively Miner , Freshener , and the TOSCA toolchain can support researchers and practitioners working with microservices.

\n The adoption of cloud computing combined with DevOps enables\n companies to react to new market requirements more rapidly and\n fosters the use of automation technologies. This influences the way\n software solutions are built, which is why the concept of\n cloud-native applications has emerged over the last few years to\n build highly scalable applications, and to automatically deploy and\n run them in modern cloud environments. However, there is currently\n no reference work clearly stating the features that a deployment\n technology must offer to support the deployment of arbitrary\n cloud-native applications. In this paper, we derive three essential\n features for deployment technologies based on the current\n cloud-native research and characteristics discussed therein. The\n presented features can be used to compare and categorize existing\n deployment technologies, and they are intended to constitute a first\n step towards a comprehensive framework to assess deployment\n technologies.\n

Summary Enterprise IT is currently facing the challenge of coordinating the management of complex, multicomponent applications across heterogeneous cloud platforms. Containers and container orchestrators provide a valuable solution to deploy multicomponent applications over cloud platforms, by coupling the lifecycle of each application component to that of its hosting container. We hereby propose a solution for going beyond such a coupling, based on the OASIS standard TOSCA and on Docker. We indeed propose a novel approach for deploying multicomponent applications on top of existing container orchestrators, which enables managing each component independently from the container used to run it. We also present prototype tools that implement our approach, and we show how we effectively exploited them to carry out a concrete case study.

Summary Fog computing aims at extending the cloud towards the Internet of things so to achieve improved quality of service and to empower latency‐sensitive and bandwidth‐hungry applications. The fog calls for novel models and algorithms to distribute multiservice applications in such a way that data processing occurs wherever it is best placed, based on both functional and nonfunctional requirements. This survey reviews the existing methodologies to solve the application placement problem in the fog, while pursuing three main objectives. First, it offers a comprehensive overview on the currently employed algorithms, on the availability of open‐source prototypes and on the size of test use cases. Second, it classifies the literature based on the application and fog infrastructure characteristics that are captured by available models, with a focus on the considered constraints and the optimized metrics. Finally, it identifies some open challenges in application placement in the fog.

The fault handling and recovery from runtime failures of cloud applications should be done by taking into account the inter-dependencies occurring among their components, and by dealing with the diverse and heterogeneous cloud offerings used to host them. The latter is even harder in trans-cloud scenarios, i.e., when application components are possibly deployed on different platforms and at different service levels (IaaS or PaaS). In this paper, we propose a methodology to support the automated management and recovery of (un) foreseen failures in a trans-cloud application, which takes into account all interdependencies occurring among its components. We then present a prototype implementation of our proposal, consisting of an orchestrator that exploits a management framework for trans-cloud application deployments, together with management protocols for the automated planning of the fault-aware administration of applications.

Abstract Estimating the cost of a multi-component application (e.g., its resource or energy consumption) is fundamental in nowadays enterprise IT, especially if we consider that current pricing models are mainly pay per-use. While this is still manageable on small applications, it is really hard to manually estimate the cost of large-scale enterprise applications involving hundreds of interdependent application components. In this article, we formalise the problem of estimating costs of multi-component applications, by representing the structure of an application as a typed directed graph, and by allowing to associate different types of costs with different application components. We show that costs can be fully customised, and that associating different costs with the same application leads to different cost estimation problems defined on that application.We then present an approach for solving cost estimation problems on multi-component applications, which is based on terminating and confluent graph transformations. We also present a prototype implemenation of our approach, which we use to run a case study based on a third-party application.

Containers as a lightweight technology to virtualise applications have recently been successful, particularly to manage applications in the cloud. Often, the management of clusters of containers becomes essential and the orchestration of the construction and deployment becomes a central problem. This emerging topic has been taken up by researchers, but there is currently no secondary study to consolidate this research. We aim to identify, taxonomically classify and systematically compare the existing research body on containers and their orchestration and specifically the application of this technology in the cloud. We have conducted a systematic mapping study of 46 selected studies. We classified and compared the selected studies based on a characterisation framework. This results in a discussion of agreed and emerging concerns in the container orchestration space, positioning it within the cloud context, but also moving it closer to current concerns in cloud platforms, microservices and continuous development.

Deploying IoT applications through the Fog in a QoS-, context-, and cost-aware manner is challenging due to the heterogeneity, scale and dynamicity of Fog infrastructures. To decide how to allocate app functionalities over the continuum from the IoT to the Cloud, app administrators need to find a trade-off among QoS, resource consumption and cost. In this paper, we present a novel cost model for estimating the cost of deploying IoT applications to Fog infrastructures. We show how the inclusion of the cost model in the FogTorchP open-source prototype permits to determine eligible deployments of multi-component applications to Fog infrastructures and to rank them according to their QoS-assurance, Fog resource consumption and cost. We run the extended prototype on a motivating scenario, showing how it can support IT experts in choosing the deployments that best suit their desiderata.

Summary We introduce DockerAnalyser, a microservice‐based tool that permits building customised analysers of Docker images. The architecture of DockerAnalyser is designed to crawl Docker images from a remote Docker registry, to analyse each image by running an analysis function, and to store the results into a local database. Users can build their own image analysers by instantiating DockerAnalyser with a custom analysis function and by configuring the architecture. More precisely, the steps needed to obtain new analysers are (1) replacing the analysis function used to analyse crawled Docker images, (2) setting the policy for crawling Docker images, and (3) setting the scalability options for obtaining a scalable architecture. In this paper, we also present 2 different use cases, ie, 2 different analysers of Docker images created by instantiating DockerAnalyser with 2 different analysis functions and configuration options. The 2 use cases show that DockerAnalyser decreases the effort required to obtain new analysers versus building them from scratch.

Summary How to flexibly manage complex applications across heterogeneous cloud platforms is one of the main concerns in today's IT enterprise. The OASIS standard TOSCA (Topology and Orchestration Specification for Cloud Applications) and the Docker ecosystem are two emerging solutions trying to address this problem from different perspectives. In this paper, we propose a solution that tries to synergically combine the pros of both TOSCA and of Docker. More precisely, we propose a TOSCA‐based representation for specifying the software components and the Docker containers forming an application. We also present TosKer, an engine for orchestrating the management of multicomponent applications based on the proposed TOSCA representation and on Docker. Finally, we illustrate how TosKer was fruitfully exploited in a concrete case study based on a third‐party application.

Deploying composite applications to Fog nodes in a QoS- and context-aware manner is challenging due to the heterogeneity, scale and dynamicity of Fog infrastructures.

Docker containers run from Docker images, which can be distributed through so-called Docker registries. The currently available support for searching images in registries is however limited. Available registries (e.g., Docker Hub) only permit searching images "by name", i.e. by specifying a term occurring in the image name, in the image description or in the name of the user that created such image. In this paper we try to enhance the support for discovering Docker images by introducing DockerFinder, a microservice-based prototype that permits searching for images based on multiple attributes, e.g., image name, image size, or supported software distributions. DockerFinder crawls images from a remote Docker registry, it automatically analyses such images to produce multi-attribute descriptions to be stored in a local repository, and it permits searching for images by querying the local repository.

Deploying composite applications to Fog nodes in a QoS-and context-aware manner is challenging due to the heterogeneity and scale of Fog infrastructures. Application components must be provided with the software and hardware capabilities they need. Communication links that support interactions between components must meet certain QoS (latency and bandwidth). On the other hand, different Fog and Cloud nodes provide different software and hardware capabilities, and actual communication links support different QoS over time. In this paper we present a prototype (FogTorchII) capable of determining deployments of composite applications to Fog infrastructures, which fulfil software, hardware and QoS requirements. FogTorchII exploits Monte Carlo simulations to take into account possible variations of the QoS of communication links. It classifies eligible deployments both in terms of QoS-assurance and of Fog resource consumption. We illustrate the utility of FogTorchII over a motivating example where we compare different possible deployments for a smart agriculture application.

Fog computing aims at extending the Cloud by bringing computational power, storage, and communication capabilities to the edge of the network, in support of the IoT. Segmentation, distribution, and adaptive deployment of functionalities over the continuum from Things to Cloud are challenging tasks, due to the intrinsic heterogeneity, hierarchical structure, and very large scale infrastructure they will have to exploit. In this paper, we propose a simple, yet general, model to support the QoS-aware deployment of multicomponent IoT applications to Fog infrastructures. The model describes operational systemic qualities of the available infrastructure (latency and bandwidth), interactions among software components and Things, and business policies. Algorithms to determine eligible deployments for an application to a Fog infrastructure are presented. A Java tool, FogTorch, based on the proposed model has been prototyped.

OASIS TOSCA aims at solving the problem of managing complex applications across heterogeneous clouds by providing a standard, vendor-agnostic language to describe them. TOSCA permits defining a cloud application as an orchestration of typed components, which can be instantiated by matching other TOSCA applications. In this paper we first present two types of behaviour-aware matching of applications, based on a notion of simulation. We then relax this notion by permitting to match an operation with a sequence of available operations, and present a coinductive procedure to compute such relaxed simulation.

The adaptive management of complex applications deployed across multiple heterogeneous PaaS platforms is one of the problems that have emerged with the cloud revolution. The ongoing EU research project SeaClouds aims at providing seamless adaptive multi-cloud management of complex applications by supporting the distribution, monitoring and migration of application modules over multiple heterogeneous PaaS platforms. In this paper we present context, motivations and objectives of SeaClouds, its relation with other cloud initiatives, and its initial architecture.

Advances in pervasive technology have made it possible to consider large-scale application types that potentially span heterogeneous organizations, technologies, and device types. This class of application will have a multilayer architecture, where each layer is likely to use languages and technologies appropriate to its own concerns. An example application is a geographically large-scale crisis management system. Typically, such applications are required to dynamically adapt their behavior based on current circumstances, with adaptations potentially affecting all layers of the application. The complexities involved in dynamically adapting multilayer applications will significantly benefit from formal approaches to its specification. This article presents a new methodology for flexible, multilayer application adaptation, with layer-specific adaptation solution templates bound to application mismatches that are organized into hierarchical taxonomies. Templates can be linked either through direct invocations or through adaptation events, supporting flexible cross-layer adaptation. The methodology illustrates the use of different formalisms for different elements of its specification. In particular, we combine semiformal metamodeling techniques for the system model specification with formal Petri nets, which are used to capture template matchmaking using reachability analysis. This work demonstrates how existing formalisms can be used for the specification of a generic adaptation model for pervasive applications.

Our long-term objective is to develop a general methodology for deploying (Web) service aggregation and adaptation middleware, capable of suitably overcoming syntactic and behavioral mismatches in view of application integration within and across organizational boundaries. This article focuses on describing the core aggregation process, which generates the workflow of a composite service from a set of service workflows to be aggregated and a data-flow mapping linking service parameters.

Web services represent a promising technology for the development of distributed heterogeneous software systems. In this setting, a major issue is to establish whether two services can be used interchangeably in any context. To this aim, our paper first briefly reviews the results contained in a recent article by the same authors, where a suitable notion of behavioural equivalence for Web services was introduced. Our work then extends those results, in order to account for ontologybased service specifications. Next, a concrete example scenario – a car rental system – is presented, and it is then used to illustrate how the equivalence between services can be fruitfully employed for correctly addressing two prominent, modularity-related problems: the publication of correct service specifications and the replaceability of (sub)services.

We present a service discovery architecture for embedded peer-to-peer systems, tailored to deal with low-capacity, mobile devices. The proposed discovery mechanism is built on top of the (Chord) Distributed Hash Table technology, extending it by fruitfully exploiting high-capacity devices (when avai

In this paper we introduce SMoL, a simplified BPEL- like language for specifying peer and service behaviour in P2P systems. We define a transformational semantics of SMoL in terms of YAWL workflows, which enables the simulation (e.g., testing possible execution scenarios) and analysis (e.g., verifying reachability or lock freedom) of the behaviour of P2P peers and services.

Web service discovery is one of the key issues in the emerging area of Service-oriented Computing. In this paper, we present a complete composition-oriented, ontology-based methodology for discovering semantic Web services, which exploits functional and behavioral properties contained in OWL-S service advertisements to satisfy functional and behavioral client queries. To this aim, we build on top of the results contained in two recent articles, where we presented (1) a suitable data structure (viz. a dependency hypergraph) to collect functional information of services, and (2) a suitable notion of behavioral equivalence for Web services. We also discuss the architecture and the main implementation choices of the matchmaking system applying such a methodology.

Service discovery and service aggregation are two crucial issues in the emerging area of service-oriented computing (SOC). We propose a new technique for the discovery of (Web) services that accounts for the need of composing several services to satisfy a client query. The proposed algorithm makes use of OWL-S ontologies, and explicitly returns the sequence of atomic process invocations that the client must perform in order to achieve the desired result. When no full match is possible, the algorithm features a flexible matching by returning partial matches and by suggesting additional inputs that would produce a full match.

The program composition approach can be fruitfully applied to combine general logic programs, that is, logic programs possibly containing negative premises. We show how the introduction of a basic set of (meta-level) composition operations over general programs increases the knowledge representation capabilities of logic programming for non-monotonic reasoning. Examples of modular programming, hierarchical reasoning, constraints and rules with exceptions will be illustrated. The semantics of programs and program compositions is defined in terms of three-valued logic by extending the three-valued semantics for logic programs proposed by Fitting. A computational interpretation of program compositions is formalized by means of an equivalence preserving syntactic transformation of arbitrary program compositions into standard general programs. Key words: Logic programming, program composition, non-monotonic reasoning, three-valued logic

A simple extension of logic programming consists of introducing a set of basic program composition operations, which form an algebra of logic programs with interesting properties for reasoning about programs and program compositions. From a programming perspective, the operations enhance the expressive power of the logic programing paradigm by supporting a wealth of programming techniques, ranging from software engineering to artificial intelligence applications. This paper focuses on the semantics of program composition operations. It is shown that the immediate consequence operator T(P) properly characterises the intended meaning of a program P when considering compositions of programs. More precisely, it is shown that the T(P) semantics is both compositional and fully abstract w.r.t. the set of composition operations of the algebra. This implies that the T(P) semantics induces the coarsest equivalence relation on programs (subsumption-equivalence) and that any other semantics of programs must induce the same equivalence relation to be both compositional and fully abstract w.r.t. the whole set of operations of the algebra. The T(P) semantics is then related to other well known semantics for logic programs which induce coarser equivalence relations. In particular, three equivalence relations, originally studied by Maher (1988), are considered: Weak subsumption-equivalence, logical equivalence and least Herbrand model equivalence. It is shown that the chain of equivalence relations composed by weak subsumption-equivalence, logical equivalence and least Herbrand model equivalence coincides with the chain of fully abstract compositional equivalence relations for proper subsets of the operations of the algebra, obtained by dropping one operation at a time from the set of compositions.

Meta-programming is a powerful technique for extending and modifying the semantics of an existing object language. Along with the expressiveness, however, meta-programming puts forth some subtle semantic problems, among which the most critical is bound to the representation of object programs at the meta-level. We propose a semantic justification for a simple representation technique in the field of a generalised notion of meta-programming in logic. The generalisation consists in specifying the meta-programs with respect to object programs defined by program expressions. The expressions are defined via a rich suite of operations on logic programs. The technique allows one to build straightforward and concise meta-programs via the representation of object level variables by meta-level variables.>

Modularity is a key issue in the design of modern programming languages. When designing modular features for declarative languages in general, and for logic programming languages in particular, the challenge lies in avoiding the superimposition of a complex syntactic and semantic structure over the simple structure of the basic language. The modular framework defined here for logic programming consists of a small number of operations over modules which are (meta-) logically defined and semantically justified in terms of the basic logic programming semantics. The operations enjoy a number of algebraic properties, thus yielding an algebra of modules. Despite its simplicity, the suite of operations is shown capable of capturing the core features of modularization: information hiding, import/export relationships, and construction of module hierarchies. A metalevel implementation and a compilation-oriented implementation of the operations are provided and proved sound with respect to the semantics. The compilation-oriented implementation is based on manipulation of name spaces and provides the basis for an efficient implementation.

Structuring logic programs to deal with evolving and incomplete knowledge is one of the main issues in representing knowledge with logic. On the one hand, evolving knowledge in logic programming can be modelled through suitable operators for the dynamic composition of separate programs. On the other hand, when dealing with dynamic compositions of logic programs, the open world assumption adequately models the aspects of incompleteness of knowledge. We analyse the notion of open program along with suitable operators for composing and closing programs. We present the semantics of open programs and of the associated operators in two different, equivalent styles. We define a model-theoretic semantics in terms of Herbrand models, while an operational semantics is given by means of inference rules. In the second part of the paper, we explore some applications of open programs and of their compositions. We show how a number of policies for structuring logic programming can be reconstructed in this setting, including the construction of modules with import declarations. Finally, the relations between open programs and abductive logic programming are discussed.

Shared Prolog is a new concurrent logic language. A Shared Prolog system is composed of a set of parallel agents that are Prolog programs extended by a guard mechanism. The programmer controls the granularity of parallelism, coordinating communication and synchronization of the agents via a centralized data structure. The communication mechanism is inherited from the blackboard model of problem solving. Intuitively, the granularity of the logic processes to be elaborated in parallel is large, while the resources shared on the blackboard can be very fined grained. An operational semantics for Shared Prolog is given in terms of a distributed model. Through an abstract notion of computation, the kinds of parallelism supported by the language, as well as properties of infinite computations, such as local deadlocks, are studied. The expressiveness of the language is shown with respect to the specification of two classes of applications: metaprogramming and blackboard systems.