It was common that software vendors sell licenses to their clients to use software products, such as Enterprise Resource Planning, which are deployed as a monolithic entity on clients’ premises. Moreover, many clients, especially big organizations, often require software products to be customized for their specific needs before deployment on premises. However, as software vendors are migrating their monolithic software products to Cloud-native Software-as-a-Service (SaaS), they face two big challenges that this paper aims at addressing: (1) How to migrate their exclusive monoliths to multi-tenant Cloud-native SaaS; and (2) How to enable tenant-specific customizations for multi-tenant Cloud-native SaaS. This paper suggests an approach for migrating monoliths to microservice-based Cloud-native SaaS, providing customers with a flexible customization opportunity, while taking advantage of the economies of scale that the Cloud and multi-tenancy provide. We develop two proofs-of-concept to demonstrate our approach on migrating a reference application of Microsoft called SportStore to a customizable SaaS as well as customizing another Microsoft’s microservices reference application called eShopOnContainers. We have shown not only the migration to microservices but also how to introduce the necessary infrastructure to support the new services and enable tenant-specific customization. Our customization-driven migration approach can guide a monolith to become SaaS having (synchronous and asynchronous) customization power for multi-tenant SaaS. Furthermore, our event-based customization approach can reduce the number of API calls to the main product while enabling different tenant-specific customization services for real-world scenarios.

It was common that software vendors sell licenses to their clients to use software products, such as Enterprise Resource Planning, which are deployed as a monolithic entity on clients’ premises. Moreover, many clients, especially big organizations, often require software products to be customized for their specific needs before deployment on premises. While software vendors are trying to migrate their monolithic software products to Cloud-native Software-as-a-Service (SaaS), they face two big challenges that this paper aims at addressing: 1) How to migrate their exclusive monoliths to multi-tenant Cloud-native SaaS; and 2) How to enable tenant-specific customization for multi-tenant Cloud-native SaaS. This paper suggests an approach for migrating monoliths to microservice-based Cloud-native SaaS, providing customers with a flexible customization opportunity, while taking advantage of the economies of scale that the Cloud and multi-tenancy provide. Our approach shows not only the migration to microservices but also how to introduce the necessary infrastructure to support the new services and enable tenant-specific customization. We illustrate the application of our approach on migrating a reference application of Microsoft called SportStore.

Enterprise applications are migrating to cloud as mutli-tenant SaaS. To empower businesses with highly customizable SaaS, software vendors need a novel approach for customizing SaaS in mutli-tenant context that still benefits from moving to cloud. In this initial industrial experience report, we present our design and experimental findings towards a novel and cloud-native architecture of customizing multi-tenant SaaS by microservices. The report clarifies the key concepts related to the problem of multi-tenant customization, nd describes a design with a reference architecture and high-level principles. An experimental use case to customize an open source web-based shopping application demonstrates that a microservice-based approach is feasible to meet the general customization requirements, and achieves a balance between isolation, assimilation and economy of scale.

Modern software systems interact with multiple 3rd party dependencies such as the OS file system, libraries, databases or remote services. To verify these interactions, developers write so-called "integration tests" that exercise the software within a specific environment. These tests are not only difficult to write as their environment is complicated, but they are also brittle because changes outside the code (i.e., in the environment) might make them fail unexpectedly. Integration tests are thus underused whereas they could help find many more issues. We hence propose CAMP, a tool that amplifies an existing integration test by exploring variations of the given environment. The tests that CAMP generates alter the services orchestration, the software stacks, the individual components' configuration or any combination thereof. We used CAMP to amplify tests from the Sphinx and Atom open-source projects, and in both cases, we were able to spot undocumented issues related to incompatible environments.

Enterprise software vendors often need to support their customer companies to customize the enterprise software products deployed on-premises of customers. But when software vendors are migrating their products to cloud-based Software-as-a-Service (SaaS), deep customization that used to be done on-premises is not applicable to the cloud-based multi-tenant context in which all tenants share the same SaaS. Enabling tenant-specific customization in cloud-based multi-tenant SaaS requires a novel approach. This paper proposes a Microservices-based non-intrusive Customization framework for multi-tenant Cloud-based SaaS, called MiSC-Cloud. Non-intrusive deep customization means that the microservices for customization of each tenant are isolated from the main software product and other microservices for customization of other tenants. MiSC-Cloud makes deep customization possible via authorized API calls through API gateways to the APIs of the customization microservices and the APIs of the main software product. We have implemented a proof-of-concept of our approach to enable non-intrusive deep customization of an open-source cloud native reference application of Microsoft called eShopOnContainers. Based on this work, we provide some lessons learned and directions for future work.

While the number of cloud solutions is continuously increasing, the development and operation of large-scale and distributed cloud applications are still challenging. A major challenge is the lack of interoperability between the existing cloud solutions, which increases the complexity of maintaining and evolving complex applications potentially deployed across multiple cloud infrastructures and platforms. In this article, we show how the Cloud Modelling Framework leverages model-driven engineering and supports the DevOps ideas to tame this complexity by providing: (i) a domain-specific language for specifying the provisioning and deployment of multi-cloud applications, and (ii) a models@run-time environment for their continuous provisioning, deployment, and adaptation.

A models@runtime environment keeps a model in synchrony with a running system, this way a reasoning engine adapts the system by modifying this model. Existing models@runtime environments typically fail to let the user control what concepts form the model nor how the model is synchronised with the running system. This is yet mandatory in uncertain environments that are open, dynamic and heterogeneous. In this position paper we evolve the classical models@runtime architectural pattern to address this issue, together with some initial implementation results.

Mixed-Criticality Systems (MCS) reconcile safety-critical requirements with multi-core architectures, by offering spatial and temporal isolation while preserving other extrafunctional properties such as optimised energy consumption or minimised latencies. MCS designers struggle to manually balance the offered functionalities with pertinent implementation choices in order to ensure that the system eventually meets all constraints. Existing attempts to further automate this process focus on specific concerns, and fail to account for variation in system functionalities. Our contribution is to integrate product-lines that capture functional variations with evolutionary optimisation to explore possible implementations and their impact on extra functional properties. Our solution is a model-driven process (and a tool prototype) to automatically select functionally different products that balance well the various concerns of interest. We illustrate how this process applies to the construction of wind turbines. Moving toward product-lines eventually contributes to reduce high development costs and the long time to market associated with MCS.

Product derivation is a building process of products from selected features in software product lines (SPLs). Realisation paves the way for automatic product derivation. A realisation defines a mapping between abstract features in a feature tree and their implementation artefacts in a model, and therefore governs the derivation of a new product. We experience that a realisation is not always straightforward and robust against modifications in the model. In the paper, we introduce an approach to build robust realisations. It consists of automated planning techniques and a layered architecture to yield a product. We demonstrate how our approach can leverage modern means of software design, development and validation. We evaluate the approach on a use-case provided by an industry partner and compare our technique to the existing realisation layer in the Base Variability Resolution (BVR) language.

We introduce a novel concept of ``architecture diversity'' for adaptive systems and posit that increased diversity has an inverse correlation with adaptation costs. We propose an index to quantify diversity and a static method to estimate the adaptation cost, and conduct an initial experiment on an exemplar cloud-based system which reveals the posited correlation.

Abstract: Design of a system architecture normally refers to a pre-defined goal. We consider the goal as the desired (functional or non-functional) aspect that is achieved by providing functionalities or mechanisms that support it. For example, a security goal is supported by a set of security mechanisms. However, there are often several ways towards (partially or completely) achieving a goal, which we refer to as design alternatives. Each design alternative is composed of a subset of the mechanisms needed. Some mechanisms are more important than others, and it is not obvious to what degree the different design alternatives fulfill the goal. It can moreover often be difficult to see what combinations of the design alternatives would result in maximum coverage of the goal. We propose an approach to modeling and analysis of the goals of a system. The approach supports specification of the goal, specification of the design alternatives, a quantification of the degree of fulfillment, as well as a quantification of the degree of overlap with respect to the goal fulfillment across design alternatives. We also propose a visual representation of the degrees of fulfillment and the degrees of overlap. We have evaluated the approach on a case study, and the initial results indicate its feasibility. This paper presents the approach and the evaluation results. It also summarizes experiences and suggestions for further improvements. 1

The Base Variability Resolution (BVR) is a modern language to build software product lines (SPL). The language incorporates advanced concepts for feature modeling, reuse and realization of components in SPL. The BVR bundle implements and supports the language. The tool covers design, implementation and quality assurance to close the development cycle. The bundle enables feature modeling, resolution, realization and derivation of products, their testing and analysis. We integrate the SPLCA additions to provide the state of the art algorithms for analysis. The project is open-source and available for practitioners. The tool consists of Eclipse plug-ins which work seamlessly together as well as separate stand-alone components. We describe how the tool collaboration contributes to variability modeling. In addition, we present how the bundle applies well-known design patterns, principals to achieve synergy between components.

Scalability and elasticity are key capabilities to tackle the variable workload of an application. Cloud elasticity offers opportunities to manage dynamically the underlying resources of an application and improve its scalability. However, managing scalability of cloud-based systems might lead to a management overhead. Self-adaptive systems are a well-known approach to tame this complexity. In this position paper, we propose an approach for the continuous design and management of scalability in multi-cloud systems. Our approach is based on a three-layer architecture and relies on two existing frameworks, namely ScaleDL and CloudML

In the landscape of cloud computing, the competition between providers has led to an ever growing number of cloud solutions offered to consumers. The ability to run and manage multi-cloud systems (i.e., applications on multiple clouds) allows exploiting the peculiarities of each cloud solution and hence optimising the performance, availability, and cost of the applications. However, these cloud solutions are typically heterogeneous and the provided features are often incompatible. This diversity hinders the proper exploitation of the full potential of cloud computing, since it prevents interoperability and promotes vendor lock-in, as well as it increases the complexity of development and administration of multi-cloud systems. This problem needs to be addressed promptly. In this paper, we provide a classification of the state-of-the-art of cloud solutions, and argue for the need for model-driven engineering techniques and methods facilitating the specification of provisioning, deployment, monitoring, and adaptation concerns of multi-cloud systems at design-time and their enactment at run-time.

Modern software systems need to be continuously available under varying conditions. Their ability to dynamically adapt to their execution context is thus increasingly seen as a key to their success. Recently, many approaches were proposed to design and support the execution of Dynamically Adaptive Systems (DAS). However, the ability of a DAS to evolve is limited to the addition, update or removal of adaptation rules or reconfiguration scripts. These artifacts are very specific to the control loop managing such a DAS and runtime evolution of the DAS requirements may affect other parts of the DAS. In this paper, we argue to evolve all parts of the loop. We suggest leveraging recent advances in model-driven techniques to offer an approach that supports the evolution of both systems and their adaptation capabilities. The basic idea is to consider the control loop itself as an adaptive system.

Runtime models represent the dynamic data of running systems, and enable developers to manipulate the data in an abstract, model-based way. This paper presents [email protected], a tool that help realize runtime models on a wide class of systems. Receiving a meta-model specifying the target system's data type and an API description specifying how to manipulate the data, [email protected] automatically generates the synchronizer to maintain the runtime model for this system.

With the increasing maturity of model-driven tools and methods, new model-based analysis methods are developed to support specific stakeholder concerns during software lifecycle. This multiplication of models and their related analysis tools calls for solution addressing the integration of MOF-based analysis methods. Current research works on integration of analysis methods have already addressed the extraction of the needed input data as well as the control and the integration of the tools supporting the analysis execution. However, little attention has been paid to the integration of analysis results back into initial model. We propose a MOF-based framework enabling the integration of analysis results that a) defines a meta-model capturing the integration requirements, b) provides a MOF meta-model extension mechanism with support for upward compatibility; and c) automatically generates a model transformation for model integration. We illustrate the use of our framework by integrating a reliability analysis methods and a fault tolerant reconfiguration method on the ABC/ADL Software Architecture. We applied the resulting analysis composition onto the ECPerf JEE system.

Dynamic reconfiguration support in application servers is a solution to meet the demands for flexible and adaptive component-based applications. However, when an application is reconfigured, its fault-tolerant mechanism should be reconfigured either. This is one of the crucial problems we have to solve before a fault-tolerant application is dynamically reconfigured at runtime. This paper proposes a fault-tolerant sandbox to support the reconfigurable fault-tolerant mechanisms on application servers. We present how the sandbox integrates multiple error detection and recovery mechanisms, and how to reconfigure these mechanisms at runtime, especially for coordinated recovery mechanisms. We implement a prototype and perform a set of controlled experiments to demonstrate the sandbox’s capabilities.

In a highly dynamic environment, software systems requires a capacity of self-adaptation to fit the environment and the user needs evolution, which increases the software architecture complexity. Despite most current execution platforms include some facilities for handling dynamic adaptation, current design methodologies do not address this issue. One of the requirement for such a design process is to describe adaptation policies in a composable and qualitative fashion in order to cope with complexity. This paper introduces an approach for describing adaptation policies in a qualitative way while keeping the compositionality of adaptation policies. The basic example of a Web server is used to illustrate how to specify and to compose two adaptations policies which handle respectively the use of a cache and the deployment of new data sources.