Anais do Simpósio Brasileiro de Engenharia de Software (SBES)
Este documento traz o front matter dos Anais do SBES 2025.
FOSTER Taxonomy-based Open Science-Related Practices in Software Engineering: Review and Observations
The Open Science (OS) movement, primarily led by UNESCO, advocates for making research and its outcomes accessible to everyone. This movement has explored various issues across different fields, including reproducibility, experimentation, design science methodologies, and education, to provide access to research resources and discoveries. While the adoption of OS principles and practices in Software Engineering (SE) is increasing, it is still in its early stages, prompting further investigation into the topic. This paper aims to identify OS concepts, practices, and challenges related to their implementation in SE. To achieve this, we performed a Scoping Review Study of the literature. The main findings highlighted several OS-related practices in SE, categorized into Open Data, Open Platforms, Open Review, Open Access, Artifact Sharing, and Open Source. Additionally, challenges were noted in applying these practices. These findings culminated in a series of observations intended to support the adoption of OS in SE.
Measuring how changes in code readability attributes affect code quality evaluation by Large Language Models
Code readability is one of the main aspects of code quality, influenced by various properties like identifier names, comments, code structure, and adherence to standards. However, measuring this attribute poses challenges in both industry and academia. While static analysis tools assess attributes such as code smells and comment percentage, code reviews introduce an element of subjectivity. This paper explores using Large Language Models (LLMs) to evaluate code quality attributes related to its readability in a standardized, reproducible, and consistent manner. We conducted a quasi-experiment study to measure the effects of code changes on Large Language Model (LLM)s’ interpretation regarding its readability quality attribute. Nine LLMs were tested, undergoing three interventions: removing comments, replacing identifier names with obscure names, and refactoring to remove code smells. Each intervention involved 10 batch analyses per LLM, collecting data on response variability. We compared the results with a known reference model and tool. The results showed that all LLMs were sensitive to the interventions, with agreement with the reference classifier being high for the original and refactored code scenarios. However, this agreement diverged for the other two interventions. The LLMs demonstrated a strong semantic sensitivity that the reference model did not fully capture. A thematic analysis of the LLMs’ reasoning confirmed their evaluations directly reflected the nature of each intervention. The models also exhibited response variability, with 9.37% to 14.58% of executions showing a standard deviation greater than zero, indicating response oscillation, though this did not always compromise the statistical significance of the results. LLMs demonstrated potential for evaluating semantic quality aspects, such as coherence between identifier names, comments, and documentation with code purpose. Further research is needed to compare these evaluations with human assessments and explore real-world application limitations, including cost factors.
LLMs as Test Generators: A Comparative Benchmarking Study
Automated tests are a key practice adopted by the software industry to verify software quality. However, they are costly to develop and maintain. Recently, the use of LLMs to generate automated tests has been explored as a viable alternative. Ongoing efforts focus on improving generation by providing richer context and post-processing the output to correct errors, ensuring accurate results. However, small-scale open LLMs, capable of running on modest hardware, have received limited attention. This work compares large-scale LLMs (e.g., GPT and Gemini) with small-scale open-source models in terms of the number of tests generated and their quality, measured by the mutation score, the cyclomatic complexity of generated code, and the number of test smells on them. We evaluated 12 small-scale models against 6 large-scale ones and used EvoSuite to establish a baseline for code quality and the number of methods tested. Our results show that some small-scale LLMs perform well in test generation tasks. xLan, Gemma2, and DeepSeekCoder gave the best overall results, producing as many tests as large-scale models, with fewer smells and a better mutation score.
Investigating the Impact of GitHub Discussions on Maintainers’ Workload and Community Dynamics
The introduction of GitHub Discussions, a space for informal communication on GitHub, offers open-source communities a mechanism for engaging contributors beyond traditional issue tracking and code review. While promising, the specific effects of GitHub Discussions on project sustainability, contributor integration, and collaboration dynamics remain underexplored. This study investigates the impact of GitHub Discussions across four high-activity OSS projects by examining (1) changes in maintainers’ workload, (2) newcomer participation and progression from GitHub Discussions to technical contribution, and (3) the evolving structure of social and technical roles in project collaboration networks. Using data from the GitHub API, we collected and analyzed issues, pull requests, and discussions over a 48-month period.We applied linear regression and longitudinal social network analysis to evaluate participation trends and role centrality. Our results show that GitHub Discussions had limited impact on overall maintainer workload but served as a valuable entry point for newcomers, with a subset transitioning into impactful technical contributors. Nearly 80% of these newcomers had pull requests accepted, and many became active reviewers. In addition, GitHub Discussions enabled a shift in collaboration patterns, with non-core contributors increasingly occupying central positions in project networks. These findings underscore the strategic role of GitHub Discussions in supporting more inclusive, distributed, and sustainable OSS collaboration. GitHub Discussions help lower entry barriers, foster long-term contributor engagement, and redistribute influence beyond core teams. Future research should explore how discussion dynamics influence project governance, contributor retention, and the integration of non-code contributions into project health metrics.
Socio-Technical Smell Dynamics in Code Samples: A Multivocal Review of Their Emergence, Evolution, and Co-Occurrence
Context and Motivation: Code samples play an important role in open-source ecosystems (OSSECO), serving as lightweight artifacts that support knowledge transfer, onboarding, and framework adoption. Despite their instructional relevance, these samples are often governed informally, with minimal review and unclear ownership, which increases their exposure to socio-technical degradation. In this context, the co-occurrence and longitudinal interplay of code smells and community smells become particularly relevant. While each type of smell has been studied in isolation, little is known about how community-level dysfunctions anticipate or exacerbate technical anomalies in code samples over time. Objective: This study investigates how code and community smells emerge, cooccur, and evolve within code samples maintained in OSSECOs. Method: A Multivocal Literature Review protocol was applied, encompassing 18 peer-reviewed papers and 17 practitioner-oriented sources (2013–2024). Thematic synthesis was conducted to identify recurring socio-technical patterns. Results: Nine patterns were identified, showing that community smells often precede or reinforce technical degradation in code samples. Symptoms such as "radio silence" and centralized ownership were frequently associated with persistent structural anomalies. Additionally, limited onboarding, the absence of continuous refactoring, and informal collaboration emerged as recurring conditions for smell accumulation. Conclusion: In OSSECOs, particularly within code samples, community-level dysfunctions not only correlate with but often signal maintainability decay. These findings underscore the need for socio-technical quality indicators and lightweight governance mechanisms tailored to shared instructional artifacts.
Explorando a Influência da Segurança Psicológica na Qualidade do Software em Equipes Ágeis
As metodologias ágeis já são amplamente adotadas no desenvolvimento de software e sua utilização continua em expansão à medida que mais empresas reconhecem a importância de ambientes de trabalho que promovam confiança, colaboração e inovação. A segurança psicológica, nesse cenário, é vista como um elemento essencial para o desempenho de equipes, fomentando abertura ao diálogo, aprendizagem com erros e cooperação técnica, fatores que impactam diretamente a qualidade dos produtos desenvolvidos. Este artigo analisa de que maneira a segurança psicológica pode influenciar à qualidade de software em equipes ágeis brasileiras, por meio da replicação de um survey previamente validado. A coleta de dados foi realizada por meio de questionário estruturado contendo sete construtos-chave. No total, foram obtidas 92 respostas válidas de profissionais que atuam em equipes ágeis no Brasil, sendo 79 delas provenientes do estado de Pernambuco. Os resultados apontam que os construtos “aprender com os erros”, “colaboração” e “resolver problemas coletivamente” obtiveram os maiores níveis de concordância, refletindo práticas maduras de trabalho em equipe e melhoria contínua. Como contribuição prática, este trabalho oferece às lideranças e equipes ágeis insights sobre como fortalecer a segurança psicológica em seus times, promovendo ambientes mais seguros, colaborativos e de alto desempenho.
Combining TSL and LLM to Automate REST API Testing: A Comparative Study
The effective execution of tests for REST APIs remains a considerable challenge for development teams, driven by the inherent complexity of distributed systems, the multitude of possible scenarios, and the limited time available for test design. Exhaustive testing of all input combinations is impractical, often resulting in undetected failures, high manual effort, and limited test coverage. To address these issues, we introduce RestTSLLM, an approach that uses Test Specification Language (TSL) in conjunction with Large Language Models (LLMs) to automate the generation of test cases for REST APIs. The approach targets two core challenges: the creation of test scenarios and the definition of appropriate input data. The proposed solution integrates prompt engineering techniques with an automated pipeline to evaluate various LLMs on their ability to generate tests from OpenAPI specifications. The evaluation focused on metrics such as success rate, test coverage, and mutation score, enabling a systematic comparison of model performance. The results indicate that the best-performing LLMs – Claude 3.5 Sonnet (Anthropic), Deepseek R1 (Deepseek), Qwen 2.5 32b (Alibaba), and Sabiá 3 (Maritaca) – consistently produced robust and contextually coherent REST API tests. Among them, Claude 3.5 Sonnet outperformed all other models across every metric, emerging in this study as the most suitable model for this task. These findings highlight the potential of LLMs to automate the generation of tests based on API specifications.
Aged to Perfection? Analyzing the Impact of Years of Experience on Code Quality
The association between developer experience and code quality is a significant debate within the software engineering community. To explore this relationship, we quantitatively evaluated 401 GitHub software repositories in JavaScript, PHP, and Python, maintained by 98 developers with Workana profiles – a freelancing platform. For quality assessment, we rely on SonarQube, a widely adopted tool in both industry and academia. We analyzed several dimensions, such as the programming languages and severity (high, medium, and low) of maintainability and reliability issues. We observed that developers with the highest level of experience presented code with fewer issues. However, developers with intermediate level of experience presented more code quality issues than their novice and experienced counterparts, revealing a more complex and nuanced relationship between level of experience and code quality. Despite that, our analysis did not indicate significant statistical differences between the density of the issue at varying levels of experience, suggesting that other factors may also contribute to code quality outcomes. This study contributes to an open question with implications for software engineering recruitment and code quality assurance.We provide a new dataset of developers and their projects based on recent data. All extracted data and accompanying scripts are available, aiming to enable further replications of our study.
Building the Landing Zone for Site Reliability Engineering: A Multivocal Literature Review
In the era of software-intensive business (SiB), the interdependence between business and software is increasingly prominent. Organizations at the forefront of the digital revolution rely on complex systems to deliver innovative services and products. One of the major challenges is maintaining 24/7 online applications with consistent performance, a task that falls to both the development (Dev) and operations (Ops) teams. Traditionally, Dev focuses on innovation and new features, while Ops ensures the stability of the applications. This division leads to reliability gaps, especially in systems where availability is critical, such as financial services, e-commerce, or mission-critical applications. In such contexts, Site Reliability Engineering (SRE) offers a structured approach that applies Software Engineering (SE) practices to Ops, promotes reliability management through service-level objectives and error budgets, and reduces toil through automation. Given that several emerging practices in SRE occur outside scientific literature, we choose a multivocal approach to capture both theoretical advances and practical experiences. Our work aims to investigate what the multivocal literature is saying about the SRE approach, building the landing zone (a comprehensive foundation) for further studies. Thus, a multivocal literature review (MLR) was performed to identify practices, tools, benefits, and future perspectives from the point of view of researchers and practitioners.We selected 28 studies after applying the review procedures. Based on the results, we categorized SRE practices using the Stacey matrix to guide organizations in prioritizing their adoption. In addition, we propose a Flywheel model to illustrate the iterative and continuous nature of the SRE implementation.
Rumo a um Catálogo de Anti-padrões de Observabilidade: Uma Revisão da Literatura
Os sistemas de software modernos são cada vez mais construídos sobre arquiteturas de microsserviços para alcançar maior escalabilidade, modularidade e suporte à entrega contínua. Embora esse estilo arquitetural simplifique o desenvolvimento, ele também introduz considerável complexidade operacional, tornando as falhas do sistema mais frequentes e difíceis de diagnosticar. Para lidar com esses desafios, a observabilidade tornou-se uma prática fundamental, permitindo a introspecção do sistema por meio de logs, métricas e traces. No entanto, apesar de seu papel crítico, a observabilidade muitas vezes é implementada de forma inadequada devido à ausência de diretrizes padronizadas, levando a monitoramento ineficaz, fadiga de alertas e redução da eficiência na resposta a incidentes. Embora pesquisas existentes abordem ferramentas, conceitos e desafios da observabilidade, nenhum trabalho anterior focou especificamente na identificação e análise de anti-padrões de observabilidade. Como consequência, decisões de projeto e implementação são frequentemente tomadas sem uma compreensão clara dos erros mais comuns, resultando em soluções ruins. Este artigo apresenta os resultados de uma revisão sistemática da literatura combinada com uma revisão da literatura cinzenta, culminando em um catálogo de 37 anti-padrões de observabilidade. Cada anti-padrão é descrito de forma sucinta, destacando como ele tipicamente se manifesta e oferecendo estratégias de refatoração acionáveis para mitigar seus efeitos. Nossos resultados mostram que o catálogo serve como um recurso valioso para ajudar equipes a reconhecer e abordar problemas recorrentes de observabilidade em sistemas baseados em microsserviços.
Evaluating Fine-tuning Approaches for Duplicate Bug Report Detection
Bug reports are artefacts that document defects encountered by users or developers. Rapid testing and release cycles often lead to the creation of similar or near-duplicate bug reports, introducing redundancy, delaying triage, and increasing maintenance overhead. Although prior research has extensively explored automated methods to detect and manage duplicate bug reports, their natural language nature makes recent advances in large language models (LLMs)—particularly BERT and its successors—a promising avenue for improving robustness and accuracy. In this study, we investigate the use of LLMs to identify duplicate bug reports (DBRs), focusing on the impact of fine-tuning an all-mpnet-base-v2 model, which builds on BERT-based architectures while addressing several of their limitations. We fine-tuned the model using large, open-source bug tracking datasets from the Eclipse, OpenOffice, Firefox, and NetBeans projects. Our evaluation shows that fine-tuning yields only marginal performance improvements across all datasets. We also discuss the trade-offs involved in fine-tuning LLMs for this task, including hyperparameter tuning guidelines and the practical challenges posed by computational and financial cost.
Generating Proto-Personas through Prompt Engineering: A Case Study on Efficiency, Effectiveness and Empathy
Proto-personas are commonly used during early-stage Product Discovery, such as Lean Inception, to guide product definition and stakeholder alignment. However, the manual creation of protopersonas is often time-consuming, cognitively demanding, and prone to bias. In this paper, we propose and empirically investigate a prompt-engineering-based approach to generate proto-personas with the support of Generative AI (GenAI). Our goal is to evaluate the approach in terms of efficiency, effectiveness, user acceptance, and the empathy elicited by the generated personas. We conducted a case study with 19 participants embedded in a real Lean Inception, employing a qualitative and quantitative methods design. The results reveal the approach’s efficiency by reducing time and effort and improving the quality and reusability of personas in later discovery phases, such as Minimum Viable Product (MVP) scoping and feature refinement. While acceptance was generally high, especially regarding perceived usefulness and ease of use, participants noted limitations related to generalization and domain specificity. Furthermore, although cognitive empathy was strongly supported, affective and behavioral empathy varied significantly across participants. These results contribute novel empirical evidence on how GenAI can be effectively integrated into software Product Discovery practices, while also identifying key challenges to be addressed in future iterations of such hybrid design processes.
An Ontology-based Approach for Developing Systems to Identify Who Knows What in Software Organizations
Context: Software development is a knowledge-intensive process, and its success in an organization relies deeply on knowledge sharing. Knowledge management challenges are often increased in agile environments, which involve a lot of tacit knowledge, commonly acquired through experiences and hard to make explicit. Thus, knowledge sharing among practitioners is crucial. However, identifying suitable experts to share specific knowledge is not trivial. It involves not only discovering the individuals with the desired knowledge but also considering other factors that may improve the expert’s responsiveness, such as social connections and availability. Moreover, the data overload problem and the specific nature of the experts’ knowledge can hinder people from finding experts with the required knowledge. Expert-finding systems address this issue by identifying and ranking experts. Developing such systems is challenging and involves complex concepts such as expertise, skill, and knowledge, among others. Additionally, integrating diverse heterogeneous sources that offer evidence of expertise poses a difficulty. Ontologies can be helpful in this matter by providing semantics to data and addressing semantic conflicts that can lead to data misuse or misinterpretation. Objective: We aim to help organizations develop expert-finding systems to identify who knows what in a software organization considering data stored in the organization repositories and non-technical factors that may affect knowledge sharing. Method:We developed iKnow, an ontology-based approach that supports developing systems that use data on skill manifestations to identify who knows what. Results: iKnow was applied to develop the ExpertFY system, which was used by members of a software organization. ExpertFY helped identify experts the members had not identified themselves. Conclusion: the results suggest that iKnow is a useful and promising approach to developing expertfinding systems and ExpertFY improves the identification of who knows what.
Designing Mutation Operators for Android Device Components: A View Through Bluetooth and Location API’s
Context: Mutation operators play a crucial role during the mutation testing process due to their capability to model common faults to be injected into an application under test. In the context of the Android OS, the academic literature shows that different studies propose mutation operators, especially focusing on the GUI and configuration. On the other hand, few devise mutation operators for specific Android device resource components such as connectivity, location, and sensors. Objective: Therefore, this paper aims to investigate the design and proposition of mutation operators for Bluetooth, Location, and the third-party library AltBeacon. The rationale is that this paper is carried out in an academia-industry partnership, in which the company develops applications that rely on these Android components. Method: The design process used a systematic approach named HAZOP to minimize any possible bias. Results: This systematic process helped in deriving a set of 16 mutation operators. Next, the paper provides an empirical cost evaluation that assesses the number of generated mutants for two applications and the number of generated mutants per operator, showing the feasibility of the mutation operators and their capabilities in modeling real faults. Conclusion: Finally, the paper discusses the future perspectives of extending the operators to other device resource components such as Wi-Fi, NFC, and sensors, as well as automation perspectives by envisioning the implementation and validation of the mutation operators.
Threat Modelling and Vulnerability Assessment for IoT Solutions: A Case Study
Security in Internet of Things (IoT) systems is increasingly critical due to their growing adoption and complexity. This study investigates how threat modelling and vulnerability assessment are applied in industrial IoT development. We conducted a single-case study with an IoT consultancy company, combining semi-structured interviews with practitioners and analysis of development artefacts from a real-world IoT project. Our findings show that while threat identification is practiced, formal methodologies like STRIDE are only used selectively, and integration into the development process is informal and ad hoc. Vulnerability assessment also lacks systematic approaches for discovery, classification, and testing, often relying on expert judgment and external tools. We identify key attack surfaces and common security weaknesses, and highlight gaps in documentation and testing integration. The study contributes practical recommendations for improving security practices and provides a curated list of open-source penetration testing tools. These insights support more structured and proactive security strategies in IoT development.
A Comparative Study of LLMs for Gherkin Generation
[Context] Behavior-Driven Development (BDD) is widely adopted, but the manual creation of Gherkin scenarios remains a significant bottleneck. While Large Language Models (LLMs) show promise for automation, there is a lack of empirical evidence on their accuracy and stability when converting free-form test descriptions into structured Gherkin, creating risks for industrial adoption. Manual scenario authoring is also time-consuming and prone to inconsistencies, leading to miscommunication between technical and non-technical stakeholders and impacting software quality assurance. [Objective] This study addresses this gap by investigating the use of LLMs to automate the generation of Gherkin-based BDD scenarios from real-world, free-form test case descriptions. The goal is to assess the robustness of current models when handling informal, ambiguous, and diverse inputs typically found in practice. [Method]We conducted a comparative evaluation involving seven LLMs — GPT-3.5 Turbo, GPT-4 Turbo, GPT-4o Mini, LLaMA 3, Phi-3, Gemini, and DeepSeek R1 — using zero-shot, one-shot, and fewshot prompting strategies. The models generated BDD scenarios from a stratified sample of ten test descriptions selected from a corpus of 1,286, ensuring diversity in structure and domain complexity. We assessed quality and consistency using quantitative metrics (METEOR, variability analysis) and Repeated Measures ANOVA to test statistical significance. [Results] The analysis revealed that simple zero-shot prompting was highly effective, achieving results comparable to more complex example-based prompting. For the topperforming model, Gemini, which balanced accuracy and stability, the difference between zero-shot and few-shot was not statistically significant. Performance differences across models were often small, suggesting that practical factors like integration and cost should also guide model choice. Some models showed higher output variability, raising concerns about consistency in test generation workflows. [Conclusion] This paper offers practical insights into prompt design and model selection for LLM-based BDD scenario generation. Results show that effective zero-shot prompts can enable scalable, high-quality generation comparable to more complex techniques, simplifying LLM adoption in industrial testing. These findings suggest that LLMs can be leveraged with minimal setup to streamline BDD, reduce costs, and accelerate validation cycles.
Bugs in the Shadows: Static Detection of Faulty Python Refactorings
Python is a widely adopted programming language, valued for its simplicity and flexibility. However, its dynamic type system poses significant challenges for automated refactoring – an essential practice in software evolution aimed at improving internal code structure without changing external behavior. Understanding how type errors are introduced during refactoring is crucial, as such errors can compromise software reliability and reduce developer productivity. In this work, we propose a static analysis technique to detect type errors introduced by refactoring implementations for Python. We evaluated our technique on Rope refactoring implementations, applying them to open-source Python projects. Our analysis uncovered 29 bugs across four refactoring types from a total of 1,152 refactoring attempts. Several of these issues were also found in widely used IDEs such as PyCharm and PyDev. All reported bugs were submitted to the respective developers, and some of them were acknowledged and accepted. These results highlight the need to improve the robustness of current Python refactoring tools to ensure the correctness of automated code transformations and support reliable software maintenance.
Identifying and Addressing Test Smells in JavaScript: A Developer-Centric Study
Test smells are poor practices in test code that can compromise maintainability, reliability, and clarity. While the concept has been widely studied in languages such as Java and Python, research on test smells in JavaScript remains limited—despite its prominence in modern development. To address this gap, we conducted a focus group study with JavaScript developers of varying experience levels to explore their perceptions of seven test smells. These smells—Anonymous Test, Comments Only Test, Overcommented Test, General Fixture, Test Without Description, Transcripting Test, and Sensitive Equality—are particularly relevant to the JavaScript ecosystem and had not been systematically examined in this context prior to our study. We applied thematic analysis to transcribed discussions, uncovering developers’ concerns, recognition patterns, and proposed mitigation strategies. Our results show that experience level strongly influences the ability to detect and refactor test smells, with junior developers often struggling to identify more subtle patterns. To the best of our knowledge, this is the first study to investigate JavaScript developers’ perceptions of test smells using a qualitative approach. Our findings reveal key challenges, offer practical insights for test improvement, and support the development of better training and tooling for JavaScript test quality.
Choosing the Right GitWorkflow: A Comparative Analysis of Trunk-based vs. Branch-based Approaches
Git has become one of the most widely used version control systems today. Among its distinguishing features, its ability to easily and quickly create branches stands out, allowing teams to customize their workflows. In this context, various formats of collaborative development workflows using Git have emerged and gained popularity among software engineers. We can categorize such workflows into two main types: branch-based workflows and trunk-based workflows. Branch-based workflows typically define a set of remote branches with well-defined objectives, such as feature branches, a branch for feature integration, and a main branch. The goal is to migrate changes from the most isolated branch to the main one shared by all as the code matures. In this category, GitFlow stands out as the most popular example. In contrast, trunkbased workflows have a single remote branch where developers integrate their changes directly. In this range of options, choosing a workflow that maximizes team productivity while promoting software quality becomes a non-trivial task. Despite discussions on forums, social networks, and blogs, few scientific articles have explored this topic. In this work, we provide evidence on how Brazilian developers work with Git workflows and what factors favor or hinder the use of each model. To this end, we conducted semistructured interviews and a survey with software developers. Our results indicate that trunk-based development favors fast-paced projects with experienced and smaller teams, while branch-based development suits less experienced and larger teams better, despite posing management challenges.
A Real-time Data Synchronization Approach for High-availability Micro Applications
The Microservice Architecture (MSA) and the Micro Frontend Architecture (MFA) are scalable, flexible, and innovative architectures for developing micro applications (MApps). The integration of these architectures optimizes development by leveraging the strengths of both architectural styles, enabling decoupled deployment, specialized domain teams, isolated failures, scalability, and software maintenance. To the best of our knowledge, the engineering of applications based on MFA poses significant challenges, as practitioners encounter difficulties because of the dependency generated between MApps. This dependency arises from the data sharing between microservice-based applications. In a real-world execution scenario, such applications require substantial data volumes and distributed databases across microservices. While the microservices are designed to communicate via a network using lightweight communication protocols, the data interchange is relatively slow compared to the database communication. Based on the presented context, this paper proposes a real-time data synchronization approach to address the limitations of MApps development concerning communication and data replication. In order to evaluate the applicability, strengths, and weaknesses of the proposed approach, a proof of concept was conducted for a condominium management system. As a result, the evidence gathered in this paper enables us to create a favorable perspective to contribute efficiently to the MApps domain by providing an approach to this research area and an empirical evaluation for researchers and practitioners.
Continuously Managing Microservice Granularity: An Evidence-Based Industrial Approach
Defining and managing appropriate service granularity remains a recurring challenge in the design and evolution of microservices-based systems, directly affecting modularity, maintenance, and operational efficiency. This paper presents early empirical evidence supporting Granulify, a continuous granularity-management approach that dynamically adjusts service boundaries throughout the system lifecycle. Although still preliminary, the results already point to tangible benefits in modularity, maintainability, and operational cost, underscoring the method’s industrial applicability. The proposal is being validated through the reengineering of a real-world investment management platform from a major financial institution in Brazil. The analysed platform manages over 40 million transactions monthly and supports more than 250K internal users across investment, compliance, and trading domains. Preliminary results indicate patterns of architectural fragmentation, productivity impacts, and signs of granularity saturation. We believe that continuous application of this approach will contribute to more informed architectural decisions, balancing modularity, maintenance effort, and operational costs. This ongoing research aims to consolidate Granulify as a practical solution to support teams in the evolutionary management of granularity in microservices architectures.
“Frustrating, Stressful, and Overwhelming”: Insights into Software Practitioners’ Productivity from Stack Exchange Discussions
Context: Productivity is a central concern in software engineering, but traditional approaches often overlook the human aspects of daily work. Aims: To investigate how software practitioners perceive productivity challenges and how they impact their well-being and their tasks. Method: We conducted a thematic analysis of grey literature, drawing from discussions in two Stack Exchange communities (Software Engineering and Project Management). Results: We identified 21 factors that affect productivity, emphasizing time management, adopting new standards and technologies, difficulty measuring productivity, and context switching. These challenges reflect technical issues and human concerns such as demotivation and psychological pressure, showing that productivity cannot be understood in isolation. The study also revealed 17 direct impacts on professionals, including stress and perceived fluctuations in productivity, and 8 impacts on tasks, such as delays and rework. Conclusion: This study offers a broader understanding of productivity in software engineering by connecting technical and human factors. It highlights the value of grey literature in uncovering underexplored dimensions of practitioners’ experiences.
Science Communication of Brazilian Software Engineering Research on LinkedIn
This study investigates how Brazilian Software Engineering Research is communicated on LinkedIn, a professional social network, by analyzing the characteristics of posts, the profile of communicators and the interactions received by posts. We used web scraping and manual classification techniques to collect, extract and process attributes related to the content of posts, authors, and interactions. A total of 336 posts referring to scientific software engineering conferences (SBES, SBQS, CIBSE, and ICSE) were extracted and analyzed, and 172 were identified as being related to science communication. Our results suggest that science communication is predominantly carried out by individual profiles, with a greater frequency of industry professionals, with self-promotion being the main goal of the posts analyzed. We also observed extensive use of visual resources and the limited use of scientific elements that facilitate the understanding of research, such as methodologies and research results. These findings suggest that, although LinkedIn can broaden the reach of science communication, this still requires further improvement. Accordingly, we present recommendations to make scientific content more accessible, effective and engaging on LinkedIn.
LSTM-based Forecasting for Non-linear Workloads in On-premises Software Systems
Cloud computing has become a commonly adopted solution to increase business operations efficiency and scalability. However, costs related to cloud infrastructure are increasingly prohibitive for some organizations in long-term deployment scenarios. This expense barrier has led to the emergence of a cloud repatriation trend, where existing software systems are moved back to on-premises environments. Although this initiative enhances cost control management and autonomy, it reintroduces technical challenges. This work investigates, through an empirical study, the applicability of Long Short-Term Memory (LSTM) networks for workload prediction to support auto-scaling decisions in on-premises environments. Initially, we contrasted the prediction accuracy of LSTM with classical methods, utilizing both standard benchmark datasets and access logs collected from an industrial-grade software system. In the second phase, we examined how varying temporal resolutions affect precision and computational expense. Results show the LSTM consistently outperforms classical methods, reducing MAPE by up to 18.02% and RMSE by 8.77% on benchmark datasets. Considering the in-field dataset, it outperforms in long-term predictions, especially regarding MAE and MAPE. Throughout all analyzed temporal resolutions, the 10-minute resolution optimally balanced accuracy with efficiency. Moreover,we noted that LSTM requires less training time than classical methods, emphasizing its applicability for real-world scenarios. Therefore, the results indicate that LSTM emerges as a viable solution to enable proactive auto-scaling within on-premises environments, potentially reducing costs in the context of cloud repatriation.
Attentionsmelling: Using Large Language Models to Identify Code Smells
Large Language Models (LLMs) are becoming essential tools in software engineering, automating tasks like code generation, unit testing, and code review. However, their potential to identify code smells, indicators of poor code quality, remains underexplored. This study evaluates GPT-4’s effectiveness in identifying three common code smells (Long Method, God Class, and Feature Envy) across four experimental setups ranging from using only source code and code smell definitions to leveraging additional context, metrics, and hyperparameter optimization. Our analysis revealed remarkable improvements across all metrics when improving the prompt with more information, with overall performance increasing by 64% in ROC Curve and 56% in F1-score. These results emphasize the impact of incorporating metrics and hyperparameter tuning into LLM prompts, enabling significant advancements in automated software quality assessment. This may lead to better coding practices, particularly related to identifying code smells.
GenIA-E2ETest: A Generative AI-Based Approach for End-to-End Test Automation
Software testing is essential to ensure system quality, but it remains time-consuming and error-prone when performed manually. Although recent advances in Large Language Models (LLMs) have enabled automated test generation, most existing solutions focus on unit testing and do not address the challenges of end-to-end (E2E) testing, which validates complete application workflows from user input to final system response. This paper introduces GenIAE2ETest, which leverages generative AI to generate executable E2E test scripts from natural language descriptions automatically. We evaluated the approach on two web applications, assessing completeness, correctness, adaptation effort, and robustness. Results were encouraging: the scripts achieved an average of 77% for both element metrics, 82% for precision of execution, 85% for execution recall, required minimal manual adjustments (average manual modification rate of 10%), and showed consistent performance in typical web scenarios. Although some sensitivity to context-dependent navigation and dynamic content was observed, the findings suggest that GenIA-E2ETest is a practical and effective solution to accelerate E2E test automation from natural language, reducing manual effort and broadening access to automated testing.
An Exploratory Study on the Lifecycle of Code Clones During Code Review
The Modern Code Review (MCR) process is iterative and asynchronous, enabling early identification of several issues during software development. Overall, code reviewconsists of inspecting code before merging it into the codebase. Code clones are code fragments that are copied and reused across different (or the same) codebases, often with minor changes. Developers must be aware of code clones in their projects, as issues in a cloned fragment may cause adjustments in all related clones, which can significantly impact the project’s maintainability. Nevertheless, there is still a gap in research addressing the presence and behavior of code clones during code review. By leveraging the CROP dataset (with over 28k code reviews and 80k revisions) and the Siamese clone detector, we identified 27,656 relevant code clones that underwent code review in 6 different software systems. A manual validation of a representative sample indicated a predominance of Type-I (46.74%) and Type-III (45.3%) clones. Based on the clones’ lifecycle within the review, we categorized the reviews into Single and Recurring, according to how the clones are introduced and/or removed during the review process. We identified 224 reviews for which clones appear in a single review (Single) and 1,258 reviews for which clones appear in multiple revisions (Recurring). Additionally, 236 code reviews lie at the intersection of Recurring and Single code reviews. To deepen the analysis, we introduced two metrics, Duration and Distance, to assess how clones are introduced or removed during the review. We observed that, on average, clones are often introduced at the beginning of the code review, commonly surviving the review process and being merged into the codebase.
404: Civility Not Found? Evaluating the Effectiveness of Small Language Models in Detecting Incivility in GitHub Conversations
Context: Incivility in open-source software (OSS) platforms like GitHub can harm collaboration, discourage contributor participation, and impact code quality. Although current moderation tools based on Machine Learning (ML) and Natural Language Processing (NLP) offer some support, they often struggle to detect nuanced or implicit types of incivility. Goal: This study aims to assess the effectiveness of Small Language Models (SLMs) in detecting both coarse-grained (civil vs. uncivil) and fine-grained (specific types) incivility in GitHub conversations (issues and pull requests), and to understand how different prompting strategies influence detection performance. Method: We evaluate ten SLMs (3B-14B parameters) across five prompt strategies, on a labeled dataset with more than 6k GitHub conversations. We also compare the best-performing SLMs with five traditional ML models using two text-encoding techniques. Results: Our results reveal that SLMs perform well in detecting civil comments, but their effectiveness in detecting uncivil comments depends on model size. Models with 9B+ parameters (e.g., deepseek-r1, gpt-4o-mini) show improved performance on uncivil comments. For the fine-grained granularity, prompting strategy plays a critical role, with role-based prompting achieving the best results, particularly for implicit incivility types (e.g., Irony and Mocking), even when SLMs struggle with these types of incivility. Traditional ML models still perform well in explicit cases like Threat and Insulting. Conclusion: Our findings highlight the effectiveness of SLMs and prompt strategies in enhancing the detection of incivility within collaborative software development settings.
Evaluating the Potential of Large Language Models in Security-Related Software Requirements Classification
An effective classification of security-related software requirements is crucial to mitigate potential threats and ensure robust system design. This study investigates the performance of Large Language Models (LLMs) in classifying security-related requirements compared to traditional Machine Learning (ML) methods. Using the SecReq, DOSSPRE and PROMISE+ datasets, we evaluated ten LLMs across various prompt engineering strategies. The results demonstrate that LLMs achieve high accuracy and outperform traditional ML-based models in several evaluation scenarios and that prompt engineering can significantly enhance the model’s ability to identify security-related requirements. This work underscores the domaingeneralization capabilities of LLMs and their potential to streamline requirements classification without the complexity of feature engineering or dataset-specific fine-tuning often required by ML-based approaches. Researchers, practitioners, and tool developers can leverage these findings to advance automated approaches in security requirements engineering.
PRemo: A Dataset of Emotions Found on Pull Request Discussions
In software engineering, effective communication is key to ensuring software quality. On GitHub projects, one of the primary channels for such communication is pull request discussions. These discussions often contain high-level design decisions. Understanding communication dynamics within development teams is crucial in software engineering, and sentiments and emotions play a significant role in this context. While there are datasets available for sentiment analysis in this field, those focusing on specific emotions are rare, and some contexts, such as pull request discussions, remain underrepresented. To address these gaps, we propose a novel methodology for capturing sentiments and emotions in contextspecific data, resulting in the creation of PRemo. PRemo includes ≈1.8K manually labeled pull-request messages from 36 active opensource industry-relevant projects. It provides data on individual emotions (and their intensity), the surrounding context, and evaluator confidence. Built using a robust triple validation and two-pass labeling process, the dataset leverages an established psychological emotion model. Already applied in prior research, PRemo is a valuable resource for advancing emotion analysis in software engineering.
Automatic Identification of Machine Learning-Specific Code Smells
Machine learning (ML) has rapidly grown in popularity, becoming vital to many industries. Currently, the research on code smells in ML applications lacks tools and studies that address the identification and validity of ML-specific code smells. This work investigates suitable methods and tools to design and develop a static code analysis tool (MLpylint) based on code smell criteria. This research employed the Design Science Methodology. In the problem identification phase, a literature review was conducted to identify ML-specific code smells. In solution design, a secondary literature review and consultations with experts were performed to select methods and tools for implementing the tool.We evaluated the tool on data from 160 open-source ML applications sourced from GitHub. We also conducted a static validation through an expert survey involving 15 ML professionals. The results indicate the effectiveness and usefulness of the MLpylint. We aim to extend our current approach by investigating ways to introduce MLpylint seamlessly into development workflows, fostering a more productive and innovative developer environment.
Investigating How Psychological Safety Can Be Fostered in Agile Teams
Context: Psychological safety is defined as a shared belief that team members can take interpersonal risks at work without fear of reprisal. Technical, social, cultural, organizational, and personal factors can all influence psychological safety. Its absence in agile environments can negatively affect both software quality and project success. Problem: Although psychological safety has been studied in other areas, it is still underexplored in the agile context. Existing research examines only a few factors and the relationships between them. The lack of understanding of the factors that influence psychological safety limits the ability to take action to foster a psychologically safe workplace. Objective: Our goal is to summarize studies that investigate psychological safety in agile contexts, as well as to identify the factors that promote or affect psychological safety, in addition to the effects of its absence or presence. Method: We conducted a mapping study. Results: We found 21 studies that investigate psychological safety in the agile context. We identified that team performance, engagement, reflexivity, learning, software quality, and open communication, among other factors, emerge in organizational cultures that promote psychological safety, and that leadership behavior is a key element in sustaining a psychologically safe environment. Conclusion: We captured relevant factors for the study of psychological safety in agile contexts. The results can support future research on the topic and contribute to the development of new solutions to address it. Furthermore, the findings may serve as a basis for defining approaches to promote a psychologically safe environment and organizational culture.
Understanding How Brazilian Software Organizations Collect and Utilize User Feedback: A Survey
Context: User feedback is a critical resource for guiding software evolution and improving usability and user experience. However, in Brazil, there is still little evidence of how organizations collect, analyze, and utilize user feedback in practice. Objective: Our goal is to provide an overview of how Brazilian software organizations have captured and utilized user feedback. Method:We conducted a survey involving 31 Brazilian software organizations. Data was collected through a structured questionnaire, represented using graphs and tables, and analyzed. Results: The study results revealed that most organizations predominantly have captured explicit feedback, combining internal and external sources, but systematic analysis and longitudinal monitoring have been limited. User feedback has been used mainly to support maintenance, strategic decision-making, and innovation initiatives aiming at software evolution. Integrating supporting tools, low response rates, difficulties in interpreting subjective or generic feedback, and resistance from development teams to incorporate user feedback into decision-making were highlighted as challenges faced by the organizations. Conclusion: Although organizations have recognized the importance of user feedback, the study results suggest that user feedback management practices in Brazil are not very mature yet, indicating opportunities for improvement, such as using implicit feedback and monitoring changes in user feedback over time.
Diversity Matters: Perceived Inclusion and Discrimination by Brazilian Tech Professionals
Diversity and inclusion are widely recognized as essential drivers of innovation in software engineering. However, systemic inequalities and implicit biases remain persistent challenges. This study aims to explore how tech professionals in Brazil perceive inclusion, discrimination, and unconscious bias in the workplace. We surveyed 220 tech professionals, focusing on experiences of bias, perceptions of fairness, and the influence of organizational setting. The findings reveal that 95.2% of women experienced sexism, compared to 70.3% of men; 77.1% of non-white professionals identify racism as a key issue, while 61.5% of disabled professionals report experiencing ableism. Hybrid work models were associated with the highest reports of sexism (80%), while employees at smaller companies reported more frequent instances of ableism than those at larger ones. Despite widespread acknowledgment of discrimination, only 23% of respondents explicitly recognized the presence of unconscious bias in themselves. While most see their teams as diverse, leadership inclusion lags, especially for disabled (25.9%) and neurodivergent (36.4%) professionals. These results reveal persistent equity gaps and call for DEI (Diversity, Equity, and Inclusion) strategies in Brazil’s tech sector.
An Empirical Study on the Effectiveness of Iterative LLM-Based Improvements for Static Analysis Issues
Maintaining and evolving software systems often demands more effort than their initial development. Improving source code quality through automated support can significantly reduce technical debt, increase maintainability, and enhance developer productivity. This paper presents an experimental approach that integrates static analysis with Large Language Models (LLMs) to automate source code improvement. The proposed pipeline iteratively processes Java classes by extracting issues detected by SonarQube and transforming them into prompts for LLMs, which generate improved code versions. Each version is reanalyzed, and the process repeats until convergence or a predefined iteration limit is reached. The experimental setup includes multiple configurations combining two LLMs (GPT-4-mini and Gemini), variation in temperature, prompt style, and number of iterations. Evaluations were conducted using multiple Java datasets, with three repeated runs for the Commons Lang repository to identify behavioral patterns. The analysis focuses on the number of issues reduction, decrease in technical debt (measured in a SonarQube metric), and the evolution of issue severity. Functional correctness was assessed manually by inspecting and executing the improved code to ensure behavior preservation. The results demonstrate that combining SonarQube with LLMs is effective in reducing code issues—achieving over 58% average reduction in key scenarios—while preserving functionality. The iterative process proved successful in guiding the models to incrementally improve code quality based on real static analysis feedback. This work contributes a reproducible and extensible pipeline, offering insights into the impact of LLM configurations and supporting further research in the integration of AI and software quality engineering.
Unveiling the Relationship Between Continuous Integration and Code Review: A Study with 10 Closed-source Projects
Companies have adopted Continuous Integration (CI) and Code Review (CR) as key practices to monitor and improve software quality continuously. These practices enable early detection and correction of issues and have shown promising results in open and closed-source projects. However, there is limited understanding of the relationship between CI and CR in closed-source environments. For instance, it remains unclear how CI practices influence CR (and vice versa) and to what extent bad CI practices hinder the CR process. To address this gap, we conducted a mixed-methods study involving ten closed-source projects developed by industry partners.We collected and analyzed 32 metrics related to CI and CR. In addition to the quantitative analysis, we gathered perceptions from project teams to (i) validate the identified correlations, (ii) explore the effects of bad CI practices on CR, and (iii) understand the perceived benefits and challenges of using CI and CR together. Our results revealed 23 correlations between CI and CR processes, leading to the following key findings: (i) theworkload and execution time of CI can influence code review time; (ii) CI and CR execution times are more correlated when the processes occur sequentially; (iii) bad CI practices (such as long-lived branches, poor testing strategies, or complex build schemes) can negatively impact CR, causing delays, reviewer overload, and undetected issues; (iv) CI adds value to CR by anticipating problems, reducing manual tasks, and supporting the distribution of updates; and (v) the joint use of CI and CR presents challenges, such as ensuring code quality, resolving merge conflicts, and aligning processes. These findings shed light on the interplay between CI and CR and offer insights to improve their combined use in closed-source software development.
Survey-Based Insights into the Replication Crisis and the 3R in Software Engineering
Context: Efforts to improve reproducibility and research credibility have gained relevance in multiple fields, including Software Engineering (SE), where the 3R practices (Repeatability, Reproducibility, and Replicability) are essential to ensure the reliability of empirical studies. Despite growing interest in Open Science, concerns about a Replication Crisis persist. Objectives: To assess the perceptions of SE researchers of the Replication Crisis and 3R practices, identify good practices, barriers, and facilitators to reproducible research, and evaluate the community’s acceptance of the ACM’s standardized definitions of 3R. Method: We conducted a survey adapted from Baker [5], targeting authors of SE studies related to replication. From a list of 1,061 researchers, we received 101 responses. The questionnaire combined Likert-scale and open-ended questions. Responses were analyzed using descriptive statistics and Reflexive Thematic Analysis. Results: Most respondents acknowledged the importance of 3R practices. On average 84.5% agreed with the ACM definitions, participants raised concerns about their clarity and applicability, especially to qualitative research. 74.3% recognized the existence of a Replication Crisis in SE. The key challenges reported include a lack of protocols, selective reporting, data unavailability, and pressure to publish. Positive actions included using containers, version control, artifact sharing, and Open Science practices. However, participants noted that cultural and institutional incentives for reproducibility are limited. Conclusion: Although SE researchers support the principles of 3R practices and recognize ongoing challenges, uncertainty persists about the scope and solutions of the crisis. This study highlights the need for more precise terminology, better reporting standards, and greater institutional support to promote reproducibility, transparency, and research integrity in SE.
Understanding Psychological Safety in Agile Software Development Teams
Context: Psychological safety (PS) refers to individuals’ perceptions of the interpersonal risks of speaking up or making mistakes in team environments. In agile software development, PS is especially relevant due to its emphasis on collaboration, iteration, and continuous feedback. Despite growing interest in PS, there is still a limited understanding of how specific situations in agile contexts trigger psychological insecurity. Aims: This study aims to identify situations that challenge PS in agile teams, explore the causes behind these situations, and analyze their effects on team members and processes. Method: We conducted a qualitative content analysis of 54 discussions from Stack Exchange forums, focusing on real-life agile development experiences. Results: We identified five categories of challenging situations (e.g., misalignment of agile roles and responsibilities), seven categories of causes (e.g., process conflicts and bureaucracy), and five categories of consequences (e.g., team management and dynamic issues). Besides, we found frequent co-occurrence patterns between causes and consequences, revealing how PS disruptions propagate in agile teams. Conclusion: By categorizing real-world PS challenges, this study offers actionable directions for agile practitioners to recognize, anticipate, and mitigate psychologically unsafe conditions. Our taxonomy contributes to a more practical and nuanced understanding of PS in agile environments, supporting both empirical research and organizational interventions.
A Mapping Study About Training in Industry Context in Software Engineering
Context: Corporate training plays a strategic role in the continuous development of professionals in the software engineering industry. However, there is a lack of systematized understanding of howtraining initiatives are designed, implemented, and evaluated within this domain. Objective: This study aims to map the current state of research on corporate training in software engineering in industry settings, using Eduardo Salas’ training framework as an analytical lens. Method: A systematic mapping study was conducted involving the selection and analysis of 26 primary studies published in the field. Each study was categorized according to Salas’ four key areas: Training Needs Analysis, Antecedent Training Conditions, Training Methods and Instructional Strategies, and Post-Training Conditions. Results: The findings show a predominance of studies focusing on Training Methods and Instructional Strategies. Significant gaps were identified in other areas, particularly regarding Job/Task Analysis and Simulation-based Training and Games. Most studies were experience reports, lacking methodological rigor and longitudinal assessment. Conclusions: The study offers a structured overview of how corporate training is approached in software engineering, revealing underexplored areas and proposing directions for future research. It contributes to both academic and practical communities by highlighting challenges, methodological trends, and opportunities for designing more effective training programs in industry.
Integrating Experiential Learning, Distance Education, and Extension Curricularization in an Undergraduate Systems Analysis and Development Program
Experiential learning is a well-established pedagogical approach that enhances student engagement and skill development through direct application. While widely adopted in in-person education, its integration into distance education remains underexplored, particularly in software engineering extension programs. This experience report investigates student perceptions of an experiential learning-based extension project within a distance education setting, specifically in a Systems Analysis and Development undergraduate program in Brazil. Using a mixed-methods approach, we analyzed student perceptions (from questionnaires and final reports) and the coordinating professor’s reflective observations. Our findings reveal that experiential learning in distance education fosters both technical proficiency (e.g., software development practices and agile methodologies) and professional identity formation (e.g., teamwork, communication, and project management skills). However, challenges such as balancing autonomy and guidance, remote collaboration barriers, and time management struggles emerged as obstacles. Our study contributes by offering actionable lessons for integrating experiential learning into software engineering distance education through the curricularization of extension.
BitBeak: Gamificação e Mangás como Apoio ao Ensino de Programação
O ensino de programação enfrenta desafios relacionados ao engajamento e à retenção de estudantes, especialmente em disciplinas introdutórias que frequentemente apresentam altas taxas de evasão. Diversos fatores — como a complexidade dos conceitos iniciais em lógica de programação, estruturas de controle, manipulação de variáveis, desenvolvimento de algoritmos, uso de funções, arrays e listas, e estruturas de dados básicas como pilhas e filas — aliados à falta de motivação, podem dificultar a aprendizagem e o progresso dos alunos na área. Este artigo apresenta o BitBeak, uma ferramenta educacional gamificada que utiliza narrativas em estilo mangá para tornar o ensino de programação mais acessível e envolvente. O impacto dessa abordagem foi avaliado por meio do modelo MEEGA+, analisando usabilidade, experiência do jogador e percepção de aprendizado. O estudo envolveu estudantes universitários que interagiram com a plataforma, com aplicação de métricas quantitativas e qualitativas para mensurar engajamento e retenção de conhecimento. Os resultados indicam que a combinação entre gamificação e mangás aumenta a motivação e a compreensão conceitual dos alunos, apoiando os processos de ensino e aprendizagem em programação.
O uso de exemplos trabalhados para facilitar a contribuição de novatos em projetos de software livre
O mercado de desenvolvimento de software está crescendo rapidamente, e projetos de software livre (SL) oferecem oportunidades valiosas para novatos. Contudo, as barreiras técnicas e não técnicas ainda dificultam as primeiras contribuições. Embora estudos busquem mitigar esses desafios, persistem as limitações. Exemplos trabalhados ajudam aprendizes a cometer menos erros, mas é difícil encontrar exemplos estruturados. Muitos desenvolvedores recorrem ao Stack Overflow, estratégia que nem sempre é eficaz. Recentemente, modelos de linguagem como o ChatGPT transformaram a busca por soluções. Considerando a reutilização frequente de códigos do Stack Overflow e o uso crescente do ChatGPT, este estudo investigou se respostas dessas fontes poderiam funcionar como exemplos trabalhados para apoiar o aprendizado e a resolução de problemas de novatos. Para isso, usamos uma issue do projeto Pandas como estudo de caso e conduzimos entrevistas individuais com o protocolo Thinking Aloud, seguidas de análise qualitativa. Os resultados sugerem que exemplos trabalhados dessas fontes podem auxiliar novatos em suas primeiras contribuições a projetos de SL.
Avaliando o Papel do GPT-4o na Aprendizagem de Engenharia de Software: Um Relato de Experiência
Desde o surgimento dos GPTs no mercado, há uma demanda crescente por estudos que investiguem seu impacto em diversas áreas, incluindo a educação. Este estudo é um relato de experiência estruturado que explora o impacto de ferramentas baseadas em IA — especificamente o modelo GPT-4o via API da OpenAI — na aprendizagem de alunos em uma disciplina de Engenharia de Software. A ferramenta proposta foi projetada com system prompts específicos para reduzir a carga cognitiva dos alunos, permitindo que se concentrassem na tarefa pedagógica. Dados de uso de 28 participantes foram coletados e analisados utilizando métodos estatísticos e processamento de linguagem natural. Os resultados indicam que alunos sem experiência profissional escreveram prompts mais longos, enquanto aqueles com tal experiência tenderam a curtir mais interações. Prompts curtidos tinham maior probabilidade de conter código, e alunos com experiência profissional também se mostraram mais propensos a incluir trechos de código em suas consultas. Este estudo contribui ao propor uma metodologia estruturada para coletar, processar e analisar dados de interação com IAs generativas em contextos educacionais, ajudando a orientar futuras pesquisas empíricas na área.
Promovendo a Representatividade Feminina na Engenharia de Software por meio de Comunidades Python: Um Relato de Experiência Educacional
Este artigo apresenta um relato de experiência educacional realizado em um curso de Engenharia de Software por meio do Movimento Ponto Python. A iniciativa teve como objetivo promover a inclusão de estudantes do sexo feminino em atividades de ensino, pesquisa e extensão, com ênfase no fortalecimento da representação feminina na área de computação. Estruturado em etapas planejadas e orientado por metodologias ativas, o projeto envolveu ações práticas em comunidades técnicas, produção científica e participação em eventos. A análise qualitativa dos resultados foi conduzida com base em três dimensões: percepção de aprendizagem, motivação e valor percebido da aprendizagem, destacando impactos positivos no desenvolvimento acadêmico, técnico e pessoal das participantes. O trabalho enfatiza práticas replicáveis para a promoção da equidade de gênero na tecnologia, contribuindo para ambientes mais inclusivos no contexto da Educação em Engenharia de Software.
Teaching software design patterns: An experience using the Jigsaw classroom
Software design patterns have been one of the most important topics taught in computer science courses. However, several challenges remain for teaching design patterns in the classroom, such as misconceptions about their utility and students’ lack of motivation for learning them. The Jigsaw classroom is a teaching method based on cooperative learning, where students, as principal actors, collaborate to construct their knowledge about a subject. Jigsaw has demonstrated improvements in students’ cognitive, affective, and psychosocial skills; however this instructional method has not been properly explored in software engineering teaching to provide evidence of its benefits and drawbacks for education in this area. This study presents an experience on using Jigsaw classroom for teaching software design patterns in an undergraduate course. The preliminary results confirm the benefits and some application challenges the Jigsaw method presents in other areas. Lessons learned from this experience are shared with educators interested in applying the Jigsaw method in software engineering-related courses.
LEDS: The Rise of the (Collective) Force — 10 Years of Impact on Innovation and Education in Software Engineering: What we Have Learned by Integrating Teaching, Research, and Extension in Higher Education
Over the past decade, the Laboratory for Extension in Development of Solutions (LEDS) has evolved from a small local initiative into an academic ecosystem that integrates teaching, research, and extension in Software Engineering. Founded in 2012 at the Federal Institute of Espírito Santo (IFES), LEDS simulates a real-world software development environment where students engage in multidisciplinary projects that serve public and private sector demands. Through project-based learning and interdisciplinary collaboration, LEDS fosters the development of both technical competencies and essential soft skills, enhancing student engagement and preparing them to face real-world challenges. This paper revisits LEDS over ten years after its inception, highlighting its organizational practices and impacts on student education and institutional innovation, through the creation of a research and extension culture grounded in experiential learning. Finally, we reflect on the lessons learned and challenges and offer practical insights for education professionals and researchers seeking to implement academic software factories as drivers of Software Engineering educational transformation and industry collaboration.
Tester’s Quest: Um Jogo de Tabuleiro Cooperativo para o Ensino de Teste de Software: Uma Abordagem Lúdica para Explorar a Pirâmide de Testes
O Tester’s Quest é um jogo de tabuleiro, inspirado no jogo Pandemic, desenvolvido e aplicado na disciplina de Teste de Software enquanto ferramenta educacional para explorar conceitos relativos aos níveis da pirâmide de teste e suas características. Sua mecânica promove a cooperação entre os jogadores quando estes assumem o papel de especialistas em qualidade de software para identificar e combater bugs a partir de recursos limitados de projetos de software. O jogo é composto por um tabuleiro representando a pirâmide de testes, cartas que representam eventos, bugs e power-ups — que simulam situações reais do desenvolvimento de software, contextualizados ao nível de teste no qual os jogadores se encontram na pirâmide. O Tester’s Quest foi aplicado de forma exploratória para refinamento em duas turmas. Foi perceptível que a proposta reforça a correspondência entre o conteúdo didático alvo e a mecânica do jogo, favorecendo o aprendizado.
Evaluating Strategies for Teaching Micro Frontends: Do Anti-patterns Help?
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 a controlled experiment, 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. 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. Conclusion: This paper provides insights into incorporating MFE into a software architecture course, proposes two supporting materials that educators can use to teach MFE, offers practical recommendations for effective instruction, and highlights the potential of the MFE anti-patterns catalog as a valuable learning tool.
Design Thinking as a Toolbox for Requirements Engineering Education: Lessons from the Classroom
Context: Design Thinking (DT) has gained popularity in software engineering education as a human-centered and collaborative approach to solving complex problems. In Requirements Engineering (RE), DT can complement traditional practices by offering concrete tools that support creativity, empathy, and stakeholder engagement. Goal: This paper presents a classroom experience in which DT was introduced not as a linear process, but as a toolbox of techniques that students could freely explore and apply to real-world projects involving external clients. Method: Students worked in teams on practical RE assignments, each involving a different system and real users. They applied DT techniques of their choice, supported by a curated selection guide called “Universo de Seleção,” which helped them identify and adapt methods suitable for their specific contexts. We conducted a qualitative analysis of students’ reflections gathered through reports and surveys. Results: The toolbox approach led to improved understanding of requirements elicitation, better engagement with users, and development of key skills such as teamwork and communication. Students also demonstrated autonomy and critical thinking in selecting techniques appropriate to their project contexts. Conclusion: This experience highlights the potential of using DT as a toolbox to enrich RE education, offering flexibility and encouraging deeper engagement with both technical and human aspects of requirements elicitation.
Educational Insights from Code: Mapping Learning Challenges in Object-Oriented Programming through Code-Based Evidence
Object-Oriented programming is frequently challenging for undergraduate Computer Science students, particularly in understanding abstract concepts such as encapsulation, inheritance, and polymorphism. Although the literature outlines various methods to identify potential design and coding issues in object-oriented programming through source code analysis, such as code smells and SOLID principles, few studies explore how these code-level issues relate to learning difficulties in Object-Oriented Programming. In this study, we explore the relationship of the code issue indicators with common challenges encountered during the learning of object-oriented programming. Using qualitative analysis, we identified the main categories of learning difficulties and, through a literature review, established connections between these difficulties, code smells, and violations of the SOLID principles. As a result, we developed a conceptual map that links code-related issues to specific learning challenges in Object-Oriented Programming. The model was then evaluated by an expert who applied it in the analysis of the student code to assess its relevance and applicability in educational contexts.
Um relatório de análise dos cursos de graduação em ES no Brasil: revelações e insights
O ensino de Engenharia de Software (ES) no Brasil iniciou-se em disciplinas nos cursos de Computação e evoluiu com a criação de cursos específicos, devido ao lançamento das primeiras diretrizes da Association for Computing Machinery (ACM), referenciais da Sociedade Brasileira de Computação (SBC) e pelas Diretrizes Curriculares Nacionais (DCNs). Apesar desse avanço, ainda são escassas análises sistemáticas sobre o perfil acadêmico desses cursos. Este trabalho investiga a estrutura curricular de 28 cursos de graduação em ES oferecidos por Instituições Públicas de Ensino Superior no Brasil (IES), com base nos eixos formativos da SBC e nas áreas do Software Engineering Body of Knowledge (SWEBOK), por meio de uma análise feita nas ementas das disciplinas dde cada curso. Os dados revelam ampla distribuição geográfica, com predominância no interior dos estados. Disciplinas ligadas aos eixos de Fundamentos aparecem com frequência, enquanto áreas críticas como Qualidade, Requisitos e Testes de Software são pouco abordadas ou ausentes. As variações regionais de ênfases curriculares indicam falta de padronização nacional. Conclui-se que ações como revisão dos PPCs, incentivo à pesquisa aplicada nas áreas de ES e flexibilização curricular com diferentes ênfases podem mitigar assimetrias na formação em Engenharia de Software no país.
Avaliando a Colaboração no Ensino de Engenharia de Software: Percepções a partir de uma Revisão Rápida
Atividades colaborativas de co-criação são amplamente adotadas no ensino de Engenharia de Software para simular cenários reais de desenvolvimento. Impulsionadas por práticas de Design Thinking e Métodos Ágeis, essas atividades envolvem os estudantes em diversas fases do ciclo de vida do desenvolvimento. No entanto, a ausência de métricas para avaliar a colaboração limita a capacidade de verificar sua efetividade educacional. Este estudo tem como objetivo identificar como a colaboração é avaliada em atividades de co-criação no contexto do ensino de Engenharia de Software, mapeando sistematicamente as estratégias relatadas na literatura. Para isso, foi realizada uma revisão rápida aplicando uma string de busca nas bases de dados IEEE Xplore e Scopus. A busca retornou 909 estudos, dos quais 32 foram selecionados com base em critérios de inclusão e exclusão. Como resultados, se observou que a maioria dos estudos avalia a colaboração por meio de questionários com perguntas em escala Likert. Alguns adotam abordagens combinadas, integrando avaliação entre pares, registros de uso de ferramentas e observações de instrutores. No entanto, muitas avaliações continuam focadas nos resultados finais, em vez do processo colaborativo em si. Desta forma, este trabalho oferece a educadores e profissionais uma visão geral das práticas atuais de avaliação da colaboração.
Do’s and Don’t s of Partnering with Industry to Educate Software Engineering Students: Recommendations Based on a Teaching Experience
This experience report describes a software development training program for undergraduate students, resulting from a longstanding collaboration between the Pontifical Catholic University of Rio Grande do Sul (PUCRS) and a renowned multinational in the technology industry, one of the largest retailers in the global IT market. The program aims to prepare students for professional software development before they formally join industry teams. Established over 25 years ago, the program currently trains around 60 students per year and has followed its current structure since 2016. This paper characterizes the university-industry partnership model and presents an overview of the program’s four main phases: (1) participant selection, (2) technical training, (3) hands-on practice, and (4) industry internship. The first three phases take place within the university. The discussion highlights key challenges and successes identified throughout each stage, and analyzes how early exposure to industry-aligned practices helps bridge the gap between academic learning and real-world professional demands. The experience report also synthesizes lessons learned through a summary of Do’s and Don’t s for each phase, offering practical recommendations for similar initiatives.
Learning through Practice: Teaching Empirical Software Engineering for Undergraduate Students
Empirical Software Engineering (ESE) is essential for understanding the benefits and limitations of existing software engineering solutions. The evidence obtained through experiments guides the evolution of this area and optimizes the use of effort in relevant research that solves real problems or gaps. In ESE teaching, the challenge arises of preparing future software engineers to plan, conduct, and analyze experiments. This article reports on an experience of teaching ESE to 54 undergraduate students in an elective course, using Active Learning. To this end, we describe the activities carried out during the course, and to understand the effect of Active Learning, we conducted a survey using an online questionnaire. Twenty-seven students from the class consented to take part in the survey. The results show that 77.7% of the respondents had little or no experience of ESE before the course. At the end of the course, around 88.2% reported greater confidence in carrying out research in the area. The hypothesis test showed a significant increase in knowledge of the course’s content, emphasizing the topics of surveys and empirical studies. Correlation analysis revealed that the perceived contribution of the course is positively associated with student motivation. Despite some challenges, the students highlighted the methodology applied as being of great value to their training and entry into the job market. The experience of using Active Learning to teach ESE showed that, as well as contributing to the students’ education, the methodology gave them more confidence and motivation, which suggests the importance of pedagogical approaches that are closer to practice.
Desvendando as Mentes dos Jogadores: Utilizando a Escala HEXAD para Identificar Preferências de Gamificação no Ensino de Arquitetura de Software
A gamificação no ensino promove benefícios no engajamento, desempenho e motivação dos estudantes. No entanto, seus resultados podem variar de acordo com os diferentes perfis de jogadores. Isto torna importante investigar a relação entre diferentes estratégias de gamificação e os perfis de quem participa da experiência. Este estudo investigou o impacto de uma estratégia de gamificação aplicada ao ensino de Arquitetura de Software, fundamentada na identificação de perfis de jogadores segundo a Escala Hexad, que categoriza os indivíduos em seis perfis de jogadores: Socializador, Filantropo, Realizador, Espírito Livre, Disruptor e Jogador. A experiência relatada neste artigo ocorreu no semestre letivo de 2024.2. Os estudantes participaram de diversas atividades integradas ao conteúdo programático da disciplina, recebiam badges como forma de reconhecimento pelo desempenho e engajamento nas atividades. Cada estudante utilizou uma cartela individual para acompanhar seu progresso, permitindo o monitoramento contínuo da sua evolução. A metodologia adotada foi de natureza quantitativa-descritiva, com análise de dados coletados por meio de questionários estruturados e observações em sala de aula. Como resultados, identificou-se uma predominância do perfil Realizador, presente em aproximadamente 40% dos participantes. Este perfil é caracterizado por uma motivação intrínseca voltada à superação de desafios e à conquista de metas, alinhando-se a elementos de design gamificado que privilegiam progresso, metas claras e feedback imediato. A análise de correlação indicou que os perfis Socializador e Filantropo obtiveram altos níveis de engajamento e valor percebido, enquanto o perfil Jogador apresentou menor desempenho e engajamento, possivelmente em função da ausência de recompensas externas atrativas.
Carlos Augusto Carneiro de Freitas Filho
Bloom’s Taxonomy as a Lens to Explore Student Learning of Design Thinking in Software Engineering Education and Training
Background: Design Thinking (DT) has been widely adopted in Software Engineering (SE) for its emphasis on creativity, user understanding, and iterative problem-solving. However, in the context of SE Education and Training (SEET), there is a lack of empirical research exploring how students internalize, engage with, and perceive DT-related content. Aims: Our research aims to understand how SE students perceive and internalize DT concepts during their training. Method: We conducted semi-structured interviews with nine students who had previous contact with DT through an SE course. We used Bloom’s Taxonomy as a foundation, as it offers a structured framework to assess the cognitive levels students reach when learning a given topic. This approach allowed us to explore how students process, retain, and apply DT-related knowledge. We analyzed the data using Grounded Theory procedures. Results: Analyzing through the lens of Bloom’s framework, we found individual differences in the depth of learning and consolidation of DT concepts. Three participants demonstrated analysis-level abilities, four reached the synthesis level, and two attained evaluation-level skills. Our findings also reveal that students associate DT with creativity, user understanding, freedom to explore options, and goal orientation. They also recognized the value of DT techniques for organizing data, guiding technical decisions, and supporting the software development process. Based on our findings, we propose an empirically-based conceptual model that structures students’ perspectives on the use of the DT in SE. Conclusions: We hope our contributions can assist educators in developing strategies to help students better retain DT content, with emphasis on SEET, as our results offer a structured understanding of how students internalize DT in SE.
Educator Perceptions of DevOps Teaching Recommendations and Their Alignment with Common Challenges
DevOps education presents unique pedagogical challenges due to the diversity of tools, rapid technological change, and the multidisciplinary nature of the field. Although previous work has proposed recommendations to address these challenges, it is unclear how educators perceive these recommendations and whether they align with the challenges encountered in practice. In this paper, we present a quantitative and qualitative methods study involving 11 DevOps educators who interacted with Improve, a tool that presents a curated set of educational challenges and recommendations derived from previous literature. Educators indicated which recommendations they already use, which they intend to use, and which challenges they experience and are motivated to address. Our findings show that 22.6% of the recommendations were new to educators and considered potentially useful, while 59.2% were already in use. Additionally, 66.3% of the challenges were considered relevant, with most of them having linked recommendations that educators were already using or willing to adopt. This study provides empirical insights into the perceived usefulness of existing recommendations, identifies gaps in challenge-recommendation mappings, and supports future efforts to design and disseminate more targeted educational guidance for DevOps teaching.
Como Percepções e Estatísticas Revelam o Desenvolvimento de Habilidades Técnicas e Não Técnicas em Estudantes de Computação
A combinação de habilidades técnicas e interpessoais é essencial para o sucesso na Engenharia de Software, e metodologias de ensino eficazes desempenham um papel crucial no desenvolvimento dessas competências. Este estudo investigou a influência da Aprendizagem Baseada em Projetos no aprimoramento dessas habilidades em estudantes de Computação, aliada a outras abordagens complementares. Foi adotada uma abordagem de métodos mistos, combinando questionários aplicados no início e ao final do curso com entrevistas semi-estruturadas visando ao aprofundamento das percepções dos participantes. A análise estatística revelou melhoria significativa em nove das dezoito habilidades interpessoais avaliadas. Para as entrevistas, foram selecionados estudantes cujas autoavaliações apresentaram contradições, relatando evoluções consideráveis nas respostas qualitativas, mas indicando, nas quantitativas, redução no nível de desenvolvimento dessas habilidades entre o início e o fim do curso. Os resultados indicaram que a metodologia centrada em atividades práticas e projetos em grupo contribuiu para ampliar a confiança dos estudantes em suas próprias capacidades. Além disso, foi identificado o efeito Dunning-Kruger, evidenciado por diferenças entre as percepções iniciais e finais dos estudantes sobre suas competências. O estudo ressalta o potencial da Aprendizagem Baseada em Projetos, em conjunto com outras abordagens, para promover o desenvolvimento integrado de habilidades técnicas e interpessoais na formação em Computação.
Investigating the Professional Profile of Software Architects in Brazil using Job Advertisements
Software systems are vital to industry, emphasizing the need for quality assurance. Software architecture underpins quality systems by reinforcing key requirements. However, defining the Software Architect role is still challenging, particularly in a dynamic market demanding complex systems. This emerging results paper investigates the profile sought for Software Architects in Brazil through an analysis of job ads collected from an online platform in October 2024. Of 411 ads, 286 were valid for analysis. The data revealed 191 different terms for the role, indicating a lack of standardization. The market favors candidates with formal education in IT and a broad skill set - ads listed an average of 11.4 skills, including APIs, Java, Azure, and DevOps. While planning and implementation tasks appeared in 69.5% of ads, activities like architecture management were less emphasized. Results also show a preference for in-person roles, and higher salaries were linked to degrees and on-site work. These findings help map employer expectations and reflect the diversity of the role in Brazil.
Exploring the Impact of GitHub Actions on Pull Request Reviews in Machine Learning Projects
Continuous Integration (CI) tools like GitHub Actions were originally designed to streamline development workflows in traditional software systems by automating tasks such as building and testing, which has proven beneficial in improving review efficiency. However, ML projects present additional complexities—such as non-determinism, challenging testing processes, and longer build durations—that may limit the effectiveness of CI in supporting efficient reviews. Given these unique challenges, it is essential to reassess how CI tools impact the review process within ML contexts. This study empirically investigates the impact of GitHub Actions on PR review dynamics across 55 GitHub-based ML projects, focusing on metrics such as time to close a PR (i.e., PR latency), PR churn, comments, and PR submission frequency. Using a Regression Discontinuity Design (RDD), we analyze PR data from 12 months before and after the adoption of GitHub Actions. Our results show that GitHub Actions does not significantly reduce PR review times in ML projects, with factors such as PR churn and backlog size playing a larger role in influencing review efficiency. Additionally, rejected PRs were characterized by higher churn and more extensive discussions. These findings suggest that, while CI tools automate repetitive tasks and reduce manual workload, they may not fully address the unique demands of ML project reviews. We provide practical recommendations to enhance review efficiency in ML workflows, including strategies for incremental PR submissions and optimized backlog management.
From Real-Time Conversation to User Story: Leveraging Agile Requirements through LLM
User stories have become the most widely adopted technique for requirements elicitation and documentation in agile teams. However, ensuring high-quality requirements through user stories remains a significant challenge. Natural Language Processing (NLP) techniques have been proposed to enhance the quality of these artifacts, but technological constraints have limited their effectiveness. More recently, the emergence of Large Language Models (LLMs) has prompted new approaches. Nonetheless, existing proposals remain preliminary and constrained. This research presents a conceptual framework for an LLM-based approach designed to support the generation of high-quality user stories from real-time conversations with end-users, thereby reducing the reliance on traditional requirements documents. The approach integrates context-specific information and incorporates automated and manual validation steps to ensure the quality of LLM-generated content and mitigate hallucinations. A preliminary evaluation was conducted with software engineering experts to evaluate the proposed approach's adherence to real-world problems. The proposal was perceived as easy to use, effective, and capable of producing high-quality outcomes. Furthermore, participants expressed a positive experience with both the introduction to the approach and their involvement in the evaluation. This engagement prompted reflections on novel opportunities for integrating LLMs into their professional practices.
Configuring Parameters of Search-based Software Engineering Tools with Multiple LLM Models
Search-Based Software Engineering (SBSE) tools offer automatic support by applying search-based techniques to solve different optimization problems of various software engineering areas. However, configuring SBSE tools often requires expertise in optimization techniques, posing a significant barrier for non-specialist users. This task involves selecting suitable algorithms, tuning parameters, choosing appropriate objective functions and search operators, and making decisions that affect optimization quality and performance. To address this challenge, we propose a multiple-LLM approach that integrates Large Language Models (LLMs), specifically ChatGPT-4, into SBSEworkflows to provide context-aware and natural language suggestions for parameter configuration. The approach follows a Divide and Conquer strategy, in which specialized LLMs are trained for distinct parameter configuration subproblems. As a proof of concept, we implemented OPLA-Wizard that works with OPLA-Tool v2.0, for Product Line Architecture (PLA) design. This assistant supports users in configuring algorithm settings, search operators, and objective functions through a user-friendly interface. Preliminary results show that the multiple-LLM approach improves accuracy, explanation clarity, and output format adherence compared to a single-LLM approach. This work contributes to the democratization of SBSE by reducing cognitive load, preventing misconfigurations, and making advanced optimization techniques more accessible to a broader audience.
Who Should Test the Requirement? A Comparative Study on Requirements Classification for Assigning Test Teams using the Pre-Trained Models
Analyzing software requirements is a complex task, particularly for projects with a large volume of requirements, and when conducted manually, this task is time-consuming and prone to human errors. Moreover, once the software implements the requirements, it is essential to conduct tests to ensure the correct validation. Within a software institute, each new requirement can be assigned to a test team (teams 1 and 2) responsible for ensuring coverage by updating or creating test cases. There are instances in which a requirement is not assigned to either the team or is assigned to both. Each test team is tasked with validating a specific scope of requirements, making it crucial that each requirement is analyzed and validated by an appropriate test team. If a test team fails to validate a requirement within its scope, it can result in software vulnerability. To mitigate these issues, this paper described the use of pre-trained models, such as BERT, XLNet, and ELECTRA, to automate the process of requirement classification, thereby determining which test team should validate each new requirement. We compared the models based on accuracy, precision, recall, F1-Score, and Area Under Curve (AUC) macro metrics. Notably, the XLNet model demonstrated superior performance among the models, achieving 93.16% AUC Macro, while the BERT model achieved 91.28% AUC, and the ELECTRA model achieved 90.17% AUC.We also applied the non-parametric Friedman test to statistically validate the results, followed by the Conover squared rank test, with a significance level of 0.05. The results indicate that XLNet outperformed the BERT and ELECTRA models, exhibiting a superior capacity for assigning requirements to the correct test teams. Given the promising results of this research, this study aims to demonstrate the viability of using pre-trained models as a solution to optimize the testing process in the software industry.
Refactoring Python Code with LLM-Based Multi-Agent Systems: An Empirical Study in ML Software Projects
Refactoring is essential for improving software maintainability, yet it often remains a validation-intensive and developer-guided task—particularly in Python projects shaped by fast-paced experimentation and iterative workflows, as is common in the machine learning (ML) domain. Recent advances in large language models (LLMs) have introduced new possibilities for automating refactoring, but many existing approaches rely on single-model prompting and lack structured coordination or task specialization. This study presents an empirical evaluation of a modular LLM-based multi-agent system (LLM-MAS), orchestrated through the MetaGPT framework, which enables sequential coordination and reproducible communication among specialized agents for static analysis, refactoring strategy planning, and code transformation. The system was applied to 1,719 Python files drawn from open-source ML repositories, and its outputs were compared against both the original and human-refactored versions using eight static metrics related to complexity, modularity, and code size. Results show that the agent consistently produces more compact and modular code, with measurable reductions in function length and structural complexity. However, the absence of a validation agent led to 281 syntactically invalid outputs, reinforcing the importance of incorporating semantic and syntactic verification to ensure transformation correctness and build trust in automated refactoring. These findings highlight the potential of LLM-based multi-agent systems to automate structural code improvements and establish a foundation for future domain-aware refactoring in ML software.
Evaluating the Capability of Prompted LLMs to Recommend NFR from User Stories: A Preliminary Study
[Context] Non-functional requirements (NFRs) are critical to software quality but are often underspecified in agile projects. Previous work proposed NFRec, a k-nearest neighbors (kNN) recommender system, to support NFR elicitation based on structured User Story metadata. [Objective] This study investigates whether Large Language Models (LLMs), when prompted with structured representations of User Stories, can generate relevant NFRs comparable to those recommended by NFRec. [Method] We reused the original dataset of 246 User Stories and adopted the same evaluation protocol. The gpt-4.1-mini model was queried using zero-shot prompting, instruction tuning, and role-playing strategies. Predicted NFRs were evaluated using effectiveness measures against the original ground truth. [Results] The LLM achieved high recall and moderate F1 performance but lower precision due to frequent overgeneration. The quality of recommendations was highly sensitive to prompt design. In several cases, the model produced plausible NFRs not present in the baseline, suggesting that traditional metrics may understate its practical value. [Conclusion] Prompted LLMs offer a viable and flexible alternative for NFR elicitation, especially in cold-start scenarios where historical data is scarce. This study serves as an initial step toward LLM-assisted requirements engineering, opening up new directions for research in prompt engineering, hybrid models, and evaluation metrics that better reflect semantic relevance and practical utility.
Towards Automating User Story Classification with Large Language Models Using a Reuse-Oriented Taxonomy
[Context] Agile Software Development (ASD) and reuse strategies are increasingly used to improve software productivity and maintainability. However, while reuse relies on structured and traceable artifacts, ASD often depends on informal elements such as user stories, limiting opportunities for systematic reuse. A recent taxonomy proposes classifying user stories to support traceability and asset reuse, but manual classification remains labor-intensive and error-prone. [Objective] This study investigates whether Large Language Models (LLMs) can automate the classification of user stories using a reuse-oriented taxonomy, reducing manual effort while preserving annotation quality. [Method] We adopted an explanatory sequential mixed-methods approach. First, a two-step prompting protocol was applied to classify user stories from 12 real-world projects using GPT-4-turbo. Then, we compared model outputs to expert annotations, measuring agreement and qualitatively analyzing disagreements to identify causes and propose corrective actions. [Results] The LLM achieved a 48.1% agreement rate with human labels, with project-specific performance ranging from 14.0% to 84.4%. Notably, in 46% of disagreement cases, the LLM’s classifications were judged more appropriate than the human label, and in only 25% the human labels were judged to be correct, highlighting inconsistencies in the human annotation process despite prior validation. [Conclusion] These initial findings suggest that LLMs can effectively assist in classifying user stories for reuse purposes. Beyond reducing labeling effort, they offer the potential as reviewers in collaborative workflows to improve consistency, transparency, and the overall quality of software artifact organization.
Code Smell Classification in Python: Are Small Language Models Up to the Task?
Code quality is essential for maintainable and evolvable software systems. Traditional code smell detection tools rely on AST-based techniques and metric-driven heuristics, which, while effective, often lack interpretability and require specialized knowledge. This paper investigates the use of Small Language Models (SLMs) for classifying two widely studied code smells—Long Method and Long Parameter List—in Python codebases. Unlike Large Language Models (LLMs), SLMs offer lower latency and reduced computational cost, making them suitable for deployment in resourceconstrained environments. We systematically compare the performance of SLMs with traditional Machine Learning (ML) and Deep Learning (DL) models, and the AST-based DPy tool. We also analyze the role of prompt engineering techniques—zero-shot and chain-of-thought—in enhancing SLM performance. Our evaluation considers precision, recall, F1-score, and processing time, using a custom event-driven dataset designed for code classification. Results show that SLMs achieve competitive accuracy with improved interpretability. Additionally, we release an annotated dataset comprising classifications from all approaches. This work provides new insights into lightweight, explainable, and practical methods for automated code quality assessment, and supports the broader adoption of SLMs in software engineering.
The Impact of Generative AI on Code Expertise Models: An Exploratory Study
Generative Artificial Intelligence (GenAI) tools for source code generation have significantly boosted productivity in software development. However, they also raise concerns, particularly the risk that developers may rely heavily on these tools, reducing their understanding of the generated code. We hypothesize that this loss of understanding may be reflected in source code knowledge models, which are used to identify developer expertise. In this work, we present an exploratory analysis of how a knowledge model and a Truck Factor algorithm built upon it can be affected by GenAI usage. To investigate this, we collected statistical data on the integration of ChatGPT-generated code into GitHub projects and simulated various scenarios by adjusting the degree of GenAI contribution. Our findings reveal that most scenarios led to measurable impacts, indicating the sensitivity of current expertise metrics. This suggests that as GenAI becomes more integrated into development workflows, the reliability of such metrics may decrease.
Language Models as Architectural Gatekeepers: Automating Conformance Checking from Natural Language
Ensuring that implemented code adheres to its intended architecture (architectural conformance) remains a critical challenge in software engineering. While formal verification tools exist, their use is hindered by the overhead of explicitly defining formal architectural specifications. At the same time, valuable architectural decisions and design constraints are often embedded in informal channels, such as pull request discussions and issue trackers, where they are expressed in natural language rather than formal specifications. In this paper, we explore the potential of Large Language Models (LLMs) to bridge this gap by investigating whether they can transform informal design rules, based on real development discussions on GitHub, into design tests — executable conformance checkers. Rather than relying on formal models, our approach focuses on deriving design tests from implicit architectural decisions discussed in natural language. To investigate this, we conducted a preliminary empirical study to generate 30 design tests representing rules for 6 design patterns. Our results show the potential of such a strategy, as 96.67% of the generated design tests execute successfully. Furthermore, 63.33% correctly assert expected behaviors, and 76.67% accurately reflect the intended architectural rules. This approach has the potential to simplify the conformance checking process by reducing the need to manually write formal specifications and tests. By leveraging existing development discussions, it makes the process more accessible and less time-consuming, and supports early identification of architectural violations during development.
Estimativa de Esforço em Story Points a partir de User Stories com Large Language Models
A estimativa de esforço em projetos ágeis continua sendo um desafio recorrente, especialmente quando os story points precisam ser inferidos apenas a partir do texto das user stories. Estudos anteriores focaram principalmente em abordagens de aprendizagem de máquina para predizer o esforço, mas a recente disponibilidade de Large Language Models (LLMs) oferece uma alternativa. O objetivo do artigo é investigar a eficácia dos LLMs em estimar story points. Um derivado do modelo BERT foi ajustado (fine-tuning) e comparado, em relação ao erro médio absoluto, a três baselines: (i) um modelo preditivo tradicional baseado em vetores TF-IDF acoplados a um classificador de Regressão Linear, (ii) um modelo LLM Zero Shot, e (iii) um modelo LLM few shot. Foi utilizado um conjunto de dados de user stories de projetos reais de desenvolvimento de software ágil, o Deep-SE, um dataset com várias User Stories de 16 projetos open-source diferentes retirados do Jira. Os resultados mostram que o LLM ajustado teve MAE menor na maioria dos projetos. Os achados sugerem que, apesar do custo computacional maior, LLMs constituem uma alternativa com menor erro para a estimativa de esforço do que as técnicas comparadas.
Pain in a Safe Space: Mapping Emotions and Discourse in the Womenintech Subreddit
Women in Information Technology (WIT) continue to face systemic challenges, including career stagnation, lack of recognition, workplace bias, and professional isolation. In response, external support networks such as the r/womenintech subreddit have emerged, offering a dedicated and inclusive space for women in Software Engineering (SE) to exchange experiences, seek advice, and build community. This study investigates the discursive landscape of this subreddit by analyzing 2,367 posts published between April 2024 and April 2025. We applied a set of natural language processing (NLP) techniques, using the Twitter-based RoBERTa model, to conduct a multi-dimensional analysis that includes emotion detection, sentiment analysis, hate speech classification, irony detection, and offensive content identification. Our findings show that 99.9% of the posts are free of hate speech, reinforcing the subreddit’s role as a safe space for women in tech to share experiences. However, the prevalence of the emotion Sadness (45%) reveal that the experiences reported are often distressing and unpleasant. In addition, we explore temporal trends in politically charged contexts of DEIA law. Our study highlights the importance of better understanding the underlying structural and cultural factors that contribute to these emotions and open new directions for further analysis.
Reimagining Studies’ Replication: A Validity-Driven Analysis of Threats in Empirical Software Engineering
Context: Replication studies play an important role in strengthening the empirical foundations of Software Engineering (SE). However, the existing literature reveals that the reporting of Threats to Validity (TTVs) remains inconsistent or superficial, potentially undermining the reliability of the replication results. Objective: The goal of this study is to analyze how replication studies consider TTVs present in original studies in SE. Method: We conducted a Systematic Literature Review (SLR) that resulted in 83 replication studies published between 2022 and 2024. We analyzed the presence and specificity of TTVs in four validity dimensions (construct, internal, external, and conclusion), considering different research methods and types of replication. Results: Our analysis shows that replication studies in Empirical Software Engineering (ESE) tend to report threats to validity more frequently and in greater detail than original studies, particularly with regard to external and internal validity. Nevertheless, threats related to the validity of the conclusion and construct remain underreported. We observed that controlled experiments generally address the different types of TTVs more comprehensively, whereas surveys and case studies provide more limited coverage. With respect to types of replication, close and differentiated replications are predominant, while conceptual and internal replications remain underexplored in the field. Conclusion: Although there is growing attention to the identification of TTVs in replication studies, reporting remains uneven across validity dimensions and study types. More structured and diverse replication strategies are needed, along with better guidelines to support comprehensive TTV reporting and enhance the rigor and methodological value of replication efforts in ESE.
AI-Generated User Stories: Are They Good Enough?
Large Language Models (LLMs), combined with advanced prompting techniques, have been used in requirements engineering, particularly in the automated generation of user stories. These stories are essential for agile software projects, but manual creation can be time-consuming and prone to inconsistencies, which has driven interest in automated approaches. Questions about the effectiveness and practical acceptance of these approaches, especially regarding quality and software professionals’ perceptions, still remain. Furthermore, little is known about users’ perspectives and the limitations of these new automation techniques. We conducted an empirical study with 24 participants who generated 457 user stories using the US-Prompt technique.We assessed the quality of the user stories using the QUS framework, and we analyzed the acceptance of the technique using the TAM3 model. Results showed that the US-Prompt method was effective, with 87.5% of the stories meeting more than 75% of the quality criteria. Participants found the technique easy to use and useful, although they identified limitations such as formatting inconsistencies and concerns about reliability for critical tasks. This study thus offers a provocative reflection on the use of LLMs and points to new directions for future research in this emerging area.
Uma página, muitas informações: como as universidades federais lidam com diferentes requisitos legais em seus sites?
Os portais web das universidades federais são, além de importantes veículos de comunicação pública, ferramentas de transparência ativa. Portanto, devem conciliar diferentes aspectos, como usabilidade e experiência do usuário, com diversos requisitos legais. Considerando a natureza complexa desse contexto, este estudo analisa o cumprimento dos requisitos legais nos portais das 69 universidades federais brasileiras. A partir de uma pesquisa exploratória nas páginas iniciais desses portais, foram analisados diferentes aspectos, como a disponibilização de documentos acadêmicos, a apresentação da carta de serviços e a disponibilidade das informações de transparência ativa, requisitos definidos por um conjunto de leis. Os resultados apontam variações com as normativas, evidenciando lacunas na disponibilidade dos dados e a importância não apenas de se aprofundar as discussões sobre o tema, mas também de se propor novas abordagens de Engenharia de Software e Interação Humano-Computador para esse contexto.
AI in the Design Thinking Toolbox: What to Recommend, When, and Why
Context: Although the use of Artificial Intelligence (AI) in software engineering is growing, the potential of Large Language Models (LLMs) to automate complex tasks in the software development process remains largely unexplored. Information-intensive decisionmaking tasks, such as selecting Design Thinking (DT) techniques for requirements elicitation, may significantly benefit from LLMbased solutions. Objective: This paper presents the automation of selecting DT techniques for specific project contexts, using LLMs as decision-support tools. We developed DT Selection Universe GPT, an LLM-based solution built on a structured repository containing 46 DT techniques and designed to operate using a prompt guided by the CRISPE model. Method: We investigated professionals’ perceptions of task automation through a qualitative study with four experienced participants from industry (INDT). The participants interacted with the tool and then participated in semi-structured interviews to share their perceptions of the experience. Results: Participants reported positive perceptions of using LLMs to automate the task of technique selection. They highlighted the system’s alignment with professional language, its adaptability to different contexts, the clarity of the recommendations provided, and the reliability of the results as key differentiators. Conclusion: The initial findings indicate that the DT Selection Universe GPT solution, developed using LLMs, shows strong potential to automate decision-support tasks for selecting DT techniques, offering benefits for novice and experienced professionals.
Toward Reliable Forward Snowballing in Systematic Literature Reviews: A Comparative Study and Framework Proposal
Systematic Literature Reviews (SLRs) play a vital role in the software engineering field by synthesizing existing knowledge, identifying research gaps, and guiding future investigations with methodological rigor. Given the rapid growth of published research, techniques such as snowballing are essential. Forward snowballing, in particular, helps to discover newer studies that cite key seed papers, enhancing the completeness of SLRs. Despite its value, when performed manually, it remains a labor-intensive and error-prone task. To address this challenge, we mapped existing tools that support forward snowballing. Our analysis focuses on the capabilities of these tools to automate core tasks, including the identification of relevant articles and the extraction of bibliographic metadata. We critically examine their reliability by comparing their outputs against a manually curated forward snowballing process. Key evaluation criteria include the completeness and relevance of the metadata retrieved, the quality of the retrieved scientific databases, and the ease of integration into SLR workflows. As future research, based on our findings, we will propose a framework that takes advantage of existing tools to automate forward snowballing.
On the Definition of a Method for Specifying Accessibility Requirements: Early Insights from a Focus Group with Practitioners’
Accessibility remains a significant challenge in software development, often due to the lack of structured and actionable guidance for specifying requirements that address diverse user needs. This paper introduces Path4All, a lightweight and user-centered method that integrates Personas, User Stories (US), Behavior-Driven Development (BDD), and WCAG guidelines to support the clear and consistent specification of accessibility requirements. To gather early insights into the method’s applicability, we conducted a focus group with experienced software professionals who applied Path4All in a practical, scenario-based activity. The findings suggest that Path4All fosters empathy, improves requirement clarity, and promotes the production of actionable and inclusive specifications. Participants highlighted the method’s potential benefits, while also identifying challenges related to WCAG complexity, organizational culture, and the need for clearer role definitions. These initial results point to Path4All’s potential to support inclusive design practices from the early stages of development.
Improving JavaScript Test Quality with Large Language Models: Lessons from Test Smell Refactoring
Test smells—poor design choices in test code—can hinder test maintainability, clarity, and reliability. Prior studies have proposed rulebased detection tools and manual refactoring strategies, most focus on statically typed languages such as Java. In this paper, we investigate the potential of Large Language Models (LLMs) to automatically refactor test smells in JavaScript, a dynamically typed and widely used language with limited prior research in this area. We conducted an empirical study using GitHub Copilot Chat and Amazon CodeWhisperer to refactor 148 test smell instances across 10 real-world JavaScript projects. Our evaluation assessed smell removal effectiveness, behavioral preservation, introduction of new smells, and structural code quality based on six software metrics. Results show that Copilot removed 58.78% of the smells successfully, outperforming Whisperer’s 47.30%, while both tools preserved test behavior in most cases. However, both also introduced new smells, highlighting current limitations. Our findings reveal the strengths and trade-offs of LLM-based refactoring and provide insights for building more reliable and smell-aware testing tools for JavaScript.
Investigating the Performance of Small Language Models in Detecting Test Smells in Manual Test Cases
Manual testing, in which testers follow natural language instructions to validate system behavior, remains crucial for uncovering issues not easily captured by automation. However, these test cases often suffer from test smells, quality issues such as ambiguity, redundancy, or missing checks that reduce test reliability and maintainability. While detection tools exist, they typically require manual rule definition and lack scalability. This study investigates the potential of Small Language Models (SLMs) for automatically detecting test smells. We evaluate Gemma3, Llama3.2, and Phi-4 on 143 real-world Ubuntu test cases, covering seven types of test smells. Phi-4 achieved the best results, reaching a 𝑝𝑎𝑠𝑠@2 of 97% in detecting sentences with test smells, while Gemma3 and Llama3.2 reached approximately 91%. Beyond detection, SLMs autonomously explained issues and suggested improvements, even without explicit prompt instructions. They enabled low-cost, concept-driven identification of diverse test smells without relying on extensive rule definitions or syntactic analysis. These findings highlight the potential of SLMs as efficient tools that preserve data privacy and can improve test quality in real-world scenarios.
Communication Challenges and Practices in AI-based Software Systems: An Exploratory Study
The integration of AI-based systems into software systems poses technical and organizational challenges, especially regarding communication between multidisciplinary teams. This qualitative study, grounded in the Socio-Technical Grounded Theory, investigates communication practices during the development and integration of AI-based systems. Conducted in two cycles with a total of 15 semistructured interviews, the study identifies five key communication challenges: lack of shared technical vocabulary, misaligned expectations and priorities, unstructured communication practices, and inadequate use of tools. These issues often lead to misunderstandings, rework, and miscoordination across teams. To address them, participants recommended strategies such as shared glossaries, regular alignment meetings, and standardized collaborative tools. These findings contribute to the understanding of socio-technical dynamics in ML-based software projects and offer practical recommendations to improve integration workflows and guide future Software Engineering practices.
Using Large Language Models to Classify Test Case Complexity with Explainability
The classification of black-box test case complexity is a key task in software testing, enabling resource prioritization and the identification of edge scenarios. In this work, we propose a three-stage LLM-based pipeline that integrates explanation generation into the classification process, treating justifications as central to model decision-making. Our approach formulates the task as a conditional generation problem, where LLMs are guided to first produce a rationale and then a complexity label. Experimental results demonstrate that this strategy improves both predictive accuracy and explainability compared to using LLMs directly for classification. We show that LLM-generated justifications not only enhance user trust but also contribute to more consistent and explainable decisions.
A Metaprotocol For a Family of Rapid Multivocal Reviews of Generative AI in the Software Industry
Context: With the growing interest in solutions based on Generative Artificial Intelligence (GenAI) applied to SE, a need to identify solutions beyond conceptual proposals and prototypes arises. In this rapidly evolving landscape, exploring methodological strategies that enable the identification of GenAI-based solutions used in the industry becomes essential. Goals: In this paper, we report on the experience of developing a metaprotocol for a family of Rapid Multivocal Reviews (RMRs) to identify operational GenAIbased technologies being used in the software industry (i) across the phases of the software development lifecycle and (ii) in the planning and executing SE empirical studies. Method: A metaprotocol was developed through an interactive process combining GenAI’s creative support with software engineers’ feedback. GenAI assisted in defining the stages of the RMRs family, while discussion cycles with software engineers contributed to refining and validating it. Results: Six RMR instances have been organized by covering the perspectives of Software Requirements, Design, Test, Coding, Management, and Empirical Methods described in SWEBOK 4.0. It allowed guiding the execution of the RMRs and highlighted the challenges of organizing the metaprotocol and justifying the decision-making. Conclusion: Using a metaprotocol to support the observation of industrial experience using GenAI in software projects through RMRs will contribute to organizing a body of knowledge regarding GenAI-based solutions currently available and used in the software industry to support the SWEBOK 4.0 practices.
RefModel: Detecting Refactorings using Foundation Models
Refactoring is a common software engineering practice that improves code quality without altering program behavior. Although tools like ReExtractor+, RefactoringMiner, and RefDiff have been developed to detect refactorings automatically, they rely on complex rule definitions and static analysis, making them difficult to extend and generalize to other programming languages. In this paper, we investigate the viability of using foundation models for refactoring detection, implemented in a tool named RefModel. We evaluate Phi4-14B, and Claude 3.5 Sonnet on a dataset of 858 single-operation transformations applied to artificially generated Java programs, covering widely-used refactoring types. We also extend our evaluation by including Gemini 2.5 Pro and o4-minihigh, assessing their performance on 44 real-world refactorings extracted from four open-source projects. These models are compared against RefactoringMiner, RefDiff, and ReExtractor+. RefModel is competitive with, and in some cases outperform, traditional tools. In real-world settings, Claude 3.5 Sonnet and Gemini 2.5 Pro jointly identified 97% of all refactorings, surpassing the best-performing static-analysis-based tools. The models showed encouraging generalization to Python and Golang. They provide natural language explanations and require only a single sentence to define each refactoring type.
Leveraging N-Version Testing to Define Approximate Oracles for Performance Testing
Performance testing plays a critical role in maintaining software quality by ensuring systems meet their expected efficiency and responsiveness. However, defining precise test oracles for performance testing remains a significant challenge. As a result, many software projects lack reliable performance test oracles, hindering the development of comprehensive test suites. Approximate test oracles have emerged as a promising alternative, offering practical means of validation in the absence of exact specifications. In this work, we explore the use of n-version testing, a technique traditionally used for fault detection through the comparison of multiple system versions, as a foundation for constructing approximate performance test oracles. Our approach leverages the performance history of recent versions of the system under test (SUT) to define an acceptable performance range. Testers configure key parameters such as the number of prior versions to consider, the strategy for computing reference performance, and the tolerance margin. When the current version’s performance falls outside the derived tolerance band, an alert is raised to trigger further investigation. In our preliminary investigation using a real-world proprietary software system (an image gallery application), we used historical performance data to demonstrate that our proposed approach would have been capable of detecting a known performance bug, previously confirmed by the development team.
Automated Generation of Exploratory Test Cases Using Prompt Chaining and Reflective Evaluation
Exploratory testing uncovers latent defects, but the design of Exploratory Test Cases (ETC) is largely manual, incurring high costs, reliance on expert knowledge, and limited reproducibility. We propose IGEX, a fully automated approach to generate ETCs using Large Language Models. IGEX models test generation as a structured chain of prompts, leveraging Chain of Thought reasoning and learning in context. To ensure quality, a Reflective Evaluator scores ETCs according to expert criteria, triggering refinements as needed. In line with Whittaker’s hybrid ETC definition, our method combines structured scripting with tester-driven exploratory detours, enabling automation. In experiments with 300 Android test scenarios, IGEX achieved 97.67% accuracy before reflection and 100% after iterative evaluation. Although dataset-agnostic and extensible, current validation is limited to mobile applications. Furthermore, IGEX inherits the challenges of LLM, including evaluation subjectivity and computational costs. These results demonstrate the potential of LLM for scalable exploratory testing with reduced manual overhead.
Investigando a Integração Estrutural de LLMs em Ecossistemas de Software: Um Estudo com Modelagem SSN
Ecossistemas de software (ECOS) são compostos por atores interconectados que colaboram na produção de software. A notação Software Supply Network (SSN) permite modelar estruturalmente esses ecossistemas, destacando as relações entre plataformas, ferramentas e agentes envolvidos. Com a crescente adoção de Modelos de Linguagem em Larga Escala (LLMs), como GitHub, Copilot e ChatGPT, novas dinâmicas emergem no desenvolvimento de código aberto, ainda pouco compreendidas de uma perspectiva estrutural. Este trabalho propõe uma análise preliminar do papel dos LLMs como agentes em quatro ecossistemas distintos — LangChain, VSCode, Transformers e Pandas — por meio da modelagem SSN e análise automatizada de Pull Requests. Os resultados revelam padrões contrastantes de centralidade dos LLMs, destacando seu potencial como elementos de reestruturação em redes de produção de software. A abordagem oferece uma nova lente para entender a inserção da IA em ECOS e levanta hipóteses relevantes para investigações futuras.
Enhancing Hackaton Practices in Software Engineering: a Neuroscience-Informed Model for TeamWell-being and Software Quality
High-pressure environments in the Information Technology (IT) sector have raised increasing concerns about mental health and team performance, particularly during intensive events such as hackathons. These collaborative, time-constrained gatherings, widely used in Software Engineering, often reproduce real-world industry stressors, negatively impacting how participants think and feel during the event. This paper presents a neuroscience-informed model designed to optimize hackathon practices by integrating human factors into their planning and execution. Structured into three interdependent dimensions: (i) Sustainable Cognitive Activation, (ii) Emotional Security and Interpersonal Relationships, and (iii) Regenerative Architecture. This model promotes well-being and enhances software quality under pressure. Grounded in cognitive neuroscience and aligned with Brazil’s updated Regulatory Standard No. 1 (NR-1/2025), the proposal will be empirically validated through a controlled experimental study with randomized participant groups. The expected results include reduced stress, improved team dynamics, and higher-quality technical outcomes. Beyond hackathons, the model offers scalable strategies to foster healthier, high-performance environments in the broader IT sector.
Can the Linux kernel sustain 30 more years of growth? Toward mitigating bottlenecks in its development model
The Linux kernel, a cornerstone of modern computing and Free Software, forms the foundation of the GNU/Linux ecosystem and critical services like the Internet. Its development model integrates diverse workflows that extend beyond technical concerns. Despite its success, the project relies on key individuals and ad-hoc tools, raising sustainability and workforce renewal concerns. Moreover, known challenges within its development model remain underexplored in academic research. This paper presents ongoing efforts to develop taxonomies that describe these workflows, aiming to identify bottlenecks and guide the creation of Free Software tools to support the kernel long-term sustainability.
Comparing LLMs and Proposing an ML-Based Approach for Search String Generation in Systematic Literature Reviews
The formulation of an effective search string is a critical process in systematic literature reviews (SLRs), as it directly influences both the coverage and precision of the retrieved studies. Traditionally, this process relies on manual keyword selection and expert-driven refinements, making it laborious, susceptible to human bias, and often inaccessible to non-specialists. To address these limitations, this study explores the application of artificial intelligence (AI) to support the generation of search strings.We organized our ongoing investigation into two main phases. In the first phase, we evaluated the performance of search strings generated by different large language models (LLMs), specifically Llama-8B, Gemma-12B, and Mistral-Nemo-12B, using a previously published SLR as a benchmark. Our results suggest that, while LLMs can assist in search string formulation, their effectiveness is inconsistent and sensitive to input conditions. Motivated by these limitations, we propose a semi-automated pipeline based on Machine Learning (ML). Through our preliminary analysis, we proposed a standardized reproducible evaluation framework to assess and compare AI-based search string generation strategies, including our proposed ML-based approach.
Mobile Robotics for Throughput Testing in a Reconfigurable Test Environment
The growing demand for wireless connectivity in applications such as the Internet of Things (IoT), autonomous vehicles, and industrial automation requires accurate performance evaluation of networks in mobile and dynamic environments. This work proposes the development of a reconfigurable test environment based on mobile robots, using Raspberry Pi Zero 2 W boards to periodically collect Wi-Fi signal data from different positions within a physical space. Two experimental scenarios are considered: (i) client mobility, in which a Mesh router is mounted on a robot that performs measurements while moving, while the Raspberry Pi remains stationary collecting data; and (ii) infrastructure mobility, in which Mesh routers mounted on robots move while the Raspberry Pi remains fixed, collecting data. Data collection is performed using native commands from the embedded Linux system, and results are stored in JSON files for later analysis. This approach directly evaluates signal degradation, connection instability, handover events, physical obstacles, and network fluctuations in realistic scenarios. The expected outcomes of our research include the creation of a valuable dataset for validating wireless connectivity quality and supporting the development of more robust solutions for mobile networks and dynamic environments. This work presents an innovative reconfigurable testbed combining mobile robots and automated diagnostics capable of accurately and reproducibly evaluating handover and latency in Wi-Fi Mesh networks.
SafeSecRETS: A Safety and Security Requirements Tool for Critical IoT Systems
[Context] Assuring safety and security from the earliest stages of development is essential, particularly for critical systems. However, addressing these requirements in complex and heterogeneous systems such as those based on the Internet of Things (IoT) is challenging. These systems often operate in dynamic and diverse environments, where vulnerabilities can lead to severe consequences if not effectively mitigated. [Objective] This paper presents SafeSecRETS, a tool supporting safety and security Requirements Engineering (RE) for critical IoT systems. [Method] The tool features a collaborative pipeline with a strategic canvas-based IoT project planning and an extended Systems-Theoretic Process Analysis (STPA) method for safety and security. [Results] SafeSecRETS assists requirements engineers, domain experts, and other stakeholders in collaboratively defining project scope and eliciting, analyzing, and specifying system requirements. Its interconnected visual components guide users through this process, fostering engagement among information, people, and decision-making. A case study on an automated insulin delivery system illustrates the tool’s applicability and presents its structured and integrated approach to RE safer and more secure critical IoT systems. SafeSecRETS demo video: https://zenodo.org/records/17000378
PeacemakerBot: A LLM-Powered Bot for Identifying and Reducing Signs of Incivility in GitHub Conversations
Context: Developers’ interactions on collaborative software development platforms like GitHub are key to maintaining technical alignment and community engagement. However, uncivil behaviors such as disrespectful, sarcastic, or offensive comments can undermine these efforts, discouraging contributions and harming code quality. Goal: This study introduces PeacemakerBot, an automated moderation tool that detects and warns developers of incivility signs in GitHub conversations. Method: We leverage Large Language Models (LLMs) to analyze conversations, identify signals of incivility, and generate reformulation suggestions in real time. To evaluate it, we conducted a user study with six developers, followed by a survey based on the Technology Acceptance Model (TAM) to understand their perception of the tool’s usefulness. Results: Our results suggest that PeacemakerBot successfully identifies multiple types of incivility and promotes more constructive conversations. The moderation feedback loop allows users to revise flagged comments, enhancing awareness and reducing harmful language over time. Conclusion: Our tool fills a key gap in OSS by providing AI-assisted moderation to enhance the social climate and inclusiveness of developer interactions. Video link: https://doi.org/10.5281/zenodo.15485535
JS-Distributor: decomposing monolith applications into microservices
While the decomposition of monolithic applications into microservices has been widely studied, most existing approaches stop at architectural analysis or service identification, offering little support for the actual generation and deployment of microservices. This creates a gap between design and implementation, often requiring significant manual effort from developers. It also limits researchers, who lack practical tools to test and experiment with new decomposition strategies in real-world scenarios. To address these challenges, we present JS-Distributor, a tool that automates the transformation of monolithic JavaScript applications into microservices. JS-Distributor generates much of the required boilerplate code for Node.js, including server setup and inter-service communication code, supporting both HTTP APIs and asynchronous messaging systems. By bridging the gap between decomposition and deployment, the tool enables rapid experimentation with different microservice architectures. We evaluated JS-Distributor using a benchmark system commonly adopted in microservice research, successfully distributing the original monolith into functional microservices while preserving its original logic. Demo video: https://doi.org/10.5281/zenodo.15477214
womeninoss.com: Supporting women participation in OSS communities with an online platform
Women are severely underrepresented in open-source software (OSS) communities, accounting for only 10% of overall contributors [20]. Unlike their male counterparts, women often face genderspecific barriers that diminish their participation in open source, including issues such as impostor syndrome, gender bias, and a lack of visible role models [20]. These challenges create a compounding effect that perpetuates their underrepresentation and limits their contributions within OSS projects, highlighting the need for interventions that can foster more inclusive and equitable environments. To support women to overcome these challenges and promote their participation in OSS, we propose the development of womeninoss.com: an online platform designed to educate, empower, and support women’s involvement in open-source communities. Designed to support both newcomers and maintainers in OSS, our web-based platform offers research-driven insights on gender inclusion in open source, along with a suite of practical tools to help individuals and communities increase and sustain women’s collaboration in OSS projects. In a preliminary evaluation of our platform, we invited 15 software developers to provide feedback on its significance, content relevance, and potential impact on fostering women’s participation in OSS. Our preliminary findings suggest that the platform was well-received, with participants highlighting its potential to serve as a valuable resource for both newcomers and community maintainers. Demo video: https://zenodo.org/records/15465699
Highlight Test Code: Visualizing the Co-Evolution of Test and Production Code in Software Repositories
The asynchronous evolution of test and production code can compromise software quality and maintainability. However, identifying and analyzing such co-evolution dynamics remains a complex task, often hindered by the lack of scalable tools and comprehensive visualizations. This paper presents Highlight Test Code, a web-based platform for analyzing the co-evolution of test and production code in open-source repositories. The platform implements a multi-stage pipeline encompassing repository mining, time series generation, clustering, and statistical correlation. It is built upon a curated dataset of 526 GitHub repositories across six programming languages. Highlight Test Code offers visual analytics and AI-generated insights that assist users in identifying test evolution patterns, evaluating co-evolution levels, and understanding their relationship with maintenance activities and project characteristics. The tool enables researchers and practitioners to assess testing practices at scale. Video link: https://youtu.be/U29eEg_gXXM. Software License: General Public License (GPL).
ArchLintor: detecting architectural violations in TypeScript systems
Maintaining architectural integrity is challenging in fast-paced development environments, especially in TypeScript systems where architectural analysis is hindered by language complexity. This paper introduces ArchLintor, a static analysis tool for architecture conformance checking in TypeScript projects. By allowing architects to define rules over module interactions, ArchLintor detects architectural violations, classifies them (e.g., divergences, absences, alerts), and produces detailed reports and visualizations through graphs and dependency structure matrices (DSM). The tool supports CI/CD integration, serving as a quality gate to prevent architectural erosion before code is merged. Entirely built from scratch using widely adopted JavaScript ecosystem tools, ArchLintor offers developers a practical solution to monitor and enforce architectural rules continuously. Demo video: https://doi.org/10.6084/m9.figshare.29123549
FluentArch: uma abordagem moderna para verificação de conformidade arquitetural em C#
Sistemas de software com longos ciclos de vida estão sujeitos à erosão arquitetural, comprometendo sua manutenibilidade e qualidade. No ecossistema C#, ferramentas como NetArch-Test.eNhancedEdition e ArchUnitNET auxiliam na verificação de conformidade arquitetural, mas apresentam duas limitações importantes: (i) operam sobre o bytecode compilado, restringindo a análise a construções pós-compilação e (ii) oferecem expressividade limitada na definição de regras personalizadas. Este trabalho apresenta o FluentArch, uma API fluente baseada no compilador Roslyn que permite a definição e verificação de regras arquiteturais diretamente sobre o código-fonte. A abordagem possibilita uma análise com granularidade mais fina, identificação precisa de dependências e suporte à criação de regras customizadas, superando restrições das soluções existentes. O uso prático da ferramenta em um projeto open source de terceiros evidenciou sua efetividade na detecção de violações arquiteturais e sua aplicabilidade em cenários reais, reforçando seu potencial como alternativa moderna e flexível para verificação arquitetural em sistemas C#. Demo vídeo: https://doi.org/10.6084/m9.figshare.29139881
AromaDr: A Language-Independent Tool for Detecting Test Smells
Ensuring high-quality test code is critical for the success and maintainability of software projects. Poorly designed tests, known as test smells, can undermine this goal by making test code harder to understand, maintain, and extend. Although various tools exist to detect and refactor test smells, most are tailored to specific programming languages, limiting their effectiveness in polyglot development environments. To overcome this limitation, we introduce AromaDr, a language-independent tool capable of detecting ten common test smells across multiple programming languages, including C#, Java, JavaScript, TypeScript, and Python. The smells detected by AromaDr include: Assertion Roulette, Conditional Test Logic, Duplicate Assert, Empty Test, Exception Handling, Ignored Test, Magic Number, Redundant Print, Sleepy Test, and Unknown Test. Beyond its language-independent detection capabilities, AromaDr offers several practical features: a graphical user interface for intuitive interaction, precise localization of test smells within the code, and an API that facilitates seamless integration with other development tools. To our knowledge, AromaDr currently supports the broadest range of programming languages among available test smell detection tools. In addition, AromaDr provides several features that distinguish it from other test-smell detection tools: a graphical interface (many alternatives are command-line only), the ability to pinpoint the exact line where each test smell occurs and a REST API that enables seamless integration with other tools. Video: https://zenodo.org/records/15467769
DABCheck: Um Plugin para Detecção de Mudanças Disruptivas em Argumentos-Padrão de Bibliotecas Python
No ecossistema Python, os valores-padrão são amplamente utilizados para simplificar o uso de métodos e funções em APIs. Esse recurso permite que métodos sejam chamados sem a necessidade de especificar todos os argumentos, atribuindo automaticamente valores-padrão aos argumentos omitidos. Acontece que, ao modificar o valor-padrão de um argumento, o comportamento dos clientes que dependem deste valor-padrão também são afetados. Essa mudança disruptiva é conhecida como Default Argument Breaking Change (DABC). Neste artigo, apresentamos o DABCheck, um plugin para detectar chamadas de métodos expostas a DABCs. Desenvolvido para as IDEs PyCharm e Visual Studio Code, o plugin funciona como um linter, analisando o código-fonte em tempo real e destacando chamadas vulneráveis. Atualmente, ele suporta a detecção de DABCs em três bibliotecas Python: Scikit-Learn, NumPy e Pandas. O artigo detalha as funcionalidades do plugin, sua arquitetura em cada IDE, e apresenta um exemplo de uso. Demo Video: https://youtu.be/Ht_oRvqnsFs.
KnowEval: A Tool for Supporting Knowledge Transfer Evaluation
The evaluation of Knowledge Transfer (KT) processes is essential for promoting organizational learning, enhancing operational efficiency, and fostering innovation. However, existing tools described in the literature offer limited support to organizations in this area. In general, knowledge about these tools remains unsystematized, lacks empirical validation, and is not widely adopted in practice. This article presents an overview of the key features of KnowEval, a decision support tool designed to recommend appropriate processes for KT evaluation based on strategic input variables. Furthermore, we describe the structured and dynamic database that enables the continuous integration of new evaluation processes. Finally, we present the validation results of KnowEval, using scenarios derived from an exploratory review of the literature. Video Available on: https://zenodo.org/records/15485087
Uma ferramenta para apoiar a análise de requisitos de software de IoT utilizando técnicas de agrupamento
O aumento da complexidade das aplicações da Internet das Coisas (IoT) trouxe novos desafios na gestão e organização de requisitos funcionais. As abordagens tradicionais de engenharia de requisitos muitas vezes enfrentam dificuldades para lidar de forma eficaz com a heterogeneidade e a variabilidade semântica inerentes ao contexto da IoT. Para enfrentar esses desafios, este trabalho apresenta a Tool4IoTReq, uma ferramenta projetada para classificar requisitos funcionais e não funcionais e agrupar apenas os requisitos funcionais no contexto de aplicações IoT. A solução é fundamentada em uma revisão exploratória da literatura que identificou características dos sistemas IoT. A ferramenta categoriza automaticamente os requisitos e agrupa aqueles com características semânticas semelhantes, melhorando a organização e a análise das demandas do sistema. A ferramenta é uma aplicação full-stack que apoia o processo de engenharia de requisitos em ambientes IoT e permite que engenheiros de requisitos documentem, classifiquem e agrupem requisitos de forma mais eficiente, auxiliando-os nos processos de tomada de decisão em contextos IoT dinâmicos e heterogêneos. Ferramenta: https://zenodo.org/records/17059260 Apresentação (Zenodo): https://zenodo.org/records/15485952 Licença: MIT
Tool Support for Spectrum-based Fault Localization during Continuous Integration
Program debugging is one of the most time consuming activities carried out by developers because, in large extent, it is performed in ad hoc fashion. Significant research efforts have been directed to the development of new debugging techniques, in special, fault localization techniques. Spectrum-based Fault Localization (SBFL) is a debugging technique that has been experimented on programs similar to those developed in industry with promising results. To support the automated application of SBFL, tools have been developed, yet in the academic realm. Few of them, though, aim to support SBFL in the context of the Continuous Integration (CI) practice. We present the Jaguar Portal platform, designed and developed to receive, store, and provide access to SBFL information in CI environments. The platform encampsulates the Jaguar 2 tool, which is responsible for executing the SBFL technique during the build process in the CI pipeline on GitHub. Furthermore, it provides web interfaces that display SBFL analyses with code snippets and suspicious line markings.We believe Jaguar Portal is a step towards the adoption of SBFL techniques in industrial settings. Demo video: https://www.youtube.com/@JaguarPortalSBFL.
Kworkflow A Linux kernel Developer Automation Workflow System
The Linux kernel is a central project to the Free/Libre and Open Source Software (FLOSS) ecosystem. Developers who interact with the kernel source code routinely face a variety of repetitive and error-prone tasks, including setting up testing environments, managing kernel configuration files, compiling with various toolchains, deploying to varied targets, and correctly submitting patches. These tasks, though essential, often require handcrafted scripts that become fragile, difficult to maintain, and disconnected from the core development goals. Kworkflow (kw) is a Developer Automation Workflow System (DAWS) that aims to provide high-quality tools that mitigate known bottlenecks experienced by kernel developers in their daily workflows. It provides a unified Command-Line Interface (CLI) that automates and streamlines many tasks, allowing practitioners to focus more on developing code and less on setup overhead and details. The hub-like design of the project reflects its philosophy of incorporating existing tools to avoid duplication of efforts and wasted resources from the community, a by-product of the many ad-hoc scripts developers commonly create. The kw tool also offers a data collection infrastructure, which makes it an excellent platform for further scientific research in the Linux kernel development model. In this sense, kw serves as a robust tool for real kernel developers and an opportunity for academic research work. Demo video: Software Heritage permalink [19].
Solaria-GPT: A Tailored ChatGPT Tool for Usability Inspection
Usability defects in software systems result in challenges for users during their interactions with the software. To address these challenges, usability inspection is key for detecting defects during software development, allowing them to be fixed before the defects reach end users. It also plays a critical role after software implementation, during the software maintenance phase. This paper presents Solaria-GPT, a tool based on a tailored version of ChatGPT, designed to assist software engineers in identifying and classifying usability defects following Nielsen’s heuristics. Solaria-GPT facilitates two interactions: the detection of usability defects in user interfaces and the classification of each defect based on the violated heuristic. To evaluate the tool, we conducted a study to assess the performance of Solaria-GPT across textual and media-based inputs (screenshots and videos), focusing on its accuracy rate (correct heuristic violation), utility rate (valid defect identified by Solaria-GPT), and new defect rate (new defect identified by Solaria-GPT). The results indicated a 96.23% accuracy rate in heuristic classification from textual inputs. For utility rate and new defect rate, the Solaria-GPT achieved 86.67% and 86.67%, respectively, for screenshots, and 16.13% and 87.10%, respectively, for videos. Comparisons with other large language models (Claude, Qwen, Gemini, and Deepseek) demonstrated that Solaria-GPT outperformed all alternatives across metrics. These findings suggest that Solaria-GPT is a promising tool for enhancing software usability during the software development lifecycle. Demo Video: https://doi.org/10.5281/zenodo.15275798
QAnubis - Uma Ferramenta Web de Apoio ao Processo de Análise Qualitativa
A principal atividade da pesquisa qualitativa é a análise de dados, a qual envolve um processo de coleta e análise de dados narrativos, incluindo textos, fotos, elementos audiovisuais e diversos formatos de arquivos digitais. Diferentes abordagens e metodologias estão disponíveis para a investigação de dados qualitativos, com maior ênfase na codificação, em que artefatos e seus conteúdos são categorizados sob um conjunto finito de categorias. Assim como em outras áreas, são realizados esforços para desenvolver e aprimorar ferramentas computacionais conhecidas como Software de Análise Qualitativa Assistida por Computador, que visam aumentar a eficiência e a eficácia do processo de análise ao fornecer meios para auxiliar na identificação, organização, interpretação, exploração e integração dos dados. Com o intuito de contribuir para o campo da análise qualitativa, este trabalho apresenta uma ferramenta web de código aberto chamada QAnubis, voltada para a realização de codificação em arquivos PDF, preservando seu conteúdo e formatação originais. Para conceber essa aplicação, o presente trabalho define os requisitos, as decisões de projeto e os detalhes de implementação, além de apresentar uma ilustração das funcionalidades da ferramenta. Por fim, é apresentada uma avaliação empírica, que buscou a opinião de especialistas sobre o software desenvolvido. O QAnubis foi considerado relevante na área devido à sua natureza de código aberto e à inclusão de funcionalidades essenciais de análise. Link do vídeo: https://doi.org/10.5281/zenodo.15483877
CaLMo: A Tool to support the use of Causal Loop Diagram in Software Engineering
Software organizations involve several processes, people, practices, culture, and other factors that affect their behavior. Understanding the organizational environment is crucial for improving processes and products. System Thinking (ST) can help in this matter. It views an organization as a system composed of elements and interconnections coherently organized in a structure that produces a characteristic set of behaviors. ST offers several tools, among which the Causal Loop Diagram (CLD) stands out. It represents feedbackdriven behaviors in complex systems and enables the visualization of organizational dynamics and the identification of systemic patterns. By understanding how the organization behaves, it is possible to identify problems and define actions aimed at improving products and processes. Currently, the creation of CLDs often relies on generic drawing/diagramming tools, which are prone to modeling errors and do not support the identification or analysis of behavior patterns. Additionally, most of these tools are limited to drawing the diagram and do not store the underlying represented data. To address this gap, this paper presents CaLMo, a tool designed to assist software engineers in modeling and analyzing CLDs to support Software Engineering tasks. CaLMo allows users to define variables, establish causal links between them, and detect feedback loops. Moreover, it automatically identifies archetypes that represent behavior patterns. We illustrate the use of the tool considering a case study in which CLDs were used to support the adoption of agile practices in an organization. A short video showing CaLMo is available at https://doi.org/10.5281/zenodo.15477387.
Test smells, anti-patterns in test code, have emerged as key indicators of test quality, attracting significant attention in software engineering research. Automated detection of test smells is crucial for maintaining effective and readable test suites, yet existing tools often lack comprehensive language support. At the same time, sentiment analysis is gaining prominence as a technique for understanding developers’ emotional states during coding activities, providing deeper insights into software quality. Motivated by these research gaps, we present DNose, the first dedicated tool for detecting test smells in Dart-based projects. DNose identifies 14 types of test smells, correlates their introduction with developer sentiment derived from commit messages, and provides integrated insights into test code quality and developer emotions. Our approach contributes to enhancing test maintainability while illuminating emotional aspects of software development practices. Link to the video: https://youtu.be/fCYdDZA8Hkg.
ResilienceBench-Operator: A Kubernetes Extension for Orchestrating Resilience Experiments on Microservice Applications
Microservice-based applications often rely on resiliency patterns such as Retry and Circuit Breaker to mitigate the impact of failures in service-to-service communication. However, there is still limited tooling support for systematically and reproducibly evaluating the performance impact of these patterns in realistic deployment environments. This paper presents ResilienceBench-Operator, a Kubernetes native tool that orchestrates resilience experiments directly on microservice applications deployed in Kubernetes clusters. ResilienceBench-Operator is an evolution of the original ResilienceBench tool, which was focused on controlled environments with predefined client-server interactions. The new version introduces a fully declarative approach to define test spaces, automatically expands them into concrete test scenarios, injects failures, and configures resiliency strategies across real service dependencies. This paper describes the motivation, architecture, and main functionalities of ResilienceBench-Operator, and illustrates how it enables systematic evaluation of resiliency strategies in a representative microservice system. Demo video: https://youtu.be/ZSQcx6Ab37w.
AriesLinter: Sniffing Test Smells Before They Happen
Software quality depends not only on production code but also on the quality of test code. Among the factors that compromise this quality, test smells stand out, poor implementation patterns in tests that negatively affect the readability, maintainability, and reliability of the test suite. Although tools such as tsDetect and JNose support test smell detection, they operate post-hoc, requiring the code to be complete and analyzed outside the development environment. Other tools, like RAIDE, offer detection within the IDE via plugins; however, the analysis is not instantaneous and still occurs after the code is written. These reactive approaches result in delayed feedback and significantly increase the refactoring effort. In this context, we propose AriesLinter, a static analysis tool that can be integrated into major development environments and is capable of detecting test smells in real time, as the test code is being written. Built on top of the Checkstyle infrastructure, AriesLinter automatically detects 10 of the most recurrent test smells reported in the literature and commonly found in Java projects. The tool is cross-platform and compatible with multiple IDEs. By anticipating the detection of poor patterns and embedding it into the natural workflow of developers, AriesLinter acts proactively, reducing the likelihood of test smells being introduced into the codebase and fostering a culture of continuous attention to test quality. Demo video: https://youtu.be/Cj6mQGGHlvk
Silver Bullet - Software Project Management Process Support Tool
Software engineering is essential to modern software development, encompassing methodologies, tools, and practices to ensure quality, maintainability, and adherence to deadlines and budgets. However, many software projects still fail due to poor or absent management practices. According to the Project Management Institute (PMI), organizations with a strong project management culture achieve a 71% success rate and significantly fewer financial losses. In response to the need for better training in software management, the Silver Bullet tool. was created in 2018 to support teaching and learning aligned with PMI’s PMBOK®. Initially developed for the Problem Solving VI course in a Software Engineering program, the tool aimed to improve both project outcomes and management practices. Since then, it has evolved beyond academia, contributing to professional training and addressing challenges in software project success. The ongoing development of Silver Bullet reflects advancements in educational tools and the broader effort to strengthen the software engineering field. License: Subscription License (SaaS). Demo video: https://doi.org/10.5281/zenodo.16237208.
DANTES: Automating Detection and Refactoring of Test Smells
Test smells affect software quality and hinder code maintenance. Refactoring test code is the main way to address these problems. However, manually refactoring is not a simple task and is usually tedious and error-prone. This study aims to present dantes, a tool for automatically detecting and refactoring eleven different types of test smells. We introduce eleven original refactoring algorithms. We conducted a study to evaluate the tool from the perspective of perceived usefulness and ease of use. Results show that dantes is well received by professionals and academics in the field. Demo video: https://youtu.be/uc5G6JMXtBs
Thoth 2.0: Advancing an RSL Tool for Enhanced Snowballing Support
Thoth is an open-source, web-based tool designed to support researchers in conducting Systematic Literature Reviews (SLRs) by automating critical phases of the review process. Currently in its final testing and refinement stage, the tool introduces an advanced Snowballing module that systematically identifies relevant studies through backward and forward citation analysis, integrated with the CrossRef API for reliable metadata retrieval. By automating repetitive tasks, including study selection, quality assessment, and data extraction, Thoth 2.0 significantly reduces manual effort while minimizing human error. Its user-friendly interface supports collaborative workflows, enabling geographically dispersed teams to coordinate SLRs seamlessly. As a freely available solution, Thoth 2.0 addresses key limitations of existing SLR tools, offering a unified platform that combines automation, rigorous methodology, and adaptability to diverse research needs. Its Snowballing module, in particular, extends literature coverage with minimal researcher intervention, demonstrating the tool’s potential to enhance the efficiency and reproducibility of evidence synthesis. Thoth demo video: https://doi.org/10.5281/zenodo.15493167
Framework RAAR: Uma Abordagem Prática para Sinergia e Eficiência no Desenvolvimento de Software
Equipes de desenvolvimento de software em grandes organizações frequentemente enfrentam desafios como fragmentação tecnológica, redundância e baixa colaboração. Este artigo apresenta o Framework RAAR (Radar Tecnológico, Arquiteturas de Referência, Artefatos Reutilizáveis e Registro de Decisões de Arquitetura), uma abordagem estruturada baseada em governança tecnológica e reuso para equilibrar padronização e flexibilidade. Descrevemos o contexto de aplicação no CPQD, como o framework endereça desafios da indústria e os indicadores propostos para validar seus benefícios.
Express Release Validation: Enhancing Quality in tight development timelines
The industry’s strong demand for increasingly faster software releases has led testing professionals to seek agility in their processes. This article proposes the Express Release Validation approach, based on essential quality criteria and the experience of quality assurance analysts in the project. This new strategy seeks to optimize testing time by focusing on the most critical aspects of the system without compromising the product reliability.
Log-Driven Autonomic Auto-Scaling with LSTM Forecasting: An Industrial Case in On-Premises Containerized Systems
This work presents an autonomic auto-scaling solution for a containerized system deployed on on-premises infrastructure. The solution addresses the lack of native autoscaling — the automatic adjustment of computing resources to match workload demand — in private environments by implementing a self-managing architecture based on the MAPE-K (Monitor-Analyze-Plan-Execute) control loop, an established methodology where the system continuously monitors itself, analyzes changes, plans reactions, and executes them using existing knowledge. It incorporates a Long Short-Term Memory (LSTM) neural network to proactively forecast workload spikes, enabling informed scaling decisions before performance degradation occurs. A key innovation is the non-intrusive, log-driven approach, where system logs serve as the primary knowledge source for analysis and scaling decisions. Preliminary evaluation using a dataset collected from a production deployment at a Brazilian public institution reveals improved system responsiveness and resource utilization during peak demand. These results, derived from a real-world, industrial-scale scenario, demonstrate the practical applicability of the proposed solution and indicate that the LSTM-driven auto-scaler can maintain quality of service under variable workloads while optimizing resource usage.
Projeto Arquitetural para Escalabilidade: Plataforma de Poupança-Incentivo Pé-de-Meia
A Plataforma de Poupança-Incentivo Pé-de-Meia é uma iniciativa do Ministério da Educação voltada à execução automatizada de transferências condicionais de renda para estudantes do ensino médio da rede pública registrados no CadÚnico. Diante do volume de dados e da criticidade do serviço prestado, optou-se pela adoção de uma arquitetura cloud-native baseada na infraestrutura da Amazon Web Services (AWS), garantindo escalabilidade, resiliência e alta disponibilidade. A combinação de serviços como Amazon EKS, RDS, EC2, S3 e ferramentas de observabilidade permitiu construir uma solução robusta, segura e com capacidade de rápida adaptação, atendendo aos requisitos operacionais e regulatórios exigidos em ambiente governamental.
Evolving Practices in Distributed R&D&I Projects: Bridging Academia and Industry Through Lightweight Collaboration
This presentation reports the best practices and methods adopted by the Alan Turing Lab (ATLab) research group in the past years, running distributed research, development, and innovation (R&D&I) projects with a global industry partner. This work highlights the software engineering processes thatwere iteratively refined through years of collaboration.We also share insights in two domains where our researchers stand out: Visualization and Artificial Intelligence. This report may be useful for research groups and organizations beginning to engage in innovation partnerships.
Escalando a Gestão de Dados para a Educação Pública: O Caso do Hub Educacional - Sistema Gestão Presente (SGP)
Este artigo apresenta um relato técnico da arquitetura e das estratégias de DevOps empregadas no desenvolvimento e operação do Sistema Gestão Presente (SGP), uma plataforma de integração de dados em larga escala desenvolvida pelo Ministério da Educação (MEC). Projetado para centralizar, padronizar e permitir o compartilhamento de dados em tempo real para mais de 47 milhões de alunos da educação básica, o SGP utiliza uma infraestrutura moderna e nativa em nuvem na AWS. A arquitetura utiliza Amazon EKS, KEDA e Karpenter para orquestração de contêineres e escalonamento elástico; Aurora para persistência transacional; Redshift para cargas de trabalho analíticas; e SQS para desacoplamento assíncrono. Por meio da adoção de práticas de GitOps e escalonamento automático orientado a eventos, o sistema alcança alta disponibilidade, resiliência e eficiência operacional. Este relato de experiência contribui com uma referência prática para o projeto de plataformas escaláveis do setor público em ambientes altamente regulamentados.