Background: Microservice architecture has become a mainstream approach for cloud-native systems, transforming industries across diverse business domains over the past decade. While scalability has driven much of its adoption, system heterogeneity is frequently highlighted as a critical advantage. The research community frequently underscores heterogeneity as a priority in proposed solutions and innovations. Aims: This study investigates the real-world significance of heterogeneity in industrial microservice-based systems, seeking to answer: How prevalent is heterogeneity in practice? Are there governance practices to manage it? Is heterogeneity truly the main enabler for independent team operations? Method: We combined industrial expertise with a controlled experiment, incorporating insights directly from practitioners to assess the role and prevalence of heterogeneity in microservice-based systems. Results: Our findings reveal common themes and influential factors guiding heterogeneity-related decisions. We also identify varying governance approaches and highlight where industry practices align-or diverge-from common academic assumptions. Conclusions: This work bridges the gap between academic research and industry realities, providing a grounded understanding of heterogeneity in microservice systems. The results offer a foundation for future research to better address the practical needs of the microservice industry.

Microservices have been a key architectural approach for over a decade, transforming system design by promoting decentralization and allowing development teams to work independently on specific microservices. While loosely coupled microservices are ideal, dependencies between them are inevitable. Often, these dependencies go unnoticed by development teams. Although syntactic dependencies can be identified, tracking semantic dependencies — when multiple microservices share similar logic — poses a greater challenge. As systems evolve, changes made to one microservice can trigger ripple effects, jeopardizing system consistency and requiring updates to dependent services, which increases maintenance and operational complexity. Effectively tracking different types of dependencies across microservices is essential for anticipating the impact of such changes. This paper introduces the Semantic Dependency Matrix as an instrument to address these challenges from a semantic perspective. We propose an automated approach to extract and represent these dependencies and demonstrate its effectiveness through a case study. This paper takes a step further by demonstrating the significance of semantic dependencies, even in cases where there are no direct dependencies between microservices. It shows that these hidden dependencies can exist independently of endpoint or data dependencies, revealing critical connections that might otherwise be overlooked.

Cloud-native systems are the mainstream for en-terprise solutions, given their scalability, resilience, and other benefits. While the benefits of cloud-native systems fueled by microservices are known, less guidance exists on their evolution. One could assume that since microservices encapsulate their code, code changes remain encapsulated as well; however, the community is becoming more aware of the possible consequences of code change propagation across microservices. Moreover, an active mitigation instrument for negative consequences of change propagation across microservices (i.e., ripple effect) is yet missing, but the microservice community would greatly benefit from it. This paper introduces what it could look like to have an infrastructure to assist with change impact analysis across the entire microservice system and intends to facilitate advance-ments in laying out the foundations and building guidelines on microservice system evolution. It shares a new direction for incremental software architecture reconstruction that could serve as the infrastructure concept and demonstrates early results from prototyping to illustrate the potential impact.

Modern software systems evolve rapidly, especially when boosted by continuous integration and delivery. While many tools exist to help manage the maintainability of monolithic systems, gaps remain in assessing changes in decentralized systems, such as those based on microservices. Microservices fuel cloud-native systems, the mainstream direction for most enterprise solutions, which drives motivation for a broader understanding of how changes propagate through such systems. This position paper elaborates on the role of dependencies when dealing with evolution challenges in microservices aiming to support maintainability. It highlights the importance of dependency management in the context of maintainability deterioration. Our proposed perspective refines the approach to maintainability assurance by focusing on the systematic management of dependencies as a more direct method for addressing and understanding change propagation pathways, compared to traditional methods that often only a ddress symptoms like anti-patterns, smells, metrics, or high-level concepts.

Cloud-native systems represent a significant leap in constructing scalable, large systems, employing microservice architecture as a key element in developing distributed systems through self-contained components. However, the decentralized nature of these systems, characterized by separate source codes and deployments, introduces challenges in assessing system qual-ities. Microservice-based systems, with their inherent complexity and the need for coordinated changes across multiple microser-vices, lack established best practices and guidelines, leading to difficulties in constructing and comprehending the holistic system view. This gap can result in performance degradation and increased maintenance costs, potentially requiring system refactoring. The main goal of this project is to offer maintainability assur-ance for microservice practitioners. It introduces an automated assessment framework tailored to microservice architecture, en-hancing practitioners' understanding and analytical capabilities of the multiple system perspectives. The framework addresses various granularity levels, from artifacts to constructing holistic views of static and dynamic system characteristics. It integrates diverse perspectives, encompassing human-centric elements like architectural visualization and automated evaluations, including coupling detection, testing coverage measurement, and semantic clone identification. Validation studies involving practitioners demonstrate the framework's effectiveness in addressing diverse quality and maintainability issues, revealing insights not apparent when analyzing individual microservices in isolation.

Researchers in the microservices community often resort to demonstrating the impact of their proposed advancements on custom-made microservices projects. This is a possible source of bias that can reduce the trustworthiness of the results. Moreover, it is hard to compare advances in small projects, often developed due to lack of time. It is common across disciplines to recognize benchmarks that mitigate bias and unify the advancements' impact. To facilitate the identification of available open-source microservice projects (OSS-MS), we performed a comprehensive study to identify, curate, and catalog OSS-MS. We started with 389559 projects and filtered them down to 3804 projects that we manually labeled. After manual labeling, our dataset contains 378 projects with three or more microservices and with over 100 commits. We document the projects from many perspectives, including project size, platform, number of contributors, project purpose, and foundation support. This dataset can serve researchers as a roadmap to identify benchmarks, as our dataset can be used to answer questions such as whether the number of services impacts the issue count.

Microservices are the mainstream architecture when designing cloud-native systems. The performance and elastic scalability of such systems are the main attraction for many vendors. Recent advancements improving microservice initialization times are related to the ahead-of-time compilation, which produces self-contained executables, significantly reducing load times. Despite recent advancements and various benefits of cloud-native systems, the evolution of such systems might be threatened by a missing system-centered view. Such a view would guide in a better contextual understanding of individual microservices and their dependencies from the holistic system perspective and aid developers in informed decisions to mitigate ripple effects. One way literature has addressed this gap is by performing Software Architecture Reconstruction (SAR), a process essential for understanding, maintaining, and evolving software systems. This paper questions whether instruments used to produce self-contained executables for microservices can be utilized for SAR, producing system-centered views. We propose a methodology for such a process, implement a proof of concept tool, MicroGraal, for the Java Platform, and assess it through a case study involving a third-party microservice system benchmark. We uncovered a system service dependency graph and a context map, comparing the approach and obtained results with source code analysis.

Microservice-based systems are often complex to understand, especially when their sizes grow. Abstracted views help practitioners with the system understanding from a certain perspective. Recent advancement in interactive data visualization begs the question of whether established software engineering models to visualize system design remain the most suited approach for the service-oriented design of microservices. Our recent work proposed presenting a 3D visualization for microservices in augmented reality. This paper analyzes whether such an approach brings any benefits to practitioners when dealing with selected architectural questions related to system design quality. For this purpose, we conducted a controlled experiment involving 20 participants investigating their performance in identifying service dependency, service cardinality, and bottlenecks. Results show that the 3D enables novices to perform as well as experts in the detection of service dependencies, especially in large systems, while no differences are reported for the identification of service cardinality and bottlenecks. We recommend industry and researchers to further investigate AR for microservice architectural analysis, especially to ease the onboarding of new developers in microservice projects.

Various works investigated microservice anti-patterns and bad smells in the past few years. We identified seven secondary publications that summarize these, but they have little overlap in purpose and often use different terms to describe the identified anti-patterns and smells. This work catalogs recurring bad design practices known as anti-patterns and bad smells for microservice architectures, and provides a classification into categories as well as methods for detecting these practices. We conducted a systematic literature review in the form of a tertiary study targeting secondary studies identifying poor design practices for microservices. We provide a comprehensive catalog of 58 disjoint anti-patterns, grouped into five categories, which we derived from 203 originally identified anti-patterns for microservices. The results provide a reference to microservice developers to design better-quality systems and researchers who aim to detect system quality based on anti-patterns. It also serves as an anti-pattern catalog for development-aiding tools, which are not currently available for microservice system development but could mitigate quality degradation throughout system evolution.

Despite the fact that there are numerous classifications of technical debt based on various criteria, Code Debt or code smells is a category that appears in the majority of current research. One of the primary causes of code debt is the urgency to deliver software quickly, as well as bad coding practices. Among many approaches, static code analysis has received the most attention in studies to detect code-smell/code debt. However, most of them examine the same programming language, although today’s software company utilizes many development stacks with various languages and tools. This problem can be resolved by detecting code debt with Issue/Ticket cards. This paper presents a method for detecting code debt leveraging natural language processing on issue tickets. It also proposes a method for calculating the average amount of time that a code debt was present in the software. This method is implemented utilizing git mining.