34-filtered-by-abstract.bib

@Article{Laigner2021,
  author     = {Laigner, Rodrigo and Zhou, Yongluan and Salles, Marcos Antonio Vaz and Liu, Yijian and Kalinowski, Marcos},
  journal    = {Proc. VLDB Endow.},
  title      = {Data Management in Microservices: State of the Practice, Challenges, and Research Directions},
  year       = {2021},
  issn       = {2150-8097},
  month      = {sep},
  number     = {13},
  pages      = {3348–3361},
  volume     = {14},
  abstract   = {Microservices have become a popular architectural style for data-driven applications, given their ability to functionally decompose an application into small and autonomous services to achieve scalability, strong isolation, and specialization of database systems to the workloads and data formats of each service. Despite the accelerating industrial adoption of this architectural style, an investigation of the state of the practice and challenges practitioners face regarding data management in microservices is lacking. To bridge this gap, we conducted a systematic literature review of representative articles reporting the adoption of microservices, we analyzed a set of popular open-source microservice applications, and we conducted an online survey to cross-validate the findings of the previous steps with the perceptions and experiences of over 120 experienced practitioners and researchers.Through this process, we were able to categorize the state of practice of data management in microservices and observe several foundational challenges that cannot be solved by software engineering practices alone, but rather require system-level support to alleviate the burden imposed on practitioners. We discuss the shortcomings of state-of-the-art database systems regarding microservices and we conclude by devising a set of features for microservice-oriented database systems.},
  doi        = {10.14778/3484224.3484232},
  file       = {:Laigner2021 - Data Management in Microservices_ State of the Practice, Challenges, and Research Directions.pdf:PDF},
  issue_date = {September 2021},
  numpages   = {14},
  publisher  = {VLDB Endowment},
  url        = {https://doi.org/10.14778/3484224.3484232},
}

@InProceedings{Yuan2019,
  author    = {Yuan, Eric},
  booktitle = {Proceedings of the 2nd International Workshop on Establishing a Community-Wide Infrastructure for Architecture-Based Software Engineering},
  title     = {Architecture Interoperability and Repeatability with Microservices: An Industry Perspective},
  year      = {2019},
  address   = {Montreal, Quebec, Canada},
  pages     = {26–33},
  publisher = {IEEE Press},
  series    = {ECASE '19},
  abstract  = {Microservices, along with supporting technologies such as containers, have become a prevalent architecture approach for today's software systems, especially in enterprise environments. They represent the latest evolutionary step in the decades-old journey towards service- and component-based software architectures. Along with virtualization technologies, microservices have enabled the loose-coupling of both service interfaces (message passing) and service integration (form and fit). This paper attempts to explore the impact of microservices on software architecture interoperability and repeatability, based on our experiences in developing two microservice-based systems. Our central thesis is that, if we view software architecture as a set of principal design decisions, the microservices approach enable us to more elegantly separate these decisions from non-architectural, domain-specific ones, and thus make these decisions more interoperable, reusable, and repeatable across disparate problem domains. We therefore propose that a microservices based reference architecture (RA) and reference implementation (RI) be created for the community-wide infrastructure for software engineering and software architecture research, along with a set of detailed considerations.},
  doi       = {10.1109/ECASE.2019.00013},
  file      = {:Yuan2019 - Architecture Interoperability and Repeatability with Microservices_ an Industry Perspective.pdf:PDF},
  keywords  = {software architecture, DevOps, microservice, cloud computing},
  numpages  = {8},
}

@InProceedings{Avritzer2020a,
  author    = {Avritzer, Alberto},
  booktitle = {Companion of the ACM/SPEC International Conference on Performance Engineering},
  title     = {Automated Scalability Assessment in DevOps Environments},
  year      = {2020},
  address   = {New York, NY, USA},
  pages     = {10},
  publisher = {Association for Computing Machinery},
  series    = {ICPE '20},
  abstract  = {In this extended abstract, we provide an outline of the presentation planned for WOSP-C 2020. The goal of the presentation is to provide an overview of the challenges and approaches for automated scalability assessment in the context of DevOps and microservices. The focus of this presentation is on approaches that employ automated identification of performance problems because these approaches can leverage performance anti-pattern[5] detection technology. In addition, we envision extending the approach to recommend component refactoring. In our previous work[1,2] we have designed a methodology and associated tool support for the automated scalability assessment of micro-service architectures, which included the automation of all the steps required for scalability assessment. The presentation starts with an introduction to dependability, operational Profile Data, and DevOps. Specifically, we provide an overview of the state of the art in continuous performance monitoring technologies[4] that are used for obtaining operational profile data using APM tools. We then present an overview of selected approaches for production and performance testing based on the application monitoring tool (PPTAM) as introduced in [1,2]. The presentation concludes by outlining a vision for automated performance anti-pattern[5] detection. Specifically, we present the approach introduced for automated anti-pattern detection based on load testing results and profiling introduced in[6] and provide recommendations for future research.},
  doi       = {10.1145/3375555.3384936},
  file      = {:Avritzer2020a - Automated Scalability Assessment in DevOps Environments.pdf:PDF},
  isbn      = {9781450371094},
  location  = {Edmonton AB, Canada},
  numpages  = {1},
  url       = {https://doi.org/10.1145/3375555.3384936},
}

@InProceedings{Santos2021,
  author    = {Santos, Ana and Paula, Hugo},
  booktitle = {Proceedings of the 15th Brazilian Symposium on Software Components, Architectures, and Reuse},
  title     = {Microservice Decomposition and Evaluation Using Dependency Graph and Silhouette Coefficient},
  year      = {2021},
  address   = {New York, NY, USA},
  pages     = {51–60},
  publisher = {Association for Computing Machinery},
  series    = {SBCARS '21},
  abstract  = {The benefits provided by microservices architecture in some application scenarios are a motivating factor for organizations to migrate their monoliths to this architecture. Extracting microservices from existing monolithic code bases presents a key challenge in this context, and there is a lack of tools that automate not only the decomposition processes but also the evaluation of the resulting architecture. This work presents a new approach for microservice decomposition that analyzes source code of a monolithic application and, with the combined use of approaches in the literature, suggests parts to be extracted in microservices considering the artifacts: classes, methods and/or history of modifications. The quality of the microservices’ suggestions are assessed, quantitatively, through the silhouette coefficient, a quality metric used in clustering analysis, and the microservice granularity. A tool was developed to automate the process of microservice decomposition for Java repositories. As a result, it was observed that the tool generated clusters with satisfactory results and can be used as an auxiliary instrument by experts during the migration process from monolithic architecture to microservices.},
  doi       = {10.1145/3483899.3483908},
  file      = {:Santos2021 - Microservice Decomposition and Evaluation Using Dependency Graph and Silhouette Coefficient.pdf:PDF},
  isbn      = {9781450384193},
  keywords  = {monolithic application, microservices, decomposition},
  location  = {Joinville, Brazil},
  numpages  = {10},
  url       = {https://doi.org/10.1145/3483899.3483908},
}

@Article{Zdun2023,
  author     = {Zdun, Uwe and Queval, Pierre-Jean and Simhandl, Georg and Scandariato, Riccardo and Chakravarty, Somik and Jelic, Marjan and Jovanovic, Aleksandar},
  journal    = {ACM Trans. Softw. Eng. Methodol.},
  title      = {Microservice Security Metrics for Secure Communication, Identity Management, and Observability},
  year       = {2023},
  issn       = {1049-331X},
  month      = {feb},
  number     = {1},
  volume     = {32},
  abstract   = {Microservice architectures are increasingly being used to develop application systems. Despite many guidelines and best practices being published, architecting microservice systems for security is challenging. Reasons are the size and complexity of microservice systems, their polyglot nature, and the demand for the continuous evolution of these systems. In this context, to manually validate that security architecture tactics are employed as intended throughout the system is a time-consuming and error-prone task. In this article, we present an approach to avoid such manual validation before each continuous evolution step in a microservice system, which we demonstrate using three widely used categories of security tactics: secure communication, identity management, and observability. Our approach is based on a review of existing security guidelines, the gray literature, and the scientific literature, from which we derived Architectural Design Decisions (ADDs) with the found security tactics as decision options. In our approach, we propose novel detectors to detect these decision options automatically and formally defined metrics to measure the conformance of a system to the different options of the ADDs. We apply the approach to a case study data set of 10 open source microservice systems, plus another 20 variants of these systems, for which we manually inspected the source code for security tactics. We demonstrate and assess the validity and appropriateness of our metrics by performing an assessment of their conformance to the ADDs in our systems’ dataset through statistical methods.},
  address    = {New York, NY, USA},
  articleno  = {16},
  doi        = {10.1145/3532183},
  file       = {:Zdun2023 - Microservice Security Metrics for Secure Communication, Identity Management, and Observability (1).pdf:PDF},
  issue_date = {January 2023},
  keywords   = {microservice security, software architecture metrics, software architecture detectors, Microservice architecture},
  numpages   = {34},
  publisher  = {Association for Computing Machinery},
  url        = {https://doi.org/10.1145/3532183},
}

@InProceedings{Baarzi2021,
  author    = {Baarzi, Ataollah Fatahi and Kesidis, George},
  booktitle = {Proceedings of the ACM Symposium on Cloud Computing},
  title     = {SHOWAR: Right-Sizing And Efficient Scheduling of Microservices},
  year      = {2021},
  address   = {New York, NY, USA},
  pages     = {427–441},
  publisher = {Association for Computing Machinery},
  series    = {SoCC '21},
  abstract  = {Microservices architecture have been widely adopted in designing distributed cloud applications where the application is decoupled into multiple small components (i.e. "microservices"). One of the challenges in deploying microservices is finding the optimal amount of resources (i.e. size) and the number of instances (i.e. replicas) for each microservice in order to maintain a good performance as well as prevent resource wastage and under-utilization which is not cost-effective. This paper presents SHOWAR, a framework that configures the resources by determining the number of replicas (horizontal scaling) and the amount of CPU and Memory for each microservice (vertical scaling). For vertical scaling, SHOWAR uses empirical variance in the historical resource usage to find the optimal size and mitigate resource wastage. For horizontal scaling, SHOWAR uses basic ideas from control theory along with kernel level performance metrics. Additionally, once the size for each microservice is found, SHOWAR bridges the gap between optimal resource allocation and scheduling by generating affinity rules (i.e. hints) for the scheduler to further improve the performance. Our experiments, using a variety of microservice applications and real-world workloads, show that, compared to the state-of-the-art autoscaling and scheduling systems, SHOWAR on average improves the resource allocation by up to 22\% while improving the 99th percentile end-to-end user request latency by 20\%.},
  doi       = {10.1145/3472883.3486999},
  file      = {:Baarzi2021 - SHOWAR_ Right Sizing and Efficient Scheduling of Microservices.pdf:PDF},
  isbn      = {9781450386388},
  keywords  = {autoscaling, cloud computing, microservices},
  location  = {Seattle, WA, USA},
  numpages  = {15},
  url       = {https://doi.org/10.1145/3472883.3486999},
}

@InProceedings{Luo2021a,
  author    = {Luo, Shutian and Xu, Huanle and Lu, Chengzhi and Ye, Kejiang and Xu, Guoyao and Zhang, Liping and Ding, Yu and He, Jian and Xu, Chengzhong},
  booktitle = {Proceedings of the ACM Symposium on Cloud Computing},
  title     = {Characterizing Microservice Dependency and Performance: Alibaba Trace Analysis},
  year      = {2021},
  address   = {New York, NY, USA},
  pages     = {412–426},
  publisher = {Association for Computing Machinery},
  series    = {SoCC '21},
  abstract  = {Loosely-coupled and light-weight microservices running in containers are replacing monolithic applications gradually. Understanding the characteristics of microservices is critical to make good use of microservice architectures. However, there is no comprehensive study about microservice and its related systems in production environments so far. In this paper, we present a solid analysis of large-scale deployments of microservices at Alibaba clusters. Our study focuses on the characterization of microservice dependency as well as its runtime performance. We conduct an in-depth anatomy of microservice call graphs to quantify the difference between them and traditional DAGs of data-parallel jobs. In particular, we observe that microservice call graphs are heavy-tail distributed and their topology is similar to a tree and moreover, many microservices are hot-spots. We reveal three types of meaningful call dependency that can be utilized to optimize microservice designs. Our investigation on microservice runtime performance indicates most microservices are much more sensitive to CPU interference than memory interference. To synthesize more representative microservice traces, we build a mathematical model to simulate call graphs. Experimental results demonstrate our model can well preserve those graph properties observed from Alibaba traces.},
  doi       = {10.1145/3472883.3487003},
  file      = {:Luo2021a - Characterizing Microservice Dependency and Performance_ Alibaba Trace Analysis.pdf:PDF},
  isbn      = {9781450386388},
  location  = {Seattle, WA, USA},
  numpages  = {15},
  url       = {https://doi.org/10.1145/3472883.3487003},
}

@Article{Camilli2023,
  author     = {Camilli, Matteo and Colarusso, Carmine and Russo, Barbara and Zimeo, Eugenio},
  journal    = {ACM Trans. Softw. Eng. Methodol.},
  title      = {Actor-Driven Decomposition of Microservices through Multi-Level Scalability Assessment},
  year       = {2023},
  issn       = {1049-331X},
  month      = {jul},
  number     = {5},
  volume     = {32},
  abstract   = {The microservices architectural style has gained widespread acceptance. However, designing applications according to this style is still challenging. Common difficulties concern finding clear boundaries that guide decomposition while ensuring performance and scalability. With the aim of providing software architects and engineers with a systematic methodology, we introduce a novel actor-driven decomposition strategy to complement the domain-driven design and overcome some of its limitations by reaching a finer modularization yet enforcing performance and scalability improvements. The methodology uses a multi-level scalability assessment framework that supports decision-making over iterative steps. At each iteration, architecture alternatives are quantitatively evaluated at multiple granularity levels. The assessment helps architects to understand the extent to which architecture alternatives increase or decrease performance and scalability. We applied the methodology to drive further decomposition of the core microservices of a real data-intensive smart mobility application and an existing open-source benchmark in the e-commerce domain. The results of an in-depth evaluation show that the approach can effectively support engineers in (i) decomposing monoliths or coarse-grained microservices into more scalable microservices and (ii) comparing among alternative architectures to guide decision-making for their deployment in modern infrastructures that orchestrate lightweight virtualized execution units.},
  address    = {New York, NY, USA},
  articleno  = {117},
  doi        = {10.1145/3583563},
  file       = {:Camilli2023 - Actor Driven Decomposition of Microservices through Multi Level Scalability Assessment.pdf:PDF},
  issue_date = {September 2023},
  keywords   = {performance analysis, scalability assessment, architectural patterns, decomposition process, Microservices},
  numpages   = {46},
  publisher  = {Association for Computing Machinery},
  url        = {https://doi.org/10.1145/3583563},
}

@Article{Herbst2018,
  author     = {Herbst, Nikolas and Bauer, Andr\'{e} and Kounev, Samuel and Oikonomou, Giorgos and Eyk, Erwin Van and Kousiouris, George and Evangelinou, Athanasia and Krebs, Rouven and Brecht, Tim and Abad, Cristina L. and Iosup, Alexandru},
  journal    = {ACM Trans. Model. Perform. Eval. Comput. Syst.},
  title      = {Quantifying Cloud Performance and Dependability: Taxonomy, Metric Design, and Emerging Challenges},
  year       = {2018},
  issn       = {2376-3639},
  month      = {aug},
  number     = {4},
  volume     = {3},
  abstract   = {In only a decade, cloud computing has emerged from a pursuit for a service-driven information and communication technology (ICT), becoming a significant fraction of the ICT market. Responding to the growth of the market, many alternative cloud services and their underlying systems are currently vying for the attention of cloud users and providers. To make informed choices between competing cloud service providers, permit the cost-benefit analysis of cloud-based systems, and enable system DevOps to evaluate and tune the performance of these complex ecosystems, appropriate performance metrics, benchmarks, tools, and methodologies are necessary. This requires re-examining old system properties and considering new system properties, possibly leading to the re-design of classic benchmarking metrics such as expressing performance as throughput and latency (response time). In this work, we address these requirements by focusing on four system properties: (i) elasticity of the cloud service, to accommodate large variations in the amount of service requested, (ii) performance isolation between the tenants of shared cloud systems and resulting performance variability, (iii) availability of cloud services and systems, and (iv) the operational risk of running a production system in a cloud environment. Focusing on key metrics for each of these properties, we review the state-of-the-art, then select or propose new metrics together with measurement approaches. We see the presented metrics as a foundation toward upcoming, future industry-standard cloud benchmarks.},
  address    = {New York, NY, USA},
  articleno  = {19},
  doi        = {10.1145/3236332},
  file       = {:Herbst2018 - Quantifying Cloud Performance and Dependability_ Taxonomy, Metric Design, and Emerging Challenges.pdf:PDF},
  issue_date = {December 2018},
  keywords   = {Metrics, cloud, performance variability, performance isolation, elasticity, benchmarking, availability, operational risk},
  numpages   = {36},
  publisher  = {Association for Computing Machinery},
  url        = {https://doi.org/10.1145/3236332},
}

@Article{Willnecker2018,
  author     = {Willnecker, Felix and Krcmar, Helmut},
  journal    = {ACM Trans. Internet Technol.},
  title      = {Multi-Objective Optimization of Deployment Topologies for Distributed Applications},
  year       = {2018},
  issn       = {1533-5399},
  month      = {jan},
  number     = {2},
  volume     = {18},
  abstract   = {Modern applications are typically implemented as distributed systems comprising several components. Deciding where to deploy which component is a difficult task that today is usually assisted by logical topology recommendations. Choosing inefficient topologies allocates the wrong amount of resources, leads to unnecessary operation costs, or results in poor performance. Testing different topologies to find good solutions takes a lot of time and might delay productive operations. Therefore, this work introduces a software-based deployment topology optimization approach for distributed applications. We use an enhanced performance model generator that extracts models from operational monitoring data of running applications. The extracted model is used to simulate performance metrics (e.g., resource utilization, response times, throughput) and runtime costs of distributed applications. Subsequently, we introduce a deployment topology optimizer, which selects an optimized topology for a specified workload and considers on-premise, cloud, and hybrid topologies. The following three optimization goals are presented in this work: (i) minimum response time for an optimized user experience, (ii) approximate resource utilization around certain peaks, and (iii) minimum cost for running the application. To evaluate the approach, we use the SPECjEnterpriseNEXT industry benchmark as distributed application in an on-premise and in a cloud/on-premise hybrid environment. The evaluation demonstrates the accuracy of the simulation compared to the actual deployment by deploying an optimized topology and comparing measurements with simulation results.},
  address    = {New York, NY, USA},
  articleno  = {21},
  doi        = {10.1145/3106158},
  file       = {:Willnecker2018 - Multi Objective Optimization of Deployment Topologies for Distributed Applications.pdf:PDF},
  issue_date = {May 2018},
  keywords   = {performance model, performance model generation, Deployment topology optimzation, distributed enterprise applications, memory simulation},
  numpages   = {21},
  publisher  = {Association for Computing Machinery},
  url        = {https://doi.org/10.1145/3106158},
}

@InProceedings{Davatz2017,
  author    = {Davatz, Christian and Inzinger, Christian and Scheuner, Joel and Leitner, Philipp},
  booktitle = {Proceedings of the 17th IEEE/ACM International Symposium on Cluster, Cloud and Grid Computing},
  title     = {An Approach and Case Study of Cloud Instance Type Selection for Multi-Tier Web Applications},
  year      = {2017},
  address   = {Madrid, Spain},
  pages     = {534–543},
  publisher = {IEEE Press},
  series    = {CCGrid '17},
  abstract  = {A challenging problem for users of Infrastructure-as-a-Service (IaaS) clouds is selecting cloud providers, regions, and instance types cost-optimally for a given desired service level. Issues such as hardware heterogeneity, contention, and virtual machine (VM) placement can result in considerably differing performance across supposedly equivalent cloud resources. Existing research on cloud benchmarking helps, but often the focus is on providing low-level microbenchmarks (e.g., CPU or network speed), which are hard to map to concrete business metrics of enterprise cloud applications, such as request throughput of a multi-tier Web application. In this paper, we propose Okta, a general approach for fairly and comprehensively benchmarking the performance and cost of a multi-tier Web application hosted in an IaaS cloud. We exemplify our approach for a case study based on the two-tier AcmeAir application, which we evaluate for 11 real-life deployment configurations on Amazon EC2 and Google Compute Engine. Our results show that for this application, choosing compute-optimized instance types in the Web layer and small bursting instances for the database tier leads to the overall most cost-effective deployments. This result held true for both cloud providers. The least cost-effective configuration in our study provides only about 67\% of throughput per US dollar spent. Our case study can serve as a blueprint for future industrial or academic application benchmarking projects.},
  doi       = {10.1109/CCGRID.2017.12},
  file      = {:Davatz2017 - An Approach and Case Study of Cloud Instance Type Selection for Multi Tier Web Applications.pdf:PDF},
  isbn      = {9781509066100},
  numpages  = {10},
}

@InProceedings{Andrade2023,
  author    = {Andrade, \'{A}lan J\'{u}nior da Cruz and Veloso, Ednilson and Santos, Gleison},
  booktitle = {Proceedings of the XXII Brazilian Symposium on Software Quality},
  title     = {What We Know About Software Dependability in DevOps - A Tertiary Study},
  year      = {2023},
  address   = {New York, NY, USA},
  pages     = {178–187},
  publisher = {Association for Computing Machinery},
  series    = {SBQS '23},
  abstract  = {Background: DevOps is viewed as an alternative approach to achieving high-quality software products. Dependability is recognized as a crucial aspect of software product quality. Existing literature highlights the lack of established standards, models, or methods for evaluating product quality within the DevOps paradigm. This emphasizes the need for further research to investigate the impact of DevOps on software quality attributes, particularly in relation to dependability.Objective: Our objective is to evaluate the scope of research on dependability in DevOps and identify what is known about this context by relating DevOps practices with dependability attributes. Method: We conducted a tertiary study to enhance the understanding of dependability in the context of DevOps. Results: We found 13 secondary studies that address dependability in DevOps. Within these studies, we identified 16 DevOps practices that have an impact on dependability and 12 attributes that are affected by DevOps practices. Additionally, we identified 6 measures related to dependability in the context of DevOps. Among the DevOps practices, the most commonly reported ones that impact dependability are Automation Practices, including deployment, testing, and infrastructure automation, as well as Cloud Computing Implementation. Conclusions: The results show that DevOps practices contribute to improve software dependability, mainly due to the impacts of these practices on dependability attributes. However, even though the literature reports some measures related to dependability, there is still a gap in understanding how organizations can assess dependability in DevOps.},
  doi       = {10.1145/3629479.3629502},
  file      = {:Andrade2023 - What We Know about Software Dependability in DevOps a Tertiary Study.pdf:PDF},
  isbn      = {9798400707865},
  keywords  = {Dependability, Software Product Quality, DevOps},
  location  = {<conf-loc>, <city>Bras\'{\i}lia</city>, <country>Brazil</country>, </conf-loc>},
  numpages  = {10},
  url       = {https://doi.org/10.1145/3629479.3629502},
}

@Article{Duboc2022,
  author     = {Duboc, Leticia and Bahsoon, Rami and Alrebeish, Faisal and Mera-G\'{o}mez, Carlos and Nallur, Vivek and Kazman, Rick and Bianco, Philip and Babar, Ali and Buyya, Rajkumar},
  journal    = {ACM Trans. Auton. Adapt. Syst.},
  title      = {Systematic Scalability Modeling of QoS-Aware Dynamic Service Composition},
  year       = {2022},
  issn       = {1556-4665},
  month      = {nov},
  number     = {3–4},
  volume     = {16},
  abstract   = {In Dynamic Service Composition (DSC), an application can be dynamically composed using web services to achieve its functional and Quality of Services (QoS) goals. DSC is a relatively mature area of research that crosscuts autonomous and services computing. Complex autonomous and self-adaptive computing paradigms (e.g., multi-tenant cloud services, mobile/smart services, services discovery and composition in intelligent environments such as smart cities) have been leveraging DSC to dynamically and adaptively maintain the desired QoS, cost and to stabilize long-lived software systems. While DSC is fundamentally known to be an NP-hard problem, systematic attempts to analyze its scalability have been limited, if not absent, though such analysis is of a paramount importance for their effective, efficient, and stable operations.This article reports on a new application of goal-modeling, providing a systematic technique that can support DSC designers and architects in identifying DSC-relevant characteristics and metrics that can potentially affect the scalability goals of a system. The article then applies the technique to two different approaches for QoS-aware dynamic services composition, where the article describes two detailed exemplars that exemplify its application. The exemplars hope to provide researchers and practitioners with guidance and transferable knowledge in situations where the scalability analysis may not be straightforward. The contributions provide architects and designers for QoS-aware dynamic service composition with the fundamentals for assessing the scalability of their own solutions, along with goal models and a list of application domain characteristics and metrics that might be relevant to other solutions. Our experience has shown that the technique was able to identify in both exemplars application domain characteristics and metrics that had been overlooked in previous scalability analyses of these DSC, some of which indeed limited their scalability. It has also shown that the experiences and knowledge can be transferable: The first exemplar was used as an example to inform and ease the work of applying the technique in the second one, reducing the time to create the model, even for a non-expert.},
  address    = {New York, NY, USA},
  articleno  = {10},
  doi        = {10.1145/3529162},
  file       = {:Duboc2022 - Systematic Scalability Modeling of QoS Aware Dynamic Service Composition.pdf:PDF},
  issue_date = {December 2021},
  keywords   = {Scalability modelling, autonomous and adaptive systems, dynamic service composition},
  numpages   = {39},
  publisher  = {Association for Computing Machinery},
  url        = {https://doi.org/10.1145/3529162},
}

@Article{AlDebagy2020,
  author   = {Al-Debagy, O. and Martinek, P.},
  journal  = {Journal of Web Engineering},
  title    = {A Metrics Framework for Evaluating Microservices Architecture Designs},
  year     = {2020},
  issn     = {1544-5976},
  month    = {June},
  number   = {3–4},
  pages    = {341-370},
  volume   = {19},
  abstract = {Microservices are becoming a more popular software architecture among companies and developers. Therefore, there is a need to develop methods for quantifying the process of measuring the quality of microservices design. This paper has created a novel set of metrics for microservices architecture applications. The proposed metrics are the Service Granularity Metric “SGM”, the Lack of Cohesion Metric “LCOM”, and the Number of Operations “NOO”. The proposed metrics measure the granularity, cohesion, and complexity of individual microservices through analyzing the application programming interface “API”. Using these metrics, it is possible to evaluate the overall quality of the design of microservices applications. The proposed metrics were measured on 5 applications with different sizes and business cases. This research found that the value for the SGM metric needs to be between 0.2 and 0.6. Besides, the value of LCOM metric for a microservice needs to be between 0 and 0.8 with less than ten operations per microservice. These findings can be applied in the decomposition process of monolithic applications as well.},
  doi      = {10.13052/jwe1540-9589.19341},
  file     = {:AlDebagy2020 - A Metrics Framework for Evaluating Microservices Architecture Designs.pdf:PDF},
}

@InProceedings{Levin2020,
  author    = {Levin, Joshua and Benson, Theophilus A.},
  booktitle = {2020 IEEE 9th International Conference on Cloud Networking (CloudNet)},
  title     = {ViperProbe: Rethinking Microservice Observability with eBPF},
  year      = {2020},
  month     = {Nov},
  pages     = {1-8},
  abstract  = {Recent shifts to microservice-based architectures and the supporting servicemesh radically disrupt the landscape of performance-oriented management tasks. While the adoption of frameworks like Istio and Kubernetes ease the management and organization of such systems, they do not themselves provide strong observability. Microservice observability requires diverse, highly specialized, and often adaptive, metrics and algorithms to monitor both the health of individual services and the larger application. However, modern metrics collection frameworks are relatively static and rigid. We introduce ViperProbe, an eBPF-based microservices collection framework that provides (1) dynamic sampling and (2) collection of deep, diverse, and precise system metrics. Viper-Probe builds on the observation that the adoption of a common set of design patterns, e.g., servicemesh, enables offline analysis. By examining the performance profile of these patterns before deploying on production, ViperProbe can effectively reduce the set of collected metrics, thereby improving the efficiency and effectiveness of those metrics. To the best of our knowledge, ViperProbe is the first scalable eBPF-based dynamic and adaptive microservices metrics collection framework. Our results show ViperProbe has limited overhead, while significantly more effective for traditional management tasks, e.g., horizontal autoscaling.},
  doi       = {10.1109/CloudNet51028.2020.9335808},
  file      = {:Levin2020 - ViperProbe_ Rethinking Microservice Observability with EBPF.pdf:PDF},
}

@InProceedings{Perera2018,
  author    = {Perera, K. J. P. G. and Perera, I.},
  booktitle = {2018 IEEE/ACIS 17th International Conference on Computer and Information Science (ICIS)},
  title     = {TheArchitect: A Serverless-Microservices Based High-level Architecture Generation Tool},
  year      = {2018},
  month     = {June},
  pages     = {204-210},
  abstract  = {Software is ubiquitous in today's systems and business operations. Most importantly the architecture of a software system determines its quality and longevity, because the development work related to the software system will be carried out to be in line with its architecture design. Hence, it's highly important to structure the high-level software architecture accordingly to deliver the expected customer requirements while accounting for quality measures such as scalability, high availability and high performance. We propose TheArchitect, a serverless-microservices based high-level architecture generation tool, which will auto generate serverless-microservices based high-level architecture for a given business application, preserving the highlighted quality measures providing a tool based support for the software architect with respect to designing the high-level architecture. TheArchitect will provide any software developer to generate a proper architecture minimizing the involvement of an experienced software architect. Furthermore, the positives that microservices and serverless technologies has brought to the world of software engineering has made the software engineering community shift from the era of building large monolith applications containing overly complex designs, to microservices and serverless based technologies. Hence TheArchitect focuses on generating best fitted microservices and serverless based high-level architecture for a given application.},
  doi       = {10.1109/ICIS.2018.8466390},
  file      = {:Perera2018 - TheArchitect_ a Serverless Microservices Based High Level Architecture Generation Tool.pdf:PDF},
}

@InProceedings{Perera2018a,
  author    = {Perera, K. J. P. G. and Perera, I.},
  booktitle = {2018 IEEE International Systems Engineering Symposium (ISSE)},
  title     = {A Rule-based System for Automated Generation of Serverless-Microservices Architecture},
  year      = {2018},
  month     = {Oct},
  pages     = {1-8},
  abstract  = {Software being ubiquitous in today's systems and business operations, it's highly important to structure the high-level architecture of a software application accordingly to deliver the expected customer requirements while accounting for quality measures such as scalability, high availability and high performance. We propose The Architect, a rule-based system for serverless-microservices based high-level architecture generation. In the process of auto generating serverless-microservices high-level architecture, TheArchitect will preserve the highlighted quality measures. It will also provide a tool based support for the high-level architecture designing process of the software architect. Any software developer will be able to use TheArchitect to generate a proper architecture minimizing the involvement of a software architect. Furthermore, the positives of microservices and serverless technologies have made a significant impact on the software engineering community in terms of shifting from the era of building large monolith applications containing overly complex designs, to microservices and serverless based technologies. Hence The Architect focuses on generating best fitted microservices and serverless based high-level architecture for a given application.},
  doi       = {10.1109/SysEng.2018.8544423},
  file      = {:Perera2018a - A Rule Based System for Automated Generation of Serverless Microservices Architecture.pdf:PDF},
}

@InProceedings{Asik2017,
  author    = {Asik, Tugrul and Selcuk, Yunus Emre},
  booktitle = {2017 IEEE 15th International Conference on Software Engineering Research, Management and Applications (SERA)},
  title     = {Policy enforcement upon software based on microservice architecture},
  year      = {2017},
  month     = {June},
  pages     = {283-287},
  abstract  = {Microservice is an architectural style that has recently started gaining popularity to become a new architectural phenomenon. Microservice architecture provides new opportunities to deploy scalable, language free and dynamically adjustable applications. This type of applications consist of hundreds or more of service instances. So that, management, monitoring, refactoring and testing of applications are more complex than monolithic applications. Therefore, some metrics and policies for measuring the quality of an application which is based on microservice architecture is needed. Moreover, automated tools are needed to carry out those tasks and enforce those policies. This work represents such metrics and policies. Additionally, an automated tool is implemented for automatic analysis of those metrics and policies upon software.},
  doi       = {10.1109/SERA.2017.7965739},
  file      = {:Asik2017 - Policy Enforcement upon Software Based on Microservice Architecture.pdf:PDF},
}

@InProceedings{Selmadji2020,
  author    = {Selmadji, Anfel and Seriai, Abdelhak-Djamel and Bouziane, Hinde Lilia and Oumarou Mahamane, Rahina and Zaragoza, Pascal and Dony, Christophe},
  booktitle = {2020 IEEE International Conference on Software Architecture (ICSA)},
  title     = {From Monolithic Architecture Style to Microservice one Based on a Semi-Automatic Approach},
  year      = {2020},
  month     = {March},
  pages     = {157-168},
  abstract  = {Due to its tremendous advantages, microservice architectural style has become an essential element for the development of applications deployed on the cloud and for those adopting the DevOps practices. Nevertheless, while microservices can be used to develop new applications, there are monolithic ones, that are not well adapted neither to the cloud nor to DevOps. Migrating these applications towards microservices appears as a solution to adapt them to both. In this context, we propose an approach aiming to achieve this objective by focusing on the step of microservices identification. The proposed identification, in this paper, is based on an analysis of the relationships between source code elements, their relationships with the persistent data manipulated in this code and finally the knowledge, often partial, of the architect concerning the system to migrate. A function that measures the quality of a microservice based on its ability to provide consistent service and its interdependence with others microservice in the resulting architecture was defined. Moreover, the architect recommendations are used, when available, to guide the identification process. The conducted experiment shows the relevance of the obtained microservices by our approach.},
  doi       = {10.1109/ICSA47634.2020.00023},
  file      = {:Selmadji2020 - From Monolithic Architecture Style to Microservice One Based on a Semi Automatic Approach.pdf:PDF},
}

@InProceedings{Valdivia2019,
  author    = {Valdivia, José A. and Limón, Xavier and Cortes-Verdin, Karen},
  booktitle = {2019 7th International Conference in Software Engineering Research and Innovation (CONISOFT)},
  title     = {Quality attributes in patterns related to microservice architecture: a Systematic Literature Review},
  year      = {2019},
  month     = {Oct},
  pages     = {181-190},
  abstract  = {Microservices is an interesting option for those who want to migrate their systems to improve performance, maintainability, scalability, and interoperability. Microservice architecture is a collection of self-sufficient services working together to provide functionalities. Nowadays, there are many options to build microservices, some of them are lead by patterns. However, the mapping between quality attributes and patterns is not clear yet. This systematic literature review presents a microservice pattern collection, it describes their benefits and the association between patterns and quality attributes. Finally, some metrics of quality attributes are identified.},
  doi       = {10.1109/CONISOFT.2019.00034},
  file      = {:Valdivia2019 - Quality Attributes in Patterns Related to Microservice Architecture_ a Systematic Literature Review.pdf:PDF},
}

@InProceedings{Guaman2018,
  author    = {Guaman, Daniel and Yaguachi, Lady and Samanta, Cueva C. and Danilo, Jaramillo H. and Soto, Fernanda},
  booktitle = {2018 13th Iberian Conference on Information Systems and Technologies (CISTI)},
  title     = {Performance evaluation in the migration process from a monolithic application to microservices},
  year      = {2018},
  month     = {June},
  pages     = {1-8},
  abstract  = {Microservices are considered as a software architecture that allows the decomposition of a system, its components or its functionalities into a set of small services, which are implemented, deployed and managed independently. In this study, the models that allow migrating a Monolith to Microservices such as NGINX and IBM are analyzed. From these models, activities that allow such migration are carefully selected and identified. In order to implement and evaluate the activities proposed in those models, an application that initially does not have any structure at the design and coding level (using PHP programming language) is applied. Then, the application's coding language changes to Java and the classes and libraries are distributed into packages. Subsequently, as it is suggested in the models, services are identified and implemented using RESTful Web Services to finally implement the microservices using technologies such as Spring Boot, Eureka, and Zuul. In the migration process, the application under study is modified at the code and design level, including patterns such as Singleton, Façade, Strangler, Single Service per Host, Service Discovery, and API Gateway, which are used to evaluate performance as a quality attribute in each migration phase. In order to obtain the performance related metrics and to analyze the advantages and disadvantages of each migration phase, Apache JMeter as tool is used. This tool is set up to generate results regarding the use of resources such as CPU, memory, network, and database access. Finally, the results show scenarios of several concurrent users who access to consult records in the database that uses the aforementioned application in each migration phase.},
  doi       = {10.23919/CISTI.2018.8399148},
  file      = {:Guaman2018 - Performance Evaluation in the Migration Process from a Monolithic Application to Microservices.pdf:PDF},
}

@InProceedings{Choochotkaew2021,
  author    = {Choochotkaew, Sunyanan and Chiba, Tatsuhiro and Trent, Scott and Amaral, Marcelo},
  booktitle = {2021 IEEE 14th International Conference on Cloud Computing (CLOUD)},
  title     = {Run Wild: Resource Management System with Generalized Modeling for Microservices on Cloud},
  year      = {2021},
  month     = {Sep.},
  pages     = {609-618},
  abstract  = {Microservice architecture competes with the traditional monolithic design by offering benefits of agility, flexibility, reusability resilience, and ease of use. Nevertheless, due to the increase in internal communication complexity, care must be taken for resource-usage scaling in harmony with placement scheduling, and request balancing to prevent cascading performance degradation across microservices. We prototype Run Wild, a resource management system that controls all mechanisms in the microservice-deployment process covering scaling, scheduling, and balancing to optimize for desirable performance on the dynamic cloud driven by an automatic, united, and consistent deployment plan. In this paper, we also highlight the significance of co-location aware metrics on predicting the resource usage and computing the deployment plan. We conducted experiments with an actual cluster on the IBM Cloud platform. RunWild reduced the 90th percentile response time by 11% and increased average throughput by 10% with more than 30% lower resource usage for widely used autoscaling benchmarks on Kubernetes clusters.},
  doi       = {10.1109/CLOUD53861.2021.00079},
  file      = {:Choochotkaew2021 - Run Wild_ Resource Management System with Generalized Modeling for Microservices on Cloud.pdf:PDF},
  issn      = {2159-6190},
}

@InProceedings{Pulparambil2018,
  author    = {Pulparambil, Supriya and Baghdadi, Youcef and Al-Hamdani, Abdullah and Al-Badawi, Mohammed},
  booktitle = {2018 9th International Conference on Computing, Communication and Networking Technologies (ICCCNT)},
  title     = {Service Design Metrics to Predict IT-Based Drivers of Service Oriented Architecture Adoption},
  year      = {2018},
  month     = {July},
  pages     = {1-7},
  abstract  = {The key factors for deploying successful services is centered on the service design practices adopted by an enterprise. The design level information should be validated and measures are required to quantify the structural attributes. The metrics at this stage will support an early discovery of design flaws and help designers to predict the capabilities of service oriented architecture (SOA) adoption. In this work, we take a deeper look at how we can forecast the key SOA capabilities infrastructure efficiency and service reuse from the service designs modeled by SOA modeling language. The proposed approach defines metrics based on the structural and domain level similarity of service operations. The proposed metrics are analytically validated with respect to software engineering metrics properties. Moreover, a tool has been developed to automate the proposed approach and the results indicate that the metrics predict the SOA capabilities at the service design stage. This work can be further extended to predict the business based capabilities of SOA adoption such as flexibility and agility.},
  doi       = {10.1109/ICCCNT.2018.8494072},
  file      = {:Pulparambil2018 - Service Design Metrics to Predict IT Based Drivers of Service Oriented Architecture Adoption.pdf:PDF},
}

@InProceedings{Gamage2021,
  author    = {Gamage, Isuru Udara Piyadigama and Perera, Indika},
  booktitle = {2021 Moratuwa Engineering Research Conference (MERCon)},
  title     = {Using dependency graph and graph theory concepts to identify anti-patterns in a microservices system: A tool-based approach},
  year      = {2021},
  month     = {July},
  pages     = {699-704},
  abstract  = {Microservice architecture (MSA) based application developments are becoming the common trend in implementing large-scale applications. Unlike the traditional monolith applications, MSA applications are composed of many services hence there is an immense possibility of anti-patterns introduced into the system. To identify these design problems, a detailed analysis of the architecture needs to be performed. We see great potential for adopting graph concepts and algorithms in this regard. However, the few tools proposed by existing work to find anti-patterns that adopt graph concepts are not up to providing developers with adequate statistical information such as metrics along with visualization techniques or they are not fully automated. In this research, we present a tool-based solution for this problem which is capable of utilizing traced data of an MSA system to generate dependency graphs and thereby extract metrics using graph theory concepts and algorithms. We analyze a sample MSA system for anti-patterns with the tool. To verify the usability of the tool further, a group of developers also analyze an open-source system with the tool.},
  doi       = {10.1109/MERCon52712.2021.9525743},
  file      = {:Gamage2021 - Using Dependency Graph and Graph Theory Concepts to Identify Anti Patterns in a Microservices System_ a Tool Based Approach.pdf:PDF},
  issn      = {2691-364X},
}

@InProceedings{Wang2017a,
  author    = {Wang, Hanzhang and Kessentini, Marouane and Hassouna, Taghreed and Ouni, Ali},
  booktitle = {2017 IEEE International Conference on Web Services (ICWS)},
  title     = {On the Value of Quality of Service Attributes for Detecting Bad Design Practices},
  year      = {2017},
  month     = {June},
  pages     = {341-348},
  abstract  = {Service-Oriented Architectures (SOAs) successfully evolve over time to update existing exposed features to the users and fix possible bugs. This evolution process may have a negative impact on the design quality of Web services. Recent studies addressed the problem of Web service antipatterns detection (bad design practices). To the best of our knowledge, these studies focused only on the use of metrics extracted from the implementation details (source code) of the interface and the services. However, the quality of service (QoS) metrics, widely used to evaluate the overall performance, are never used in the context of Web service antipatterns detection. We start, in this work, from the hypothesis that these bad design practices may impact several QoS metrics such as the response time. Furthermore, the source code metrics of services may not be always available. Without the consideration of these QoS metrics, the current detection processes of antipatterns will still lack the integration of symptoms that could be extracted from the usage of services. In this paper, we propose an automated approach to generate Web service defect detection rules that consider not only the code/interface level metrics but also the quality of service attributes. Through multi-objective optimization, the proposed approach generates solutions (detection rules) that maximize the coverage of antipattern examples and minimize the coverage of well-designed service examples. An empirical validation is performed with eight different common types of Web design defects to evaluate our approach. We compared our results with three other state of the art techniques which are not using QoS metrics. The statistical analysis of the obtained results confirm that our approach outperforms other techniques and generates detection rules that are more meaningful from the services' user perspective.},
  doi       = {10.1109/ICWS.2017.126},
  file      = {:Wang2017a - On the Value of Quality of Service Attributes for Detecting Bad Design Practices.pdf:PDF},
}

@InProceedings{Bogner2018a,
  author    = {Bogner, Justus and Fritzsch, Jonas and Wagner, Stefan and Zimmermann, Alfred},
  booktitle = {2018 IEEE/ACM International Conference on Technical Debt (TechDebt)},
  title     = {Limiting Technical Debt with Maintainability Assurance – An Industry Survey on Used Techniques and Differences with Service- and Microservice-Based Systems},
  year      = {2018},
  month     = {May},
  pages     = {125-133},
  abstract  = {Maintainability assurance techniques are used to control this quality attribute and limit the accumulation of potentially unknown technical debt. Since the industry state of practice and especially the handling of Service-and Microservice-Based Systems in this regard are not well covered in scientific literature, we created a survey to gather evidence for a) used processes, tools, and metrics in the industry, b) maintainability-related treatment of systems based on service-orientation, and c) influences on developer satisfaction w.r.t. maintainability. 60 software professionals responded to our online questionnaire. The results indicate that using explicit and systematic techniques has benefits for maintainability. The more sophisticated the applied methods the more satisfied participants were with the maintainability of their software while no link to a hindrance in productivity could be established. Other important findings were the absence of architecture-level evolvability control mechanisms as well as a significant neglect of service-oriented particularities for quality assurance. The results suggest that industry has to improve its quality control in these regards to avoid problems with long-living service-based software systems.},
  file      = {:Bogner2018a - Limiting Technical Debt with Maintainability Assurance – an Industry Survey on Used Techniques and Differences with Service and Microservice Based Systems.pdf:PDF},
}

@InProceedings{Torkura2017,
  author    = {Torkura, Kennedy A. and Sukmana, Muhammad I.H. and Cheng, Feng and Meinel, Christoph},
  booktitle = {2017 IEEE International Conference on Smart Cloud (SmartCloud)},
  title     = {Leveraging Cloud Native Design Patterns for Security-as-a-Service Applications},
  year      = {2017},
  month     = {Nov},
  pages     = {90-97},
  abstract  = {This paper discusses a new approach for designing and deploying Security-as-a-Service (SecaaS) applications using cloud native design patterns. Current SecaaS approaches do not efficiently handle the increasing threats to computer systems and applications. For example, requests for security assessments drastically increase after a high-risk security vulnerability is disclosed. In such scenarios, SecaaS applications are unable to dynamically scale to serve requests. A root cause of this challenge is employment of architectures not specifically fitted to cloud environments. Cloud native design patterns resolve this challenge by enabling certain properties e.g. massive scalability and resiliency via the combination of microservice patterns and cloud-focused design patterns. However adopting these patterns is a complex process, during which several security issues are introduced. In this work, we investigate these security issues, we redesign and deploy a monolithic SecaaS application using cloud native design patterns while considering appropriate, layered security counter-measures i.e. at the application and cloud networking layer. Our prototype implementation out-performs traditional, monolithic applications with an average Scanner Time of 6 minutes, without compromising security. Our approach can be employed for designing secure, scalable and performant SecaaS applications that effectively handle unexpected increase in security assessment requests.},
  doi       = {10.1109/SmartCloud.2017.21},
  file      = {:Torkura2017 - Leveraging Cloud Native Design Patterns for Security As a Service Applications.pdf:PDF},
}

@InProceedings{Hecht2014,
  author    = {Hecht, Geoffrey and Jose-Scheidt, Benjamin and De Figueiredo, Clement and Moha, Naouel and Khomh, Foutse},
  booktitle = {2014 IEEE 6th International Conference on Cloud Computing Technology and Science},
  title     = {An Empirical Study of the Impact of Cloud Patterns on Quality of Service (QoS)},
  year      = {2014},
  month     = {Dec},
  pages     = {278-283},
  abstract  = {Cloud patterns are described as good solutions to recurring design problems in a cloud context. These patterns are often inherited from Service Oriented Architectures or Object Oriented Architectures where they are considered good practices. However, there is a lack of studies that assess the benefits of these patterns for cloud applications. In this paper, we conduct an empirical study on a Restful application deployed in the cloud, to investigate the individual and the combined impact of three cloud patterns (i.e., Local Database proxy, Local Sharding-Based Router and Priority Queue Patterns) on Quality of Service (QoS). We measure the QoS using the application's response time, average, and maximum number of requests processed per seconds. Results show that cloud patterns doesn't always improve the response time of an application. In the case of the Local Database proxy pattern, the choice of algorithm used to route requests has an impact on response time, as well as the average and maximum number of requests processed per second. Combinations of patterns can significantly affect the QoS of applications. Developers and software architects can make use of these results to guide their design decisions.},
  doi       = {10.1109/CloudCom.2014.141},
  file      = {:Hecht2014 - An Empirical Study of the Impact of Cloud Patterns on Quality of Service (QoS).pdf:PDF},
}

@InProceedings{Jack2023,
  author    = {Jack, Chang Hoong and Teck, See Kwee and Ming, Lim Tong and Hong, Ding Ying},
  booktitle = {2023 IEEE 8th International Conference On Software Engineering and Computer Systems (ICSECS)},
  title     = {An Overview Analysis of Authentication Mechanism in Microservices-Based Software Architecture: A Discussion Paper},
  year      = {2023},
  month     = {Aug},
  pages     = {1-6},
  abstract  = {Microservices-based software architecture promotes scalability and flexibility by breaking down a software application into smaller modules and making it more independent and loosely coupled services compared to monolith systems. However, securing microservices in a distributed nature has become one of the challenges. Authentication is one of the most critical components that should be focused in the microservices security measures. It helps to identify that only authenticated personnel and services can access sensitive information and secure the trust between microservices. This discussion paper aims to provide an overview analysis and extensive understanding on the authentication mechanism in microservices-based software architecture. In this study, we explore different authentication mechanisms including Mutual Transport Layer Security (mTLS), Token based authentication and API Gateway authentication. This study examines the strengths and limitations of different authentication mechanisms in microservices-based software architecture. It also emphasizes the importance of authentication and the need for having a well-designed authentication mechanism to ensure the integrity and security of microservices-based software architecture is crucial.},
  doi       = {10.1109/ICSECS58457.2023.10256409},
}

@InProceedings{Frank2022,
  author    = {Frank, Sebastian and Wagner, Lion and Hakamian, Alireza and Straesser, Martin and van Hoorn, André},
  booktitle = {2022 IEEE 22nd International Conference on Software Quality, Reliability and Security (QRS)},
  title     = {MiSim: A Simulator for Resilience Assessment of Microservice-Based Architectures},
  year      = {2022},
  month     = {Dec},
  pages     = {1014-1025},
  abstract  = {Increased resilience compared to monolithic architectures is both one of the key promises of microservice-based architectures and a big challenge, e.g., due to the systems’ distributed nature. Resilience assessment through simulation requires fewer resources than the measurement-based techniques used in practice. However, there is no existing simulation approach that is suitable for a holistic resilience assessment of microservices comprised of (i) representative fault injections, (ii) common resilience mechanisms, and (iii) time-varying workloads. This paper presents MiSim — an extensible simulator for resilience assessment of microservice-based architectures. It overcomes the stated limitations of related work. MiSim fits resilience engineering practices by supporting scenario-based experiments and requiring only lightweight input models. We demonstrate how MiSim simulates (1) common resilience mechanisms — i.e., circuit breaker, connection limiter, retry, load balancer, and autoscaler — and (2) fault injections — i.e., instance/service killing and latency injections. In addition, we use TeaStore, a reference microservice-based architecture, aiming to reproduce scaling behavior from an experiment by using simulation. Our results show that MiSim allows for quantitative insights into microservice-based systems’ complex transient behavior by providing up to 25 metrics.},
  doi       = {10.1109/QRS57517.2022.00105},
  file      = {:Frank2022 - MiSim_ a Simulator for Resilience Assessment of Microservice Based Architectures.pdf:PDF},
  issn      = {2693-9177},
}

@Article{Abgaz2023,
  author   = {Abgaz, Yalemisew and McCarren, Andrew and Elger, Peter and Solan, David and Lapuz, Neil and Bivol, Marin and Jackson, Glenn and Yilmaz, Murat and Buckley, Jim and Clarke, Paul},
  journal  = {IEEE Transactions on Software Engineering},
  title    = {Decomposition of Monolith Applications Into Microservices Architectures: A Systematic Review},
  year     = {2023},
  issn     = {1939-3520},
  month    = {Aug},
  number   = {8},
  pages    = {4213-4242},
  volume   = {49},
  abstract = {Microservices architecture has gained significant traction, in part owing to its potential to deliver scalable, robust, agile, and failure-resilient software products. Consequently, many companies that use large and complex software systems are actively looking for automated solutions to decompose their monolith applications into microservices. This paper rigorously examines 35 research papers selected from well-known databases using a Systematic Literature Review (SLR) protocol and snowballing method, extracting data to answer the research questions, and presents the following four contributions. First, the Monolith to Microservices Decomposition Framework (M2MDF) which identifies the major phases and key elements of decomposition. Second, a detailed analysis of existing decomposition approaches, tools and methods. Third, we identify the metrics and datasets used to evaluate and validate monolith to microservice decomposition processes. Fourth, we propose areas for future research. Overall, the findings suggest that monolith decomposition into microservices remains at an early stage and there is an absence of methods for combining static, dynamic, and evolutionary data. Insufficient tool support is also in evidence. Furthermore, standardised metrics, datasets, and baselines have yet to be established. These findings can assist practitioners seeking to understand the various dimensions of monolith decomposition and the community's current capabilities in that endeavour. The findings are also of value to researchers looking to identify areas to further extend research in the monolith decomposition space.},
  doi      = {10.1109/TSE.2023.3287297},
  file     = {:Abgaz2023 - Decomposition of Monolith Applications into Microservices Architectures_ a Systematic Review.pdf:PDF},
}

@Article{Zdun2023a,
  author   = {Zdun, Uwe and Queval, Pierre-Jean and Simhandl, Georg and Scandariato, Riccardo and Chakravarty, Somik and Jelić, Marjan and Jovanović, Aleksandar},
  journal  = {IEEE Transactions on Dependable and Secure Computing},
  title    = {Detection Strategies for Microservice Security Tactics},
  year     = {2023},
  issn     = {1941-0018},
  pages    = {1-17},
  abstract = {Microservice architectures are widely used today to implement distributed systems. Securing microservice architectures is challenging because of their polyglot nature, continuous evolution, and various security concerns relevant to such architectures. This article proposes a novel, model-based approach providing detection strategies to address the automated detection of security tactics (or patterns and best practices) in a given microservice architecture decomposition model. Our novel detection strategies are metrics-based rules that decide conformance to a security recommendation based on a statistical predictor. The proposed approach models this recommendation using Architectural Design Decisions (ADDs). We apply our approach for four different security-related ADDs on access management, traffic control, and avoiding plaintext sensitive data in the context of microservice systems. We then apply our approach to a model data set of 10 open-source microservice systems and 20 variants of those systems. Our results are detection strategies showing a very low bias, a very high correlation, and a low prediction error in our model data set.},
  doi      = {10.1109/TDSC.2023.3276487},
  file     = {:Zdun2023a - Detection Strategies for Microservice Security Tactics.pdf:PDF},
}

@InProceedings{Raharjo2022,
  author    = {Raharjo, Agus Budi and Andyartha, Putu Krisna and Wijaya, William Handi and Purwananto, Yudhi and Purwitasari, Diana and Juniarta, Nyoman},
  booktitle = {2022 International Conference on Computer Engineering, Network, and Intelligent Multimedia (CENIM)},
  title     = {Reliability Evaluation of Microservices and Monolithic Architectures},
  year      = {2022},
  month     = {Nov},
  pages     = {1-7},
  abstract  = {Software is continuously evolving as business processes that needed to be solved become increasingly complex. Software architecture is an important aspect during software design, with monolithic and microservices being two of the most common with their own advantages and disadvantages. Monolithic is a unified system with a relatively fast development time. Meanwhile, microservices facilitates low coupling and high cohesion, prioritizing maintenance, and ease of modification post-development. This research compares microservices and monolithic API-based thesis monitoring systems. Implementations are done using PHP, Redis, PostgreSQL, Docker, and Heroku. Reliability evaluations are done through automated tests with Apache JMeter. Metrics used are maturity, availability, fault tolerance, and recoverability based on the ISO/IEC 25010 reliability quality characteristics. The conclusion section showed that microservices are more reliable than the monolithic by demonstrating much better fault tolerance and recoverability, with comparable maturity and availability.},
  doi       = {10.1109/CENIM56801.2022.10037281},
}

@InProceedings{Daniel2023,
  author    = {Daniel, João and Guerra, Eduardo and Rosa, Thatiane and Goldman, Alfredo},
  booktitle = {2023 49th Euromicro Conference on Software Engineering and Advanced Applications (SEAA)},
  title     = {Towards the Detection of Microservice Patterns Based on Metrics},
  year      = {2023},
  month     = {Sep.},
  pages     = {132-139},
  abstract  = {Microservices is a popular architectural approach for complex systems in companies, despite its nature of decentralization. There is a comprehensive set of microservices architectural patterns that guides implementations and helps developers to overcome issues. However, the community still scarcely adopts these patterns and only has a theoretical understanding of them. In this work, in order to increase awareness of such patterns and provide aid to developers to better understand an architecture based on microservices, we propose a detection approach based on metrics for microservices patterns. We focused on structural or architectural patterns, and implemented detection for five of them. We conducted two case studies with real-world applications and evaluated the accuracy and applicability of our approach with the developers of those applications.},
  doi       = {10.1109/SEAA60479.2023.00029},
  file      = {:Daniel2023 - Towards the Detection of Microservice Patterns Based on Metrics.pdf:PDF},
  issn      = {2376-9521},
}

@InProceedings{Pinciroli2023,
  author    = {Pinciroli, Riccardo and Aleti, Aldeida and Trubiani, Catia},
  booktitle = {2023 IEEE 20th International Conference on Software Architecture (ICSA)},
  title     = {Performance Modeling and Analysis of Design Patterns for Microservice Systems},
  year      = {2023},
  month     = {March},
  pages     = {35-46},
  abstract  = {The adoption of design patterns in the microservice architecture and cloud-native development scope was recently reviewed to investigate the industry practice. Interestingly, when considering performance-related aspects, practitioners focus on specific metrics (e.g., the time taken to handle requests) to identify sources of performance hindrance. This paper investigates a subset of seven design patterns that industrial practitioners indicate as relevant for system performance. We are interested to quantify the impact of these patterns while considering heterogeneous workloads, thus supporting software architects in understanding the root causes of performance issues. We use queuing networks to build the performance models of the seven design patterns and extract quantitative insights from model-based performance analysis. Our performance models are flexible in their input parameterization and reusable in different application contexts. We find that most design patterns confirm the expectation of practitioners, and our experimental results assess the identified performance gains and pains. One design pattern (i.e., Gateway Offloading) shows the peculiar characteristic of contributing to performance pains in some cases, leading to novel insights about the impact of design patterns in microservice systems.},
  doi       = {10.1109/ICSA56044.2023.00012},
  file      = {:Pinciroli2023 - Performance Modeling and Analysis of Design Patterns for Microservice Systems.pdf:PDF},
}

@InProceedings{ElMalki2022,
  author    = {El Malki, Amine and Zdun, Uwe and Pautasso, Cesare},
  booktitle = {2022 IEEE International Conference on Service-Oriented System Engineering (SOSE)},
  title     = {Impact of API Rate Limit on Reliability of Microservices-Based Architectures},
  year      = {2022},
  month     = {Aug},
  pages     = {19-28},
  abstract  = {Many API patterns and best practices have been developed around microservices-based architectures, such as Rate Limiting and Circuit Breaking, to increase quality properties such as reliability, availability, scalability, and performance. Even though estimates on such properties would be beneficial, especially during the early design of such architectures, the real impact of the patterns on these properties has not been rigorously studied yet. This paper focuses on API Rate Limit and its impact on reliability properties from the perspective of API clients. We present an analytical model that considers specific workload configurations and predefined rate limits and then accurately predicts the success and failure rates of the back-end services. The model also presents a method for adaptively fine-tuning rate limits. We performed two extensive data experiments to validate the model and measured Rate Limiting impacts, firstly on a private cloud to minimize latency and other biases, and secondly on the Google Cloud Platform to test our model in a realistic cloud environment. In both experiments, we observed a low percentage of prediction errors. Thus, we conclude that our model can provide distributed system engineers and architects with insights into an acceptable value for the rate limits to choose for a given workload. Very few works empirically studied the impact of Rate Limit or similar API-related patterns on reliability.},
  doi       = {10.1109/SOSE55356.2022.00009},
  file      = {:ElMalki2022 - Impact of API Rate Limit on Reliability of Microservices Based Architectures.pdf:PDF},
  issn      = {2642-6587},
}

@InProceedings{Zhou2015a,
  author    = {Zhou, Ping and Wang, Zhipeng and Li, Wenjing and Jiang, Ning},
  booktitle = {2015 IEEE 17th International Conference on High Performance Computing and Communications, 2015 IEEE 7th International Symposium on Cyberspace Safety and Security, and 2015 IEEE 12th International Conference on Embedded Software and Systems},
  title     = {Quality Model of Cloud Service},
  year      = {2015},
  month     = {Aug},
  pages     = {1418-1423},
  abstract  = {In recent years, services based on cloud computing have been used more and more widely. Stakeholders have paid more and more attention on the quality of cloud service. But most of them don't know how to evaluate the quality of cloud service. This paper proposes a comprehensive, structurized, and hierarchical quality model of cloud service, which concerned not only the IT features but also the service features of cloud service. The quality model was constructed by 6 characteristics, i.e., usability, security, reliability, tangibility, responsiveness, and empathy. We divided each characteristic into several subcharacteristics. In order to apply the cloud service model better, and to evaluate the service quality systematically, we provide a metrics framework for those subcharacteristics, which was made up of objective and subjective metrics. We give a brief intro to the methodology on evaluating the cloud service quality. We also illustrate the evaluation process with a case study.},
  doi       = {10.1109/HPCC-CSS-ICESS.2015.134},
  file      = {:Zhou2015a - Quality Model of Cloud Service.pdf:PDF},
}

@InProceedings{Abdeladim2014,
  author    = {Abdeladim, Alfath and Baina, Salah and Baina, Karim},
  booktitle = {2014 Third IEEE International Colloquium in Information Science and Technology (CIST)},
  title     = {Elasticity and scalability centric quality model for the cloud},
  year      = {2014},
  month     = {Oct},
  pages     = {135-140},
  abstract  = {Cloud computing seems to be the most logical shift in terms of Information Technology after Internet, Social Networking. Despite the potential benefits that cloud computing offers, the model brings new issues, challenges, and needs in term of SLA formalization, Quality of Service (QoS) evaluation due to the heterogeneous resources and to the special features it implies, such as Elasticity and Scalability. In the scope of this paper we focus on the Elasticity and Scalability attributes to assess their impact on the QoS. The paper provides a multi-lenses overview that can help both cloud consumers and potential business application's owners to understand, analyze, and evaluate important aspects related to Scalability and Elasticity capabilities. We determine and analyze the key features of these characteristics and derive metrics that evaluate the cloud elasticity-centric capabilities. We present a specific quality model for those two characteristics derived from their sub-attributes.},
  doi       = {10.1109/CIST.2014.7016607},
  file      = {:Abdeladim2014 - Elasticity and Scalability Centric Quality Model for the Cloud.pdf:PDF},
  issn      = {2327-1884},
}

@InProceedings{Ravanello2014,
  author    = {Ravanello, Anderson and Desharnais, Jean-Marc and Bautista Villalpando, Luis Eduardo and April, Alain and Gherbi, Abdelouahed},
  booktitle = {2014 Joint Conference of the International Workshop on Software Measurement and the International Conference on Software Process and Product Measurement},
  title     = {Performance Measurement for Cloud Computing Applications Using ISO 25010 Standard Characteristics},
  year      = {2014},
  month     = {Oct},
  pages     = {41-49},
  abstract  = {Measuring the performance of cloud computing-based applications using ISO quality characteristics is a complex activity for various reasons, among them the complexity of the typical cloud computing infrastructure on which an application operates. To address this issue, the authors use Bautista's proposed performance measurement framework [1] on log data from an actual data centre to map and statistically analyze one of the ISO quality characteristics: time behavior. This empirical case study was conducted on an industry private cloud. The results of the study demonstrate that it is possible to use the proposed performance measurement framework in a cloud computing context. They also show that the framework holds great promise for expanding the experimentation to other ISO quality characteristics, larger volumes of data, and other statistical techniques that could be used to analyze performance.},
  doi       = {10.1109/IWSM.Mensura.2014.33},
  file      = {:Ravanello2014 - Performance Measurement for Cloud Computing Applications Using ISO 25010 Standard Characteristics.pdf:PDF},
}

@InProceedings{Althani2016,
  author    = {Althani, B. and Khaddaj, S. and Makoond, B.},
  booktitle = {2016 IEEE Intl Conference on Computational Science and Engineering (CSE) and IEEE Intl Conference on Embedded and Ubiquitous Computing (EUC) and 15th Intl Symposium on Distributed Computing and Applications for Business Engineering (DCABES)},
  title     = {A Quality Assured Framework for Cloud Adaptation and Modernization of Enterprise Applications},
  year      = {2016},
  month     = {Aug},
  pages     = {634-637},
  abstract  = {Cloud Computing has emerged as a viable alternative to in-house computing resources for many organisations. It offers an alternative solution for many enterprise applications, particularly large-scale legacy applications. In addition, it can offer a cost effective strategy for small and medium-sized enterprises (SMEs) where the high set-up and maintenance cost of computing resources can be prohibiting. Thus, in this paper a System Migration Life Cycle (SMLC) framework is proposed, which includes a step by-stepmigration strategy that is descriptive at the business analyst level and based on quality metrics modelling at the technical level, to estimate the potential computational needs, risks, and costs for an organisation. The proposed framework is generic and adaptable in order to accommodate various organisational requirements, thus covering a wide range of enterprise applications and following a number of novel software requirements and quality engineering principles.},
  doi       = {10.1109/CSE-EUC-DCABES.2016.251},
  file      = {:Althani2016 - A Quality Assured Framework for Cloud Adaptation and Modernization of Enterprise Applications.pdf:PDF},
}

@InProceedings{Haupt2017a,
  author    = {Haupt, Florian and Leymann, Frank and Scherer, Anton and Vukojevic-Haupt, Karolina},
  booktitle = {2017 IEEE International Conference on Software Architecture (ICSA)},
  title     = {A Framework for the Structural Analysis of REST APIs},
  year      = {2017},
  month     = {April},
  pages     = {55-58},
  abstract  = {Today, REST APIs have established as a means for realizing distributed systems and are supposed to gain even more importance in the context of Cloud Computing, Internet of Things, and Microservices. Nevertheless, many existing REST APIs are known to be not well-designed, resulting in the absence of desirable quality attributes that truly RESTful systems entail. Although existing analysis show, that many REST APIs are not fully REST compliant, it is still an open issue how to improve this deficit and where to start. In this work, we introduce a framework for the structural analysis of REST APIs based on their description documents, as this allows for a comprehensive, well-structured analysis approach that also includes analyzing the corresponding API description languages. A first validation builds on a set of 286 real world API descriptions available as Swagger documents, and comprises their transformation into a canonical metamodel for REST APIs as well as a metrics-based analysis and discussion of their structural characteristics with respect to compliance with the REST architectural style.},
  doi       = {10.1109/ICSA.2017.40},
  file      = {:Haupt2017a - A Framework for the Structural Analysis of REST APIs.pdf:PDF},
}

@InProceedings{Papakonstantinou2020,
  author    = {Papakonstantinou, Ioannis and Kalafatidis, Sarantis and Mamatas, Lefteris},
  booktitle = {2020 16th International Conference on Network and Service Management (CNSM)},
  title     = {A Techno-Economic Assessment of Microservices},
  year      = {2020},
  month     = {Nov},
  pages     = {1-5},
  abstract  = {The microservices design paradigm enables applications, usually based on containers, exploiting the flexibility of cloud computing and bringing unique scalability, fault-tolerance and resource-allocation benefits. A number of orchestration facilities, including Kubernetes, target the efficient deployment and operation of containers and are mainly focusing on the maintenance of server resource allocation under predefined thresholds, i.e., through scaling up or down containers to mitigate dynamic changes in the workload. In this work, we highlight the technical capabilities and cost-saving impact of microservices in contrast to traditional monolithic applications, based on a techno-economic analysis. We also investigate the service performance vs resource allocation trade-off, uncovering interesting dynamics when elasticity is driven from service quality metrics. This approach allows the Service Providers (SPs) to balance their profit margins with the customer satisfaction, i.e., reducing the infrastructure cost while keeping the service performance at an acceptable level.},
  doi       = {10.23919/CNSM50824.2020.9269114},
  file      = {:Papakonstantinou2020 - A Techno Economic Assessment of Microservices.pdf:PDF},
  issn      = {2165-963X},
}

@Article{Peng2017,
  author   = {Peng, Kuan-Li and Huang, Chin-Yu},
  journal  = {IEEE Transactions on Services Computing},
  title    = {Reliability Analysis of On-Demand Service-Based Software Systems Considering Failure Dependencies},
  year     = {2017},
  issn     = {1939-1374},
  month    = {May},
  number   = {3},
  pages    = {423-435},
  volume   = {10},
  abstract = {Service-based software systems (SBSSs) are widely deployed due to the growing trend of distributed computing and cloud computing. It is important to ensure high quality of an SBSS, especially in a strongly competitive market. Existing works on SBSS reliability usually assumed independence of service failures. However, the fact that resource sharing exists in different levels of SBSS operations invalidates this assumption. Ignorance of failure dependencies have been discussed as potentially affecting system reliability predictions and lowering the benefits of design diversity, as typically seen in high-reliability systems. In this paper, we propose a reliability framework that incorporates failure dependence modeling, system reliability modeling, as well as reliability analysis for individual services and for failure sources. The framework is also capable of analyzing the internal structures of popular software fault tolerant (FT) schemes. The proposed method is applied to a travel agency system based upon a real-world practice for verifying its accuracy of reliability modeling and effectiveness of varied reliability measures. The results show that failure dependence of the services is an essential factor for analyzing any valuable SBSS system. Further, a set of reliability measures with different capabilities and complexities are available for assisting SBSS engineers with system improvements.},
  doi      = {10.1109/TSC.2015.2473843},
  file     = {:Peng2017 - Reliability Analysis of on Demand Service Based Software Systems Considering Failure Dependencies.pdf:PDF},
}

@InProceedings{Klinaku2021,
  author    = {Klinaku, Floriment and Hakamian, Alireza and Becker, Steffen},
  booktitle = {2021 IEEE International Conference on Autonomic Computing and Self-Organizing Systems (ACSOS)},
  title     = {Architecture-based Evaluation of Scaling Policies for Cloud Applications},
  year      = {2021},
  month     = {Sep.},
  pages     = {151-157},
  abstract  = {The cloud computing model enables organizations to employ policies for the automated provisioning of computing resources. The impact on the quality, such as performance or cost, of such policies is often unknown for complex, large, and highly distributed cloud applications. Software architects lack a feasible approach to evaluate scaling policies for their cloud application quantitatively. While approaches exist in the literature, they are costly and require a high effort. We propose an approach that utilizes modeling and terminating simulations to evaluate alternative styles and configurations for cloud scaling policies. The approach aids the architect in understanding and explaining their dynamic behavior and the existing trade-offs. Third, we conduct simulation experiments on a representative case study model to show the approach&#x0027;s feasibility. We evaluate the performance, cost, efficiency, and complexity of three scaling policies of different styles (e.g., centralized vs. decentralized) on a model. Results show that the policies improve the performance for the selected scenario. However, no significant difference among them exists in terms of performance. Other metrics highlight the present trade-offs across policies. All in all, the case shows that the approach helps architects refine the style and find an appropriate policy for their context.},
  doi       = {10.1109/ACSOS52086.2021.00035},
  file      = {:Klinaku2021 - Architecture Based Evaluation of Scaling Policies for Cloud Applications.pdf:PDF},
}

 
@Article{Haoues2016,
  author    = {Haoues, Mariem and Sellami, Asma and Ben-Abdallah, Hanêne and Cheikhi, Laila},
  journal   = {International Journal of System Assurance Engineering and Management},
  title     = {A guideline for software architecture selection based on ISO 25010 quality related characteristics},
  year      = {2016},
  issn      = {0976-4348},
  month     = nov,
  number    = {S2},
  pages     = {886–909},
  volume    = {8},
  abstract  = {As the complexity of software increases, the choice of the appropriate software architecture becomes a critical task. This paper provides a guideline for selecting the appropriate software architecture based on pertinent ISO 25010 quality characteristics. The guideline was established through an analytical survey of 113 papers published from 2010 to 2014. Through this survey, we first identified a set of commonly used software architectures in the software engineering literature. Secondly, we applied the Formal Concept Analysis technique to classify each one of these architectures according to ISO 25010 quality characteristics. Finally, we identified the relationships among ISO 25010 quality characteristics, which in turn helped us to develop a guideline on how to select the appropriate software architecture with respect to ISO 25010 quality characteristics. In order to make sure about the validation of the proposed guideline, a survey with industrial experts is in progress. Data were collected from two companies working in the software development field (ST2i and Telnet).},
  doi       = {10.1007/s13198-016-0546-8},
  file      = {:Haoues2016 - A Guideline for Software Architecture Selection Based on ISO 25010 Quality Related Characteristics.pdf:PDF},
  publisher = {Springer Science and Business Media LLC},
  url       = {http://dx.doi.org/10.1007/s13198-016-0546-8},
}

 
@InBook{Ntentos2021,
  author    = {Ntentos, Evangelos and Zdun, Uwe and Plakidas, Konstantinos and Geiger, Sebastian},
  pages     = {188–203},
  publisher = {Springer International Publishing},
  title     = {Evaluating and Improving Microservice Architecture Conformance to Architectural Design Decisions},
  year      = {2021},
  isbn      = {9783030914318},
  abstract  = {Microservices are a commonly used architectural style targeting independent development, deployment, and release of services, as well as supporting polyglot capabilities and rapid release strategies. This depends on the presence of certain software architecture qualities. A number of architecture patterns and best practices that support the required qualities have been proposed in the literature, but usually in isolation of one another. Additionally, in real-world systems, assessing conformance to these patterns and practices and detecting possible violations is a significant challenge. For small-scale systems of a few services, a manual assessment and violation detection by an expert is probably both accurate and sufficient. However, for industrial-scale systems of several hundred or more services, manual assessment and violation detection is laborious and likely leads to inaccurate results. Furthermore, manual assessment is impractical for rapidly evolving and frequently released system architectures. In this work we examine a subset of microservice-relevant patterns, and propose a method for the semi-automatic detection and resolution of conformance violations. Our aim is to assist the software architect by providing a set of possible fix options and generating models of “fixed” architectures.},
  booktitle = {Lecture Notes in Computer Science},
  doi       = {10.1007/978-3-030-91431-8_12},
  file      = {:Ntentos2021 - Evaluating and Improving Microservice Architecture Conformance to Architectural Design Decisions.pdf:PDF},
  issn      = {1611-3349},
  url       = {http://dx.doi.org/10.1007/978-3-030-91431-8_12},
}

 
@InBook{Abdelfattah2023,
  author    = {Abdelfattah, Amr S. and Cerny, Tomas and Salazar, Jorge Yero and Lehman, Austin and Hunter, Joshua and Bickham, Ashley and Taibi, Davide},
  pages     = {35–51},
  publisher = {Springer Nature Switzerland},
  title     = {End-to-End Test Coverage Metrics in Microservice Systems: An Automated Approach},
  year      = {2023},
  isbn      = {9783031462351},
  abstract  = {Microservice architecture gains momentum by fueling systems with cloud-native benefits, scalability, and decentralized evolution. However, new challenges emerge for end-to-end (E2E) testing. Testers who see the decentralized system through the user interface might assume their tests are comprehensive, covering all middleware endpoints scattered across microservices. However, they do not have instruments to verify such assumptions. This paper introduces test coverage metrics for evaluating the extent of E2E test suite coverage for microservice endpoints. Next, it presents an automated approach to compute these metrics to provide feedback on the completeness of E2E test suites. Furthermore, a visual perspective is provided to highlight test coverage across the system’s microservices to guide on gaps in test suites. We implement a proof-of-concept tool and perform a case study on a well-established system benchmark showing it can generate conclusive feedback on test suite coverage over system endpoints.},
  booktitle = {Lecture Notes in Computer Science},
  doi       = {10.1007/978-3-031-46235-1_3},
  file      = {:Abdelfattah2023 - End to End Test Coverage Metrics In Microservice Systems_ an Automated Approach.pdf:PDF},
  issn      = {1611-3349},
  url       = {http://dx.doi.org/10.1007/978-3-031-46235-1_3},
}

@InProceedings{Chauvel2014,
  author    = {Chauvel, Franck and Song, Hui and Ferry, Nicolas and Fleurey, Franck},
  booktitle = {Proceedings of the 2014 IEEE/ACM 7th International Conference on Utility and Cloud Computing},
  title     = {Robustness Indicators for Cloud-Based Systems Topologies},
  year      = {2014},
  address   = {USA},
  pages     = {307–316},
  publisher = {IEEE Computer Society},
  series    = {UCC '14},
  abstract  = {Various services are now available in the Cloud, ranging from turnkey databases and application servers to high-level services such as continuous integration or source version control. To stand out of this diversity, robustness of service compositions is an important selling argument, but which remains difficult to understand and estimate as it does not only depend on services but also on the underlying platform and infrastructure. Yet, choosing a specific service composition may fail to deliver the expected robustness, but reverting early choices may jeopardise the success of any Cloud project. Inspired by existing models used in Biology to quantify the robustness of ecosystems, we show how to tailor them to obtain early indicators of robustness for cloud-based deployments. This technique helps identify weakest services in the overall architecture and in turn mitigates the risk of having to revert key architectural choices. We illustrate our approach by comparing the robustness of four alternative deployments of the Sens App application, which includes a Mongo DB database, four REST services and a graphical web-front end.},
  doi       = {10.1109/UCC.2014.40},
  file      = {:Chauvel2014 - Robustness Indicators for Cloud Based Systems Topologies.pdf:PDF},
  isbn      = {9781479978816},
  keywords  = {robustness indicators, failures sequences, extinction sequences, cloud topologies, deployment, bio-inspired},
  numpages  = {10},
}

@InProceedings{Filippone2023,
  author    = {Filippone, Gianluca and Qaisar Mehmood, Nadeem and Autili, Marco and Rossi, Fabrizio and Tivoli, Massimo},
  booktitle = {2023 IEEE 20th International Conference on Software Architecture (ICSA)},
  title     = {From monolithic to microservice architecture: an automated approach based on graph clustering and combinatorial optimization},
  year      = {2023},
  month     = {March},
  pages     = {47-57},
  abstract  = {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.},
  doi       = {10.1109/ICSA56044.2023.00013},
  file      = {:Filippone2023 - From Monolithic to Microservice Architecture_ an Automated Approach Based on Graph Clustering and Combinatorial Optimization.pdf:PDF},
}

@Comment{jabref-meta: databaseType:bibtex;}

@Comment{jabref-meta: fileDirectory-robin-robin-x1-carbon10:../../../pdfs;}