Technologies such as mobile, edge, and cloud computing have the potential to form a computing continuum for new, disruptive applications. At runtime, applications can choose to execute parts of their logic on different infrastructures that constitute the continuum, with the goal of minimizing latency and battery consumption and maximizing availability. In this article, we propose A3-E, a unified model for managing the life cycle of continuum applications. In particular, A3-E exploits the Functions-as-a-Service model to bring computation to the continuum in the form of microservices. Furthermore, A3-E selects where to execute a certain function based on the specific context and user requirements. The article also presents a prototype framework that implements the concepts behind A3-E. Results show that A3-E is capable of dynamically deploying microservices and routing the application’s requests, reducing latency by up to 90% when using edge instead of cloud resources, and battery consumption by 74% when computation has been offloaded.

This extended abstract summarizes our paper entitled "A Comparison Framework for Runtime Monitoring Approaches" published in the Journal on Systems and Software in vol. 125 in 2017 (https://doi.org/10.1016/jjss.2016.12.034). This paper provides the following contributions: (i) a framework that supports analyzing and comparing runtime monitoring approaches using different dimensions and elements; (ii) an application of the framework to analyze and compare 32 existing monitoring approaches; and (iii) a discussion of perspectives and potential future applications of our framework, e.g., to support the selection of an approach for a particular monitoring problem or application context.

This paper presents MAGNET, a novel middleware infrastructure that exploits Wi-Fi Direct to provide a reliable and stable communication means for large numbers of mobile devices. This self-organizing middleware abstracts the multi-hop communication process by autonomously maintaining connectivity among devices. MAGNET also provides a discovery mechanism that exploits the MAC address of the different devices or the services they offer. MAGNET was evaluated both on our WiDiSi simulator for Wi-Fi Direct-based systems, and on real Android devices. The results we obtained in our evaluation illustrate the effectiveness of the proposed middleware, both in discovering and maintaining connectivity in large-scale dynamic scenarios.

Modern Web applications exploit Cloud infrastructures to scale their resources and cope with sudden changes in the workload. While the state of practice is to focus on dynamically adding and removing virtual machines, we advocate that there are strong benefits in containerizing the applications and in scaling the containers.

This paper describes WiDiSi, a research-oriented prototype simulator for Wi-Fi Direct networks. WiDiSi is provided as an extension of PeerSim, a widely-used, open-source simulation framework for large-scale peer to peer networks. WiDiSi's main goal is to allow Android Wi-Fi direct applications to be easily tested in large-scale dynamic scenarios. In this article, we explain how WiDiSi was modeled and present its general architecture. We also provide evaluation results that show the correctness and the capabilities of the simulator.

A common barrier to experimenting with cloud infrastructure is the lack of access to a fully functional cloud installation. Although Open Stack can be used to create test beds, it is not uncommon in literature to find works that are plagued by unrealistic setups that use only a handful of servers. Moreover, setting up a test bed is necessary but not sufficient. One must also be able to create repeatable experiments that can be used to compare one's results to baseline or related approaches from the state of the art. We present a Dock, a suite of tools for creating perform ant, sand boxed, and configurable cloud infrastructure experimentation environments based on Open Stack and Docker. Its light-weight approach facilitates the development of Open Stack extensions, allowing one to more easily test them in realistic scenarios. A dock also provides a set of simulation tools that, for now, focus on creating experiments for Virtual Machine Placement and Server Consolidation algorithms. In this paper we also show how a Dock was used to develop a Server Consolidation Service for Nova, and provide an analysis of a Dock's scalability and simulation capabilities.

Smart interconnected devices are changing our lives and are turning conventional spaces into smart ones. Physical proximity, a key enabler of social interactions in the old days is not exploited by smart solutions, where the social dimension is always managed through the Internet. This paper aims to blend the two forces and proposes the idea of social smart space, where modern technologies can help regain and renew social interactions, and where proximity is seen as enabler for dedicated and customized functionality provided by users to users. A Social Proximity Framework (SPF) provides the basis for the creation of this new flavor of smart spaces. Two different versions of the SPF, based on different communication infrastructures, help explain the characteristics of the different components, and show how the SPF can benefit from emerging connection-less communication protocols. A first assessment of the two implementations concludes the paper.

Service-based business processes must evolve to remain aligned with their goals, with zero downtime to guarantee business continuity. A new version of a service should be adopted as soon as it becomes available to let clients benefit from the updated functionality and/or improved quality of service. In practice, however, existing services may be involved in distributed computations that cannot immediately adopt the new versions without suffering inconsistencies. The paper proposes a solution for the consistent runtime evolution of service-based business processes: new service versions can be adopted safely and in a timely fashion, and old versions can be consistently decommissioned. The proposal has been evaluated in the context of an online bank wire transfer example. Our experiments show that the approach is timely in activating service updates, and that the overhead it introduces is negligible.

In this paper, we focus on the reliability and availability analysis of Web service (WS) compositions, orchestrated via the Business Process Execution Language (BPEL). Starting from the failure profiles of the services being composed, which take into account multiple possible failure modes, latent errors, and propagation effects, and from a BPEL process description, we provide an analytical technique for evaluating the composite process' reliability-availability metrics. This technique also takes into account BPEL's advanced composition features, including fault, compensation, termination, and event handling. The method is a design-time aid that can help users and third party providers reason, in the early stages of development, and in particular during WS selection, about a process' reliability and availability. A non-trivial case study in the area of travel management is used to illustrate the applicability and effectiveness of the proposed approach.

Due to the growing pervasiveness of the service paradigm, modern systems are now often built as software as a service, and tend to exploit underlying platforms and virtualized resources also provided as services. Managing such systems requires that we be aware of the behaviors of all the different layers, and of the strong dependencies that exist between them. In this paper we present the Multi-layer Collection and Constraint Language (mlCCL). It allows us to define how to collect, aggregate, and analyze runtime data in a multi-layered system. We also present ECoWare, a framework for event correlation and aggregation that supports mlCCL, and provides a dashboard for on-line and off-line drill-down analyses of collected data. Empirical assessment shows that the impact of the approach on runtime performance is negligible.

Distributed systems comprise a significant number of entities that must be properly coordinated to reach a goal. These systems present high turnover of elements, and demand for solutions that keep their coordination as decentralized as possible to avoid bottlenecks. The paper discusses why it is important to address these characteristics from a system's conception and proposes A-3, an innovative architectural solution that adopts the concept of group as an abstraction for organizing an application into semi-independent slices, providing a single and coherent view of these aggregates, and coordinating the interactions inside and among groups. The paper presents the A-3 model and defines it as an innovative architectural style, describes a Java-based framework that supports A-3 and provides users with the proper means to exploit the style, and exemplifies all the main concepts on a simple scenario where autonomous robotic vacuum cleaners are coordinated to properly clean a museum.

Service compositions suffer changes in their partner services. Even if the composition does not change, its behavior may evolve over time and become incorrect. Such changes cannot be fully foreseen through prerelease validation, but impose a shift in the quality assessment activities. Provided functionality and quality of service must be continuously probed while the application executes, and the application itself must be able to take corrective actions to preserve its dependability and robustness. We propose the idea of self-supervising BPEL processes, that is, special-purpose compositions that assess their behavior and react through user-defined rules. Supervision consists of monitoring and recovery. The former checks the system's execution to see whether everything is proceeding as planned, while the latter attempts to fix any anomalies. The paper introduces two languages for defining monitoring and recovery and explains how to use them to enrich BPEL processes with self-supervision capabilities. Supervision is treated as a cross-cutting concern that is only blended at runtime, allowing different stakeholders to adopt different strategies with no impact on the actual business logic. The paper also presents a supervision-aware runtime framework for executing the enriched processes, and briefly discusses the results of in-lab experiments and of a first evaluation with industrial partners.

In the literature, there exist several approaches for monitoring the execution of BPEL processes. They concentrate on different properties, adopt different languages, work at different levels of abstraction, and assume different perspectives. Even if the field is rather new, we do not think that this diversity is a limitation of current solutions; rather it is intrinsic in the problem itself. We claim that, instead of working on the definition of the ultimate approach for BPEL monitoring, we should push a cooperative approach based on the integration of different solutions.In this paper, we present a first step in this direction, and describe a monitoring framework which is obtained by integrating two well-known approaches, namely Dynamo and Astro. This integration, which happens both for the language used for expressing the properties to be monitored, and for the architecture of the monitoring framework, allows to combine the advantages of the two approaches and to obtain a general, comprehensive solutions for BPEL monitoring.

Web service based applications are expected to live in dynamically evolving settings. At run-time, services may undergo changes that could modify their expected behavior. Because of such intrinsic dynamic nature, applications should be designed by adhering to the principles of design- by-contract. Run-time monitoring is needed to check that the contract between service providers and service users is fulfilled while the collaboration is in place. We describe a language to specify the expected functional and non-functional requirements that a service provider should fulfill. The language (timed WSCoL) is a temporal extension of a previous proposal (WSCoL). We also illustrate the architecture of a run-time analyzer that checks timed WSCoL properties. Should such properties be disproved during execution, appropriate recovery and reconfiguration actions may be put in place.

This tutorial introduces dynamic web services as a solution to cope with the dynamism and flexibility required by many modern software systems. Current technologies (WSDL, WS-BPEL, etc.) have proven insufficient in addressing these issues; however, they remain a good starting point for the analysis of the current situation and for building for the future.The core part of the tutorial analyzes ---by looking at available technologies and prominent research proposals---the deployment and execution of these applications within three separate phases: a composition phase, to discover available services and implement the desired behavior, a monitoring phase, to understand if a given service is behaving correctly (with respect to both functional and non-functional requirements), and a recovery phase, to react to anomalies by means of suitable replanning or recovery strategies.In conclusion, the tutorial summarizes the main topics, presents a list of still-to-be-solved problems, and highlights possible directions for future research.

The service-oriented approach is becoming more and more popular to integrate highly heterogeneous systems. Service-oriented architectures (SoAs) define a new flexible coordination paradigm for integrating components (services) in unstable and evolving contexts, where the high degree of flexibility and dynamism requires that available functionality be discovered at run-time and its quality parameters be negotiated dynamically. This is the case, for example, of ambient computing and automotive applications that need to cope with continuously evolving configurations. The dynamic nature of these systems precludes the a-priori identification of the components that define the system and demands for the run-time discovery and composition of such services, adding uncertainty to the system. It could be the case, for example, that a binding (request/provision) cannot span multiple executions since the changing context alters the set of available services. This means that problems related to the discovery of services should also be considered and handled at run-time. If the selection phase aborts, simply shutting down the system is not, in general, going to be a solution. The execution environment should be able to select new services and even reorganize the process to find a solution that uses what is available, if a perfect match does not exist.

SOAs (service oriented architectures) are becoming a new paradigm for flexible coordination between business partners within continuously evolving and heterogeneous environments. In these environments, the set of available services with which to do business changes constantly in number and type, hindering the degree of trustworthiness. In this research, the author focuses on how to augment this trust through the use of self-healing Web service compositions. There are three dimensions along which this research move to achieve the aforementioned goals: service composition and process description, monitoring and recovery strategies.

Service-based approaches are widely used to integrate heterogenous systems. Web services allow for the definition of highly dynamic systems where components (services) can be discovered and QoS parameters negotiated at run-time. This justifies the need for monitoring service compositions at run-time. Research on this issue, however, is still in its infancy.