Journal of Software Engineering Research and Development

Management of Technical Debt in Startups: A Systematic Mapping

Déverson Rogério Rando — 2026-03-31

This study explores the state of the art of Technical Debt (TD) in software startups, seeking to understand the approaches, methods, and techniques used to manage this issue. TD is a concept that refers to suboptimal technical decisions made to accelerate development, such as implementing code or design that later requires revision to avoid future problems. In startups, where speed and innovation are essential for growth, the pressure to quickly release products often leads to the accumulation of TD. Although this offers short-term benefits, such as faster feature releases, in the long term, it can compromise product quality, increase maintenance costs, and reduce the ability to scale the business. We conducted the study through a systematic literature mapping and analyzed articles from the Scopus, IEEE Xplore, and ACM Digital Library databases. The authors selected fourteen studies published between 2017 and 2024. The analysis revealed that practitioners and researchers still lack standardized practices and tools for efficiently managing TD. Furthermore, the research highlights the need for more empirical studies that consider the specific context of startups, where limited resources and the need for accelerated innovation create unique challenges for TD management. The mapping carried out highlights the fragmentation of current approaches and the lack of a unified framework for managing TD in startups. The authors therefore conclude that there is a need to develop and empirically validate strategic models that integrate technical, human, and business aspects to prove more effective solutions for this specific context.

Refactoring Code Smells in Open Source Projects: A Hands-on Approach to Teaching Software Maintenance

Carla Bezerra — 2026-05-02

Code smells are suboptimal structures that undermine software quality. While refactoring is the standard technique to address them, its manual application can degrade code if done without discipline. Despite its importance, refactoring is rarely explored in depth in undergraduate computing courses, creating a gap between academia and industry. Simultaneously, Open Source Software (OSS) projects offer authentic, hands-on learning environments for software maintenance. To address the academic gap and leverage this opportunity, this paper presents and evaluates a hands-on pedagogical approach for teaching code smell refactoring through student contributions to OSS projects. We implemented this approach in two undergraduate Software Quality and Maintenance courses. Our analysis of students' learning experiences reveals that they recognized quality improvements and the connection between refactoring and testing. However, they faced challenges with code complexity and cross-file changes, which sometimes inadvertently introduced new code smells. Regarding the OSS experience, students reported professional growth but struggled with contribution workflows and receiving feedback from maintainers. Our findings offer valuable insights and propose actionable pedagogical recommendations for educators seeking to integrate advanced software maintenance practices into their curricula by leveraging the real-world environment of OSS.

Specifying Accessibility Requirements with Personas, WCAG, US, and BDD Scenarios: Insights from Two Case Studies

Renata Vinadé — 2026-03-31

Accessibility is essential for inclusive digital experiences, yet it is often overlooked in early stages of software development. This paper presents two empirical studies focused on improving how accessibility requirements are specified. In the first study, undergraduate Software Engineering students explored accessibility principles through guided activities and questionnaires. The second study evaluated a structured method combining Personas, User Stories, Behavior-Driven Development (BDD), and WCAG guidelines. Participants applied the method to specify accessibility features in real scenarios. The findings show that although initial knowledge was limited, structured interventions led to more precise, WCAG-aligned, and testable requirements. These results highlight the value of embedding accessibility into software engineering education and demonstrate the effectiveness of combining user-centered design with formal specification techniques.

Extending the Comparative Study of Anomaly Detection Tools in Software Requirements with ChatGPT

Fábio Rodrigues Pereira — 2026-05-08

A software requirement indicates a capability or characteristic that a software system must possess to provide value to its stakeholders. It is essential to ensure that the description of the requirements is unambiguous to allow for proper understanding and facilitate its evolution. However, since most software requirements are described in natural language, they may contain subjectivity and inconsistencies in their descriptions, which are conventionally referred to as "Software Requirements Anomalies". Several studies propose tools to aid in the detection of requirements anomalies. However, it can be observed that few of these studies evaluate the effectiveness (recall and precision) of the proposed tools. Therefore, this work presents a comparative study of three anomaly detection tools (RETA, Tactile Check, and Tiger Pro), as well as the ChatGPT model, analyzed based on requirements documents from different domains containing over 85 anomalies. The results show that the Tactile Check tool produced the best performance. Although ChatGPT offers advantages in terms of information visualization and flexibility of interaction, its performance was not satisfactory compared to tools specifically designed for anomaly detection in software requirements. All analyzed tools, including ChatGPT, demonstrated unsatisfactory levels of recall and precision, averaging below 66% and 57%, respectively. These results highlight the need for further contributions in this research area.

TechDebt Tracker: Towards a Method for Monitoring Technical Debt in Agile Projects

Mayra Pereira — 2026-05-11

Context: Software companies that adopt agile methods face numerous challenges in sustaining the long-term evolution of software systems. Technical debt is a key contributor to poor maintainability, often leading to failures in agile software projects. This situation becomes even more problematic when managers do not adequately address technical debt items. Objective: This paper proposes the TechDebt Tracker, a method for supporting the documentation and monitoring of technical debt items within technical debt management activities in the context of agile projects. Method: We employed Design Science Research to develop and evaluate the proposal, following the summarized steps of related work review, problem definition, design and development, demonstration, and evaluation. In the related work review, we examined studies with similar research questions across multiple digital libraries. During the design and development phase, we used Design Thinking, the Business Model Canvas, and the Value Proposition Canvas to identify vulnerabilities and opportunities for improvement in the emerging solution. The proposal was demonstrated in a small software company, from which feedback was gathered to refine the method. The evaluation phase consisted of a small-scale study assessed through questionnaires. Results: The proposal comprises three components: two formulas, a kanban board, and a flow. The formulas are used to measure the impact of technical debt on the project and incorporate data such as the developer’s hourly rate, severity, and penalty associated with each technical debt item. The kanban board includes several columns—such as monitoring, technical debt backlog, and testing—as well as a card template used to register and prioritize each technical debt item. The flow consists of states and actions that, when used together with the kanban board, define a method for monitoring technical debt. The company evaluated the proposal positively, highlighting its technical adequacy. Conclusions: We recommend evaluating the proposal in additional contexts and hope that this proposal will be adopted by software companies that employ agile methodologies in diverse scenarios. Our goal is to take a step toward developing a method that can be used in the daily operations of companies to simplify technical debt management.

Democratizing AI Development: A Feature-Based Categorization of API Platforms, Development Frameworks, LCNC and AIaaS Platforms for LLM-Based Applications

Dimitrios Tolis — 2026-05-08

In recent years, LLM-based AI development platforms have gained widespread adoption, enabling both IT professionals and citizen developers to create AI-powered applications. However, the landscape remains fragmented, with a variety of API-based platforms, AI development frameworks, Low Code/No Code (LCNC) platforms, and Domain-Specific AI as a Service (AIaaS) solution, each offering varying levels of accessibility and customization. Due to the recency of the interest in LLM-based AI development platforms, there is limited systematic research categorizing these tools based on their functionalities and intended user groups. This paper addresses this gap by proposing a structured, feature-based categorization framework, distinguishing between platforms based on criteria such as primary target group, degree of customization, and level of abstraction. Methodologically, we apply a feature-driven analysis grounded in documented capabilities and design affordances across a representative set of tools, and we operationalize the two core dimensions (customization and abstraction) through an anchored ordinal scoring rubric to produce a visual map of categories and overlaps. However, further empirical research is needed to validate the attitude of users towards the different tools in the categories. By providing a clearer understanding of AI development tools, this research supports more informed decision-making and contributes to the democratization of AI adoption across industries.

How TypeScript Compiler Options Influence Code Quality: A Correlation Study with Git Repositories

Thomaz Zandonotto — 2026-08-06

TypeScript is widely adopted in modern software development to improve code reliability through static typing. However, its effectiveness in promoting code quality depends heavily on the compiler options configured within each project. Despite its popularity, little is known about how these compiler configurations influence code quality in practice. This study investigates the relationship between TypeScript compiler options and code quality metrics in real-world software projects. We analyzed over 4,000 public GitHub repositories that use TypeScript, through an automated four-stage pipeline comprising data mining, compiler configuration extraction, static quality assessment, and statistical correlation analysis. Projects were selected based on predefined criteria, and their tsconfig.json files were parsed to extract compiler settings. SonarQube was employed to evaluate bugs and code smells, aggregated into a composite Static Issues Index (SII), which was then correlated with specific compiler options. The results show that stricter compiler settings, such as noImplicitAny and noUnusedParameters, tend to correlate with fewer bugs and code smells. However, some options behave counterintuitively at scale; for instance, enabling noFallthroughCasesInSwitch and noUncheckedIndexedAccess correlated positively with bug counts in our dataset, suggesting the presence of confounding factors rather than a direct causal effect. These findings provide large-scale empirical evidence that compiler configurations in TypeScript are associated with measurable differences in static code quality. The study offers practical guidance for developers seeking to enforce best practices through TypeScript's configuration mechanisms and contributes an empirical perspective to the software engineering community.

The Development and Validation of a Questionnaire to Assess Agility in Software Engineering (QASE)

Vincent Tchikanmou — 2026-08-06

The concept of agility is increasingly becoming the focus of empirical research. However, what agility is and how it can best be conceptualized and measured remain controversial, even among researchers. This lack of consensus is reflected in the literature in the divergent approaches used to operationalize the concept in research, which limits the comparability of empirical results and impedes the development of a cohesive body of knowledge in the field. Against this background, the present article addresses the development of a valid questionnaire to assess agility in software engineering (QASE) that can be consistently used across various contexts. For this purpose, the commonalities among pioneer agile methods were examined by analyzing their underlying techniques, resulting in a second-order measurement model comprising 30 factors and 90 items. The QASE was evaluated using confirmatory factor analysis in a first study (N = 418), then refined and re-evaluated in a second study (N = 152), thereby demonstrating its factor structure, validity, and reliability. With the QASE, we provide the research community with a theoretically sound and empirically valid measurement instrument that facilitates hypothesis testing, supports theory development, and enables more reliable conclusions about the mechanisms underlying the positive outcomes associated with agility, thereby contributing to a more coherent and cumulative body of knowledge in Agile Software Development.

On the Effectiveness of Feedforward Neural Networks for Performance Prediction in Highly Configurable Systems: The Case of Linux Kernel Size

João Marcello Bessa — 2026-08-06

Highly configurable software systems, such as the Linux kernel, expose thousands of configuration options whose combinations can drastically influence non-functional properties. In embedded or resource-constrained environments, kernel binary size is particularly important because it directly affects memory footprint, boot time, storage usage, and overall system responsiveness. Accurately predicting binary size from configuration options enables developers to evaluate trade-offs early in the development cycle, reducing the need for costly trial-and-error compilation and measurement processes. This study investigates the use of Feedforward Neural Networks (FNNs) for predicting Linux kernel binary size and compares their performance against strong classical Machine Learning (ML) baselines, including Random Forest and Gradient Boosting Trees. In addition, we analyze the impact of feature selection (FS) strategies on predictive accuracy and computational cost. We evaluate five FS approaches, including supervised tree-based importance rankings and a semantic, label-free method based on Word2Vec embeddings extracted from Linux kernel documentation. Our experiments were conducted on a dataset containing 9,670 Linux kernel configuration options. The results show that classical tree-based ensemble methods outperformed FNNs in predictive accuracy, with Gradient Boosting Trees achieving the best overall results (MAPE of 5.21%). Although FNNs combined with feature selection achieved reasonable accuracy (best MAPE of 8.26%) and benefited from reduced training times, they did not surpass the traditional ML baselines. These findings provide important empirical evidence that more complex neural architectures do not necessarily yield superior performance for SPL prediction tasks, even in high-dimensional configuration spaces. We also show that the Word2Vec-based semantic FS method offers a practical label-free alternative for early-stage scenarios where measured NFP data are unavailable or expensive to obtain, although it generally underperforms supervised feature selection strategies in both accuracy and efficiency. Overall, our findings provide practical guidance for SPL practitioners and researchers in selecting prediction models and preprocessing strategies that balance accuracy, interpretability, and computational cost in highly configurable systems.

Task Interdependence in Software Teams: A Systematic Review Anchored in Kiggundu’s Theory

Mayara Benício de Barros Souza — 2026-05-19

Background: Task interdependence is a core mechanism underlying coordination, performance, and collaboration in team-based work. Kiggundu’s task design theory has shaped how interdependence is conceptualized across knowledge-work settings, including Software Engineering (SE). However, there has been no consolidated synthesis of how Kiggundu’s theory has been empirically applied, operationalized, and adapted in SE and related domains. Objectives: This review aims to (1) systematically synthesize empirical studies that explicitly cite or build on Kiggundu’s task interdependence theory; (2) examine how task interdependence is conceptualized and measured in software development contexts; and (3) compare findings across other knowledge-work domains to identify convergent patterns, boundary conditions, and implications for SE research and practice. Method: We conducted a systematic literature review using forward snowballing from Kiggundu’s foundational publications, identifying 23 eligible empirical studies published between 2013 and 2024. A structured extraction protocol was used to code studies for theoretical framing, conceptualization and measurement of interdependence, analytical role, outcomes, domain, unit of analysis, and methodological characteristics. Open and axial coding supported thematic development, complemented by cross-tabulations and visual mappings to support integrative synthesis. Results: Most studies model task interdependence as a predictor or moderator of outcomes such as team performance, learning, coordination, and relational or affective states. In software development, interdependence is frequently conceptualized as a structural and directional feature of work design, often examined in relation to autonomy, coordination mechanisms, and distributed collaboration. Cross-domain evidence reveals both convergent patterns, such as positive associations with effectiveness under supportive conditions, and important boundary conditions shaped by factors including autonomy, social support, task complexity, and role clarity. A smaller but growing set of studies emphasizes perceived (psychological) interdependence and socio-cognitive or affective pathways, particularly in agile and distributed teams. Conclusions: The findings indicate that Kiggundu’s theory remains a relevant and adaptable framework for analyzing task interdependence in contemporary knowledge work, including software development. The synthesis highlights increasing attention to directionality, perceived interdependence, and emotional–cognitive dimensions, alongside persistent reliance on structural measures. By integrating evidence across domains, this review clarifies how structural task features interact with contextual and psychological factors, and outlines implications for software development practice as well as directions for future empirical research on software teams.

Inside the Mobile Community: GUI Testing Discussions and Challenges on Stack Exchange

Matheus Costa Pinto Marçal — 2026-08-06

The Graphical User Interface (GUI) is increasingly becoming the focus of developers and testers. A well-designed, defect-free interface can significantly affect whether the application functions properly and provides a satisfying user experience. In particular, in the era of smartphones with varying screen sizes and operating systems, mobile developers and testers are increasingly developing and using interface tests. This article aims to characterize the practical landscape of Mobile GUI testing by analyzing discussions among practitioners across six Stack Exchange communities, identifying the main challenges, tools, and platform-specific differences reported by developers and testers. To achieve this goal, we collected and filtered data from Stack Exchange Data Dumps covering the years 2012 to 2023, combining automated keyword-based filtering with manual validation by three independent analysts, resulting in 714 posts and 203 comments for analysis. The yielded findings show that the main challenges are device compatibility, unexpected UI interference, and limitations in automation tools. Appium emerges as the most prevalent tool, mentioned in over 40% of analyzed posts, while platform-specific frameworks such as Espresso and UI Automator (Android) and XCTest and XCode UI Test (iOS) are also widely discussed. The results also show that Android offers greater testing flexibility, whereas iOS imposes stricter restrictions that require additional configuration. This study provides a practitioner-driven synthesis of real-world Mobile GUI testing practices, shedding light on the main trends and practices developed by the community.

Exploring the Relationship Between SOLID Principles and Code Smells: The Software Developer Perspective

Ivandeclei Mendes — 2026-08-06

Software engineering principles aim to deliver high-quality products efficiently. However, as development progresses and new features are added, software quality can deteriorate without proactive measures. Refactoring helps maintain software quality by systematically restructuring code through small incremental changes without altering its behavior. A crucial step in the refactoring process is identifying code smells, which are design or structural flaws that increase software complexity, hinder maintenance, and contribute to duplication and rework. This study examines developers' knowledge of code smells and their perceptions of using SOLID principles to avoid them. To explore this relationship, we conducted a survey with 71 professional developers. Our results show no correlation between knowledge of code smells and the developer's academic background or experience level. Additionally, participants widely recognized the SOLID principles as an effective way of avoiding code smells. These findings reinforce the importance of studying code smells, understanding their refactoring techniques, and applying the SOLID principles for maintaining high-quality software products.

Privacy by Design Maturity in Software Development: An Empirical Study in Brazilian Federal Higher Education Institutions

Fernando Elias de Oliveira — 2026-08-06

Context: Privacy by Design (PbD) has emerged as a key approach for embedding data protection into software systems from their inception, a pressing concern in Brazil after the enactment of the General Data Protection Law (LGPD). However, public organizations such as Brazilian Federal Higher Education Institutions (IFES) still struggle to translate legal requirements into concrete engineering practices and governance routines. Goal: This study investigates how IT professionals in IFES perceive, adopt, and operationalize PbD in software development, and which organizational, technical, and individual factors influence the maturity of privacy practices in this context. Method: We conducted a mixed-method survey with 58 IT professionals from IFES across 15 Brazilian states. The instrument combined 46 closed-ended and 9 open-ended questions covering privacy knowledge, attitudes, behaviors, strategies, and organizational conditions. Results: Respondents strongly recognize privacy as a fundamental right and frequently handle personal and sensitive data in their daily work. Core strategies such as encryption, data minimization, anonymization, risk management, and user control are perceived as very important and are more often applied, whereas decentralization, data sovereignty, and temporality remain uncommon and are more difficult to implement. Inferential analysis using Spearman’s rank correlation indicates that the adoption of privacy strategies is significantly associated with perceived importance (ρ = 0.37, p = 0.005), while organizational, social, and usability-related factors show no statistically significant associations. Conclusion: PbD maturity in IFES remains incipient, characterized by fragmented and reactive practices driven more by individual perceptions than by institutional structures. Advancing this maturity requires structured training, clearer roles and responsibilities, better tool support, and strategies that reinforce the perceived importance of privacy among practitioners.

More than one million test smells: how are Dart projects and their sentiments?

Tássio Virgínio — 2026-08-07

Objective: This study investigates the quality of tests and the associated sentiments in Dart, the primary language for mobile application development with the Flutter framework. Methods: The study begins by using the DNose tool to detect 14 types of test smells in code written in the Dart language, along with their associated sentiments. Next, we evaluate the tool in terms of precision, recall, accuracy, and F1-score. Using this tool, we conduct a detailed analysis of tests in open-source projects extracted from the language’s central repository. Results: The study starts with a dataset of 5,410 Dart projects, from which 4,154 repositories were successfully cloned after processing. Based on the cloned projects, we generated a dataset containing 1,115,938 occurrences of test smells and their associated sentiments. The analysis allowed us to characterize the most frequently encountered test smells and identify their causes. We observed the presence of test smells in 77% of test files. Another key characteristic observed in the analyzed projects was the scarcity of tests: 1,873 projects had one or no tests, which led us to expand the analysis to a broader base. In addition, we analyzed the relationship between developers’ sentiments and the identified test smells, enabling us to classify test smells according to sentiment. Conclusion: This research makes a significant contribution by providing in-depth insights into the quality of tests and associated sentiments in projects from Dart’s official repository, as well as offering an open-source tool for detecting 14 types of test smells and their associated sentiments.

Ethical Literacy in Computing Education under the Pressure of Generative AI: A Mixed-Methods Study of Students and Educators in Brazil

Felippe Carvalho e Kipman — 2026-08-07

Context The rapid expansion of Artificial Intelligence (AI), particularly Generative AI, has intensified ethical challenges in computing education, exposing tensions between technical training and ethical responsibility. While ethical principles are widely endorsed in international AI governance frameworks, their effective integration into computing curricula remains uneven, especially in Global South contexts. Goal This study investigates the ethical literacy of undergraduate computing students and examines how educators perceive their role, institutional constraints, and pedagogical challenges in fostering ethics education under the pressure of Generative AI. Method We adopted a sequential explanatory mixed-methods design. First, a survey with 56 undergraduate computing students at the University of Brasília (UnB) examined familiarity with 21 AI ethical principles, perceived relevance, and curricular exposure. Second, semi-structured interviews with 31 computing educators explored how ethics integration has evolved, the impact of Generative AI on teaching practices, perceived student ethical maturity at graduation, and structural barriers to effective ethics education. Quantitative data were analyzed descriptively, and qualitative data were examined through iterative coding procedures. \textbf{Results}: Students demonstrated strong agreement regarding the importance of ethical principles in computing and reported high self-perceived preparedness to assess social impacts. However, a clear gap emerged between perceived importance and formal curricular exposure. Educators, in turn, identified Generative AI as an operational accelerator that intensified assessment reconfiguration, academic integrity concerns, and accountability tensions. Interviews also revealed a dominant perception of low ethical maturity at the transition to professional practice, alongside systemic barriers including curricular overload, limited faculty preparation, and institutional governance gaps. Conclusions: The findings suggest the existence of a structural ethical literacy gap in computing education, reinforced by curricular fragmentation and insufficient institutional support, and amplified by the rapid integration of Generative AI. Addressing this gap requires coordinated curricular reform, faculty development, and institutional governance strategies that integrate ethical reasoning as a core technical competency rather than a peripheral concern. This competency is particularly important for future software engineers who must evaluate AI-generated artifacts, assume accountability for AI-supported engineering decisions, and negotiate socio-technical trade-offs throughout the software lifecycle.

Metamorphic Fairness Testing of Retrieval-Augmented Generation: Diagnosing Retriever Bias and Evaluating Graph-based Mitigation

Matheus Oliveira — 2026-08-04

Fairness is an under-tested quality attribute in Artificial Intelligence (AI)-enabled software systems. Retrieval-Augmented Generation (RAG) pipelines in production software pose a critical testing challenge: the retriever, as an upstream component, can exhibit demographic sensitivity that propagates defects across downstream stages. Yet most test suites target only relevance and factuality, leaving fairness systematically untested. Applying metamorphic testing (MT) is well-suited here since, as an oracle-free technique, it checks whether semantically neutral input transformations such as demographic perturbations preserve system outputs. This exposes fairness violations without requiring ground-truth labels. This paper presents a two-stage empirical study that applies MT to RAG pipelines as a component-level software testing problem. In the Bias Diagnosis stage, we treat the retriever as a first-class test artifact and apply 21 controlled demographic metamorphic relations across four categories to three Small Language Models (SLMs). In the Mitigation Assessment stage, we perform regression testing to determine whether graph-enhanced retrieval affects relevance and fairness. At this stage, the results show that graph-based retrieval is fairness-neutral. Only the 3B model degrades significantly under graph reranking (p = 0.0005), while larger models remain unaffected (p > 0.14), a model-specific regression effect invisible to aggregate testing. The change in Attack Success Rate (ASR) between flat retrieval and graph reranking is ΔASR = +-0.0008: the architectural change passes relevance regression but leaves the demographic-bias defect unmitigated, neither correcting nor worsening fairness. Together, these test stages yield implications for software testing practice: (i) RAG fairness testing must be component-level, not end-to-end only; (ii) retrieval enhancements such as graph reranking require independent fairness regression testing per model; (iii) discard retrieval stability as a promising lightweight, Graphics Processing Unit (GPU)-free signal for fairness-oriented monitoring in Continuous Integration / Continuous Deployment (CI/CD) workflows; and (iv) fault mitigation should target the embedding stage, since downstream architectural change evaluated here did not affect fairness. We provide a reusable MT test framework and grounded thresholds to help practitioners integrate fairness testing into RAG development workflows.

Teaching Micro Frontends: Insights from Two Controlled Experiments on Guidelines and Anti-patterns

Nabson Silva — 2026-05-18

Context: Micro Frontend (MFE) is an architectural style that extends microservices principles to the frontend. Despite its growing adoption, misunderstandings about MFE foundations can create significant challenges during development. Preparing in-training software engineers to address these challenges and incorporating MFE into software architecture curricula is essential. Goal: We aim to address the gap in MFE education by presenting an experience report on teaching MFE in an undergraduate course. We compare two supporting materials to aid students in architectural decision-making: practitioner-provided guidelines and a catalog of MFE anti-patterns. Through two controlled experiments, we evaluate their effectiveness, with particular emphasis on understanding the role and benefits of using anti-patterns as a learning tool. Method: We taught MFE across five sessions and conducted a controlled experiment with two assessments, each one using one of the supporting materials. We compared them by analyzing differences in assessment scores and evaluated whether the catalog improved students' perceived learning. Additionally, we investigated how students used the catalog by applying the Technology Acceptance Model and collecting qualitative feedback regarding its use. Finally, we extend our previous work by introducing a new version of the catalog and comparing it with the original through a second controlled experiment. Results: Both supporting materials are equally helpful for solving MFE architectural problems. Students reported an increased perception of learning after engaging with the catalog. Their feedback indicated that the catalog was used to identify problems and solutions, promote efficient search for issues, and reinforce MFE knowledge. The results of the second experiment show no statistically significant differences between the versions. However, qualitative feedback indicates that preferences depend on individual reading styles and information needs. It also revealed additional ways students use the catalog to learn about MFE, such as using anti-patterns as a third learning phase. Conclusion: This paper provides insights into teaching MFE, introduces two supporting instructional materials, and highlights the value of anti-pattern catalogs for both education and practice. Our findings show that the catalog can support learning while also helping developers analyze architectural problems and make more informed decisions.

ResilienceBench-Operator: A Kubernetes Extension for Systematic Evaluation of Microservice Resilience Patterns

Carlos M. Aderaldo — 2026-07-17

Microservice-based applications commonly employ resilience mechanisms such as Retry and Circuit Breaker to mitigate failures in service-to-service communication, yet configuring these mechanisms involves complex trade-offs between reliability and latency. Systematically evaluating these trade-offs in cloud-native Kubernetes environments remains a challenge due to the lack of tools supporting controlled, reproducible resilience experimentation. This paper presents ResilienceBench-Operator, a Kubernetes-native extension of the original ResilienceBench framework that enables in situ benchmarking of resilience mechanisms directly on microservice applications deployed in Kubernetes. The operator preserves the declarative evaluation-space model of ResilienceBench while integrating scenario generation, environment reconfiguration, fault injection, workload execution, and metric collection into Kubernetes through Custom Resource Definitions, controllers, and jobs. The paper formalizes the underlying scenario-based evaluation model, details the design and implementation of the operator, and demonstrates its capabilities through a controlled benchmark experiment on the Online Boutique application, covering hundreds of automatically orchestrated evaluation scenarios across multiple workloads, failure levels, and retry configurations. The experimental results reveal nuanced performance--reliability trade-offs and show, through Pareto-frontier and correlation-based analyses, how retry parameters affect checkout success and tail latency under different downstream failure and workload conditions. The paper also discusses practical challenges encountered when conducting controlled experiments in Kubernetes and extracts lessons that can guide future benchmarking efforts in this area.

Assessing the Effectiveness of Large Language Models in Detecting Semantic Conflicts

Nathalia Barbosa — 2026-08-06

Semantic conflicts occur when a developer introduces changes to a codebase that unintentionally affect the behavior of changes integrated in parallel by other developers. Since merge tools used in practice cannot detect this type of conflict, complementary tools have been proposed, such as SAM (SemAntic Merge), based on the SMAT approach and relies on the generation and execution of unit tests in Java. Despite showing good conflict detection capabilities, SAM presents a high rate of false negatives (existing conflicts not signaled by it). Part of this problem is due to the natural limitations of unit test generation tools, specifically Randoop and EvoSuite. To understand if these limitations can be overcome by large language models (LLMs), this work proposes, and integrates into SMAT, LUCIA (LLM-based Unit-tests for Conflict Identification & Analysis), a new test generation tool based on the Ollama framework to interface with various local LLMs, including the Llama, Gemma, DeepSeek, and Qwen families. We then explore these models' capability to generate tests, using different interaction strategies, prompts with different contents, and different model parameter configurations. We evaluate the results with two distinct samples: a benchmark with simpler systems, used in related work, and a more significant sample based on complex systems used in practice. Finally, we evaluate the effectiveness of LUCIA in detecting conflicts, comparing the selected LLMs with each other and against the original test generation tools used by SAM: Randoop, Randoop Clean, EvoSuite, and Differential EvoSuite. Our evaluation shows that LLMs effectively detect semantic conflicts, with Llama and Qwen outperforming the other models. While no single model could surpass traditional tools, multiple models combined achieved superior performance in conflict detection. Overall, the new extension identified three additional conflicts undetected by SAM, representing a 200% improvement in identifying unique conflicts compared to the single-model approach (Code Llama 70B) used in our previous work. These results reinforce previous findings that LLMs can generate unit tests that are effective in detecting semantic conflicts, while demonstrating the superior effectiveness of multi-model approaches.