Migrating from a legacy monolithic system to a microservice architecture is a complex and time-consuming process. Software engineers may strongly benefit from automated support to identify a high-cohesive and loose-coupled set of microservices with proper granularity. The automated approach proposed in this paper extracts microservices by using graph clustering and combinatorial optimization to maximize cohesion and minimize coupling. The approach performs static analysis of the code to obtain a graph representation of the monolithic system. Then, it uses graph clustering to detect high-cohesive communities of nodes using the Louvain community algorithm. In parallel, the tool clusters the domain entities (i.e., classes representing uniquely identifiable concepts in a system domain) within bounded contexts to identify the required service granularity. Finally, it uses combinatorial optimization to minimize the coupling, hence deriving the microservice architecture. The approach is fully implemented. We applied it over four different monolithic systems and found valuable results. We evaluated the identified architectures through cohesion and coupling metrics, along with a comparison with other state-of-the-art approaches based on features such as granularity level, number of produced services, and methods applied. The approach implementation and the experimental results are publicly available.

Abstract Modern technologies and emerging wireless communication solutions in the Information and Communications Technology (ICT) world are empowering the spread of the most disparate ready‐to‐use software services distributed over the globe and accessed by an increasing number of users. This state of affairs encourages the development of systems based on the reuse of existing services through composition approaches, notably choreographies. Also Public Administrations are driven towards a digitalization process which exploits composition approaches to build complex and interoperable systems that can be remotely accessed by citizens and authorities. However, an automatic support is needed in order to realize the service composition and the distributed coordination logic that enforces the correct choreography realization. Moreover, the need for building dynamic and user‐centered systems calls for the realization of choreographies capable to adjust their behavior to the surrounding context. This work presents our proposal for addressing the choreography realization problem, by describing an automated process for the synthesis of choreography‐based systems. The synthesized systems are location‐aware and able to adapt the services' interaction according to the user's needs and context conditions. We show and evaluate our approach at work on a real use case scenario in the Public Administration domain.

Summary Service choreographies support a distributed composition approach that is based on the specification of the external interaction of the participant services in terms of flows of message exchanges, given from a global perspective. When developing distributed service‐based applications, different services are produced by different teams; at the same time, such choreographies can also interact with third‐party services, hence leading to the reuse of black‐box services. Enforcing a global coordination logic across the many in‐house and third‐party services to correctly realize the specified choreography is a nontrivial endeavor. Automatic support is then desirable. In this article, we present an integrated development and run‐time environment for choreography‐based systems, which covers all the development activities, including specification, code synthesis, automatic deployment, enactment, and monitoring on the Cloud. We focus on providing a practical solution, that is, applicable by the community and considering technological standards used in the industry. We report the results of an experiment that we conducted with a use case in the in‐store marketing and sales domain. Results confirm confidence in the approach and show that the platform can be applied in practical contexts.

With the emerging connected automated vehicles, 5G and Internet of Things (IoT), vehicles and road infrastructure become connected and cooperative, enabling Cooperative Intelligent Transport Systems (C-ITS). C-ITS are transport system of systems that involves many stakeholders from different sectors. While running their own systems and providing services independently, stakeholders cooperate with each other for improving the overall transport performance such as safety, efficiency and sustainability. Massive information on road and traffic is already available and provided through standard services with different protocols. By reusing and composing the available heterogeneous services, novel value-added applications can be developed. This paper introduces a choreography-based service composition platform, i.e. the CHOReVOLUTION Integrated Development and Runtime Environment (IDRE), and it reports on how the IDRE has been successfully exploited to accelerate the reuse-based development of a choreography-based Urban Traffic Coordination (UTC) application. The UTC application takes the shape of eco-driving services that through real-time eco-route evaluation assist the drivers for the most eco-friendly and comfortable driving experience. The eco-driving services are realized through choreography and they are exploited through a mobile app for online navigation. From specification to deployment to execution, the CHOReVOLUTION IDRE has been exploited to support the realization of the UTC application by automatizing the generation of the distributed logic to properly bind, coordinate and adapt the interactions of the involved parties. The benefits brought by CHOReVOLUTION IDRE have been assessed through the evaluation of a set of Key Performance Indicators (KPIs).

Multicopters are increasingly popular since they promise to simplify a myriad of everyday tasks. Currently, vendors provide low-level APIs and basic primitives to program multicopters, making mission development a task-specific and error-prone activity. As a consequence, current approaches are affordable only for users that have a strong technical expertise. Then, software engineering techniques are needed to support the definition, development, and realization of missions at the right level of abstraction and involving teams of autonomous multicopters that guarantee the safety today's users expect. In this paper we describe a tool that enables end-users with no technical expertise, e.g., firefighters and rescue workers, to specify missions for a team of multicopters. The detailed flight plan that each multicopter must perform to accomplish the specified mission is automatically generated by preventing collisions between multicopters and obstacles, and ensuring the preservation of no-fly zones.

This document is a summary paper reporting on the IEEE Services 2015 Visionary Track on Service Composition for the Future Internet (SCFI 2015).

Summary of the IEEE First International Workshop on Service Orchestration and Choreography for the Future Internet (OrChor 2014)

Ubiquitous and pervasive computing promotes the creation of an environment where Networked Systems (NSs) eternally provide connectivity and services without requiring explicit awareness of the underlying communications and computing technologies. In this context, achieving interoperability among heterogeneous NSs represents an important issue. In order to mediate the NSs interaction protocol and solve possible mismatches, connectors are often built. However, connector development is a never-ending and error-prone task and prevents the eternality of NSs. For this reason, in the literature, many approaches propose the automatic synthesis of connectors. However, solving the connector synthesis problem in general is hard and, when possible, it results in a monolithic connector hence preventing its evolution. In this paper, we define a method for the automatic synthesis of modular connectors, each of them expressed as the composition of independent mediators. A modular connector, as synthesized by our method, supports connector evolution and performs correct mediation.

Software is increasingly produced according to a certain goal and by integrating existing software produced by third-parties, typically black-box, and often provided without a machine readable documentation. This implies that development processes of the next future have to explicitly deal with an inherent incompleteness of information about existing software, notably on its behaviour. Therefore, on one side a software producer will less and less know the precise behaviour of a third party software service, on the other side she will need to use it to build her own application. In this paper we present an innovative development process to automatically produce dependable software systems by integrating existing services under uncertainty and according to the specied goal. Moreover, we (i) discuss important challenges that must be faced while producing the kind of systems we are targeting, (ii) give an overview of the state of art related to the identied challenges, and finally (iii) provide research directions to address these challenges.

In the next future we will be surrounded by a virtually infinite number of software applications that provide computational software resources in the open Globe. This will radically change the way software will be produced and used. Users will be keen on producing their own piece of software, by also reusing existing software, to better satisfy their needs, therefore with a goal oriented, opportunistic use in mind. The produced software will need to be able to evolve, react and adapt to a continuously changing environment, while guaranteeing dependability. The strongest adversary to this view is the lack of knowledge on the software's structure, behavior, and execution context. Despite the possibility to extract observational models from existing software, a producer will always operate with software artifacts that exhibit a degree of uncertainty in terms of their functional and non functional characteristics. We believe that uncertainty can only be controlled by making it explicit and by using it to drive the production process itself. In this paper, we introduce a novel paradigm of software production process that explores available software and assesses its degree of uncertainty in relation to the opportunistic goal G, assists the producer in creating the appropriate integration means towards G, and validates the quality of the integrated system with respect to G and the current context.

The CONNECT European project that started in February 2009 aims at dropping the interoperability barrier faced by todaypsilas distributed systems. It does so by adopting a revolutionary approach to the seamless networking of digital systems, that is, synthesizing on the fly the connectors via which networked systems communicate. CONNECT then investigates formal foundations for connectors together with associated automated support for learning, reasoning about and adapting the interaction behavior of networked systems.

Web-services are broadly considered as an effective means to achieve interoperability between heterogeneous parties of a business process and offer an open platform for developing new composite web-services out of existing ones. In the literature many approaches have been proposed with the aim to automatically compose web-services. All of them assume that, along with the web-service signature, some information is provided about how clients interacting with the web-service should behave when invoking it.

SYNTHESIS is a tool for automatically assembling correct and distributed component-based systems. In our context, a system is correct when it is deadlock-free and performs only specified component interactions. In order to automatically synthesize the correct composition code, SYNTHESIS takes as input an high-level behavioural description for each component that must form the system to be built and a specification of the component interactions that must be enforced in the system. The automatically derived composition code is implemented as a set of distributed component wrappers that cooperatively interact with each other and with their wrapped components in order to prevent possible deadlocks and make the composed system exhibit only the specified interactions. The current version of SYNTHESIS supports two possible development platforms: Microsoft COM/DCOM, and EJB (Enterprise Java Beans).

The use of component-based development (CBD) is growing in the software engineering community and it has been successfully applied in many engineering domains such as office applications and in web-based distributed applications. Recently, the need of CBD is growing also in other domains related to dependable and embedded systems, namely, in the control engineering domain. However, the widely used commercial component technologies are unable to provide solutions to the requirements of embedded systems as they require too much resources and they do not provide methods and tools for developing predictable and analyzable embedded systems. There is a need for new component-based technologies appropriate to development of embedded systems. In this paper we briefly present a component-based development framework called SAVEComp. SAVEComp is developed for safety-critical real-time systems. One of the main characteristics of SAVEComp is syntactic and semantic simplicity which enables a high analyzability of properties important for embedded systems. We discuss how SAVEComp is able to provide an efficient support for designing and implementing embedded control systems by mainly focusing on simplicity and analyzability of functional requirements and of real-time and dependability quality attributes. In particular we discuss the typical solutions of control systems in which feedback loops are used and which significantly complicate the design process. We provide a solution for increasing design abstraction level and still being able to reason about system properties using SAVEComp approach. Finally, we discuss an extension of SAVEComp with dynamic run-time property checking by utilizing run-time spare capacity that is normally induced by real-time analysis.

Building a distributed system from third-party components introduces a set of problems, mainly related to compatibility and communication. Our approach to solve these problems is to build an adaptor which forces the system to exhibit only a set of safe or desired behaviors. By exploiting an abstract and partial specification of the global behavior that must be enforced, we automatically build a centralized adaptor. It mediates the interaction among components by both performing the specified behavior and, simultaneously, avoiding possible deadlocks. However in a distributed environment it is not always possible or convenient to insert a centralized adaptor. In contrast, building a distributed adaptor might increase the applicability of the approach in a real-scale context. In this paper we show how it is possible to automatically generate a distributed adaptor by exploiting an approach to the definition of distributed IDS (Intrusion Detection Systems) filters developed by us to increase security measures in component based systems. Firstly, by taking into account a high level specification of the global behavior that must be enforced, we synthesize a behavioral model of a centralized adaptor that allows the composed system to only exhibit the specified behavior and, simultaneously, avoid possible unspecified deadlocks. This model represents a lower level specification of the global behavior that is enforced by the adaptor. Secondly, by taking into account the synthesized adaptor model, we generate a set of component filters that validate the centralized adaptor behavior by simply looking at local information. In this way we address the problem of mechanically generating correct and distributed adaptors for real-scale component-based systems.

Correct assembly of software components is an important issue in Component Based Software Engineering. Composing a system from reusable components often introduces a set of problems related to communication and compatibility. In particular, one of the main problems in component assembly is that components may have incompatible interaction behavior. In this paper, we address this problem using an architecture-based approach that can detect integration mismatches, and semi-automatically synthesize a suitable adaptor, or glue code, to bridge them.

Many software projects are based on the integration of independently designed software components that are acquired on the market rather than developed within the project itself. Sometimes interoperability and composition mechanisms provided by component based integration frameworks cannot solve the problem of binary component integration in an automatic way. Notably, in the context of component based concurrent systems, the binary component integration may cause deadlocks within the system. In this paper we present a technique to allow connectors synthesis for deadlock-free component based architectures [2] in a real scale context, namely in the context of COM/DCOM applications. This technique is based on an architectural, connector-based approach which consists of synthesizing a COM/DCOM connector as a COM/DCOM server that can route requests of the clients through a deadlock free policy. This work also provides guide lines to implement an automatic tool that derives the implementation of routing dead-lock-free policy within the connector from the dynamic behavior specification of the COM components. It is then possible to avoid the deadlock by using COM composition mechanisms to insert the synthesized connector within the system while letting the system COM servers unimodified. We present a sucessful application of this technique on the (COM version of the) problem known as "The dining philosophers". Depending on the type of deadlock we have a strategy that automatically operates on the connector part of the system architecture in order to obtain a suitably equivalent version of the system which is deadlock-free.