Abstract Microservice developers increasingly use resiliency patterns such as Retry and Circuit Breaker to cope with remote services that are likely to fail. However, there is still little research on how the invocation delays typically introduced by those resiliency patterns may impact application performance under varying workloads and failure scenarios. This article presents a novel approach and benchmark tool for experimentally evaluating the performance impact of existing resiliency patterns in a controlled setting. The main novelty of this approach resides in the ability to declaratively specify and automatically generate multiple testing scenarios involving different resiliency patterns, which one can implement using any programming language and resilience library. The article illustrates the benefits of the proposed approach and tool by reporting on an experimental study of the performance impact of the Retry and Circuit Breaker resiliency patterns in two mainstream programming languages (C# and Java) using two popular resilience libraries (Polly and Resilience4j), under multiple service workloads and failure rates. Our results show that, under low to moderate failure rates, both resiliency patterns effectively reduce the load over the application's target service with barely any impact on the application's performance. However, as the failure rate increases, both patterns significantly degrade the application's performance, with their effect varying depending on the service's workload and the patterns' programming language and resilience library.

Abstract Several organizations need to address the challenge to migrate current traditional monolithic applications in production to microservices, preferably, without having to schedule maintenances to take the application offline. This article presents an approach for migrating to microservices with almost zero downtime and minimal changes in the monolithic code. The approach is based on the concepts of aspect‐oriented programming (AOP) and reflection to enable to intercept calls inside the monolith and transform them into service requests invoking the newly built microservices using the concept of around advices. The aspects do the “dirty work” of decoupling what will be refactored and which service to call and practically “zero” code changes need to be done in the original monolithic code. This enables one key novel contribution of our migration approach which is the ability to revert code and data changes without having to take the system offline. Two applications are used as proofs of concept to demonstrate that the proposed approach enables to go “forward” or “backward” among different versions of the application with minimal code or data changes. An evaluation performed in the cloud demonstrates that this work does not introduce significant performance or cost overhead when compared to the current state of the art and to the original monolith.

Microservice application developers try to mitigate the impact of partial outages typically by implementing service-to-service interactions that use well-known resiliency patterns, such as Retry, Fail Fast, and Circuit Breaker. However, those resiliency patterns-as well as their available open-source implementations-are often documented informally, leaving it up to application developers to figure out when and how to use those patterns in the context of a particular microservice application. In this paper, we take a first step towards improving on this situation by introducing a model checking-based approach in which we use the PRISM probabilistic model checker to analyze the behavior of the Retry and Circuit Breaker resiliency patterns as continuous-time Markov chains (CTMC). This approach has enabled us to quantify the impact of applying each resiliency pattern on multiple quality attributes, as well as to determine how to best tune their parameters to deal with varying service availability conditions, in the context of a simple client-service interaction scenario.

Summary Cloud computing is an emerging computing paradigm that is changing software engineering. It offers scalable virtual compute resources at low prices, thus attracting many software developers interested in reducing their infrastructure and operational costs. Even though acquiring and using cloud solutions can be simple, a common difficulty developers face is how to best configure their applications at the architectural level, given a myriad of cloud services and resource types available, specially when considering different attributes such as cost, scalability, and performance. An inappropriate architectural decision can lead to a significant cost increase or a deployment option that does not meet the minimum required performance. This paper focuses on the problem of finding the best cloud deployment options for a given application that meet a given set of well‐known nonfunctional requirements. To address this problem, the paper presents Cloud Application Architecture Appraiser (CA3), a multicriteria optimization approach and tool that relies on nonfunctional requirements as key drivers for assessing and selecting the best architectural options for deploying applications in the cloud. Results from the assessment of a real web application (WordPress), deployed using several different architectural options in a popular cloud provider (Amazon), are also presented to illustrate the use and benefits of the proposed method and tool.

Summary As the number of infrastructure‐as‐a‐service (IaaS) cloud offers in the market increases, selecting an appropriate configuration of cloud resources for a given application becomes a non‐trivial task even for experienced developers. Because cloud resources are relatively cheap, usually charged by the hour, developers could systematically evaluate the performance of their application using different resource types from different cloud providers, thus allowing them to accurately identify the best providers and resource types for their application. However, conducting systematic performance tests in multiple IaaS clouds may require a significant amount of planning and configuration effort from application developers. This paper presents Cloud Crawler, a declarative environment for specifying and conducting application performance tests in IaaS clouds. The environment includes a novel declarative domain‐specific language, Crawl, by means of which cloud users can describe, at a high abstraction level, a large variety of performance evaluation scenarios for a given application, and a scenario execution engine, Crawler, which automatically configures, executes, and collects the results of the scenarios described in Crawl. The paper also reports on how Cloud Crawler has been successfully used to systematically test the performance of two open‐source web applications in public IaaS clouds. Copyright © 2016 John Wiley & Sons, Ltd.

Summary Many organizations migrate on‐premise software applications to the cloud. However, current coarse‐grained cloud migration solutions have made such migrations a non transparent task, an endeavor based on trial‐and‐error. This paper presents Variability‐based, Pattern‐driven Architecture Migration (V‐PAM), a migration method based on (i) a catalogue of fine‐grained service‐based cloud architecture migration patterns that target multi‐cloud, (ii) a situational migration process framework to guide pattern selection and composition, and (iii) a variability model to structure system migration into a coherent framework. The proposed migration patterns are based on empirical evidence from several migration projects, best practice for cloud architectures and a systematic literature review of existing research. Variability‐based, Pattern‐driven Architecture Migration allows an organization to (i) select appropriate migration patterns, (ii) compose them to define a migration plan, and (iii) extend them based on the identification of new patterns in new contexts. The patterns are at the core of our solution, embedded into a process model, with their selection governed by a variability model. Copyright © 2016 John Wiley & Sons, Ltd.

Provisioning cloud applications usually is a complex task as it involves the deployment and configuration of several components (e.g., load balancer, application server, database) and cloud services (computing, storage, CDN, etc.) also known as application blueprints or topologies. The Topology and Orchestration Specification for Cloud Applications (TOSCA) is a recent standard that has focused on standardizing the way cloud applications are structured and managed to favor interoperability. In this paper we describe an approach that facilitates the evaluation of different application topologies by enabling cloud users to easily provision and evaluate different TOSCA topology options based on performance and cost metrics. We show the technical feasibility of the approach based on a case study with the WordPress blogging application where various topologies were automatically provisioned and evaluated in order to gain insights into the best (w.r.t. performance) options.

This work presents a novel approach to support application capacity planning in infrastructure-as-a-service (IaaS) clouds. The approach, called performance inference, relies on the assumption that it is possible to establish a capacity relation between different resource configurations offered by a given IaaS provider, enabling one to infer an application's performance under certain resource configurations and workloads, based upon the application's actual performance as observed for other related resource configurations and workloads. Preliminary evaluation results, obtained from testing the performance of a well-known blogging application (Word Press) in a public IaaS cloud (Amazon EC2), show that the best performance inference strategies can significantly reduce (over 80%) the total number of application deployment scenarios that need to be actually tested in the cloud, with a high (over 98%) inference accuracy.

One of the main challenges faced by users of infrastructure-as-a-service (IaaS) clouds is the difficulty to adequately estimate the virtual resources necessary for their applications. Although many cloud providers offer programatic ways to rapidly acquire and release resources, it is important that users have a prior understanding of the impact that each virtual resource type offered by the provider may impose on application performance. This paper presents Cloud Crawler, a new declarative environment aimed at supporting users in describing and automatically executing application performance tests in IaaS clouds. To this end, the environment provides a novel declarative domain-specific language, called Crawl, which supports the description of a variety of performance evaluation scenarios in multiple IaaS clouds, and an extensible Java-based cloud execution engine, called Crawler, which automatically configures, executes and collects the results of each performance evaluation scenario described in Crawl. To illustrate Cloud Crawler's potential benefits, the paper reports on an experimental evaluation of a social network application in two public IaaS cloud providers, in which the proposed environment has successfully been used to investigate the application performance for different virtual machine configurations and under different demand levels.

Cloud computing is becoming mainstream in software development, with many organizations now considering migrating their applications to the cloud. However, the task of deploying Java Enterprise Edition (JEE) applications in infrastructure-as-a-service (IaaS) clouds is generally daunting due to a number of manual steps necessary to configure all application components as a set of virtual machine images. This work presents a tool, TREXCLOUD, which supports the task of deploying a fully functional Java Enterprise application in IaaS clouds with a few clicks. TREX Cloud enables users to easily upload a set of files that contain the application components (e.g.,. war files, database back up, context files) so that the tool automatically deploys and configures the whole application stack in an IaaS provider selected by the user. An empirical study shows how TREXCLOUD enables users, independently of their level of expertise, to quickly deploy a complete JEE application in the Amazon cloud when compared to two different approaches: Amazon EC2 dashboard and Amazon Elastic Beanstalk.

One of the main challenges faced by current users of infrastructure-as-a-service (IaaS) clouds are the difficulties to estimate cloud resources according to their application needs. Even though cloud platforms are elastic and provide fast means to acquire or release resources it is important to understand the best ways to do that considering a diversity of providers with many different resource types and prices. This work reports on an experimental investigation conducted on a popular cloud benchmark based on a social network application running on top of the Amazon EC2 cloud. Our experiments aim at finding cost-effective ways to select the different EC2 resource types and deployment configurations based on the demand imposed to the application (measured in number of simultaneous users) and identify the configuration that gives the best return in terms of its cost per user.

This paper presents an analysis of the performance impact of two generic group communication APIs, namely Hedera and jGCS. The analysis was carried out in a four-node cluster by comparing the performance of different configurations of two well-known group communication middleware systems (i.e., JGroups and Spread), under different message sizes, both in standalone mode and when used as plug-ins for the two generic APIs. The results show that there are significant variations in the performance overhead imposed by each generic API on both JGroups and Spread, and that those differences are strongly related to variations in message size and the way each generic API is implemented. The paper also discusses whether it would be worth migrating from a standalone group communication implementation to a generic API.

Probabilistic models are useful in the analysis of system behaviour and non-functional properties. Reliable estimates and measurements of probabilities are needed to annotate behaviour models in order to generate accurate predictions. However, this may not be sufficient, and may still lead to inaccurate results when the system model does not properly reflect the probabilistic choices made by the environment. Thus, not only should the probabilities be accurate in properly reflecting reality, but also the model that is being used. In this paper we identify and illustrate this problem showing that it can lead to inaccuracies and both false positive and false negative property checks. We propose state refinement as a technique to mitigate this problem, and present a framework for iteratively improving the accuracy of a probabilistically annotated behaviour model.

The aspect-oriented programming (AOP) paradigm offers software developers with powerful modularization abstractions to help them explicitly separate design concerns at the source code level. However, the impact of AOP in the service-oriented architecture (SOA) paradigm has been dwarfed by the fact that existing AOP solutions are tightly coupled to a particular programming language, middleware system or execution platform. Clearly, this not only restricts the implementation choices available to application developers, but it also clashes with the heterogeneous and loosely coupled nature of SOA. This paper presents the Web Service Aspect Language (WSAL) that seamlessly integrates AOP and SOA concepts, thus avoiding the drawbacks of existing solutions. In WSAL, aspects themselves are freely specified, implemented and executed as loosely coupled web services. This characteristic allows WSAL aspects to be easily woven into the message flow exchanged between service consumers and service providers, in a way that is completely independent from any particular implementation technology. This paper also reports on the implementation and preliminary evaluation of a prototype aspect weaver for WSAL, which is based on an existing web intermediary technology.

This paper presents a novel programming model for explicitly separating parallelization and middleware-specific concerns in bag-of-tasks (BoT) grid applications. The model uses Java threads for application decomposition, and aspect-oriented programming to dynamically (and transparently) convert the application's thread objects into independent grid tasks, using the services of a specific grid middleware API. This paper also describes early experimental results showing the model's modularity gains and performance overhead, when applied to implement BoT grid applications using OurGrid.

Refactoring, i.e., the process of changing a software system to improve its internal quality and preserving its external behavior, is gaining increasing acceptance among software developers. Even though many refactoring tools are now available for a variety of programming languages, most of them are difficult to reuse, extend or even customize, mainly because they provide no uniform way of representing and manipulating source code information. This work presents a refactoring framework, called RefaX, which relies on open, XML-based source code models and processing standards to facilitate the development, customization and reuse of refactoring tools. In particular, RefaX makes it possible to develop refactoring tools that are independent of source code model, programming language and XML processing technology. The viability of the framework is illustrated through a refactoring prototype for Java.

Effective analysis and evolution of existing distributed software systems rely to great an extent on the ability to recognise implemented executable components, particularly their constituent modules. Traditionally, this information is obtained via manual examination of configuration files and the source code directory hierarchy. However both types of artifact are limited in distinguishing which modules are used exclusively by each executable component. This exclusivity distinction is important in that it helps to understand the components' unique functionalities and their potential runtime behaviour. This paper presents a module classification technique that can facilitate automatic recognition of executable component modules in a distributed system. In contrast to existing approaches, the technique explicitly distinguishes component exclusive modules from modules shared by multiple components. The paper illustrates the benefits of the technique by reporting on the results of a case study where it has been useful to (a) revealing component exclusive modules in the source code for the field distributed programming environment; and (b) investigating some aspects of an implicit-invocation model of field described elsewhere. Applications of the technique to other software engineering tasks, such as change impact analysis, reuse and restructuring, are also discussed.