publications

2026

1. IST

   Exception handling bugs in Python: An empirical study of root causes, fix patterns, and anti-patterns

   Jairo Souza, Eric Coelho, João Correia, Rodrigo Lima, Leopoldo Teixeira, and Baldoino Fonseca

   Information and Software Technology, 2026

   Abs PDF

   Context: Exception handling mechanisms are designed to manage abnormal events that disrupt normal program execution, helping software recover from unexpected situations. However, defects in exception handling mechanisms can introduce errors, crashes, and unexpected behavior, reducing system reliability. Despite widespread adoption of Python, exception handling bugs in Python projects remain largely underexplored. Objectives: This study aims to investigate the characteristics of exception handling bugs in Python projects by analyzing their root causes, fix patterns, and their relationship with anti-patterns (exception handling anti-patterns). Methods: We conducted a large-scale empirical study on 550 open-source Python projects. Using our Exception Miner tool and manual validation, we analyzed 942 confirmed exception handling bugs identified from 1,649 bug candidates extracted from issue reports and associated commits. Results: Our analysis identified 12 root causes and 25 fix patterns. The most common root cause is Unhandled Exception, accounting for 50.64% of the analyzed cases. The most frequent repair strategies include adding exception handling blocks, changing exception types, and introducing appropriate raise conditions, which together account for approximately 60% of the fixes. A before-and-after analysis shows that many exception handling anti-patterns were preserved from the buggy version, while fixes still introduced an increase of 196 exception handling anti-patterns occurrences. Conclusion: The results reveal systematic relationships between root causes and repair strategies, indicating that exception handling bugs often follow predictable patterns. These findings provide insights to improve testing practices and design automated tools to detect and repair exception handling bugs in Python projects.

2. SBES

   An Empirical Evaluation of Using Large Language Models to Recommend Exception Handling Tasks

   Jairo Souza, Tales Alves, Rodrigo Lima, Ericlecio Araujo, Leopoldo Teixeira, and Baldoino Fonseca

   In Proceedings of the XL Brazilian Symposium on Software Engineering, São Paulo, Brazil, 2026

   Abs PDF

   Large Language Models (LLMs) are increasingly used to support software engineering tasks such as code generation, bug fixing, and program comprehension. However, their ability to support exception handling tasks remains largely unexplored. Prior work on automated exception handling has mostly relied on task-specific models, fine-tuning, or specialized pipelines, which may limit reuse across projects and as APIs evolve. In this paper, we empirically evaluate whether open-source and proprietary LLMs can support Python exception handling tasks through prompting alone, without fine-tuning. We study four tasks: (1) detecting whether exception handling is necessary, (2) localizing statements that should be enclosed in a try block, (3) recommending exception types for except clauses, and (4) generating exception handlers. We further complement the generation task with a quality assessment of the generated exception handlers. We evaluated several LLMs, including CodeLlama, Phi-4, GPT-4 Mini, Claude Haiku 4.5, and Gemini 3 Flash, across four prompting strategies using a benchmark from 21 open-source Python projects, collecting 479,345 functions and curating 379 code snippets. Results showed stronger effectiveness for exception necessity detection and try-block localization, with best F-scores of 0.752 and 0.733, respectively, while exception-type recommendation and handler generation remained substantially more challenging. Overall, our findings indicate that prompt-based LLMs are more suitable as early-stage exception handling tasks for detecting need contexts and localizing risky statements. Also, generated exception handlers still require validation, as they often diverge semantically from developer-written implementations and introduce more exception-related quality violations.

3. SBES

   Evaluator Bias in LLM-Based Program Repair: A Disagreement Analysis on Android Resource Leaks

   Andrezza Bonfim, and Leopoldo Teixeira

   In Proceedings of the XL Brazilian Symposium on Software Engineering, São Paulo, Brazil, 2026

   Abs PDF

   Proper management of system resources in Android applications remains a challenge due to the need for explicit release calls during component lifecycles. While Large Language Models (LLMs) are increasingly deployed to automate resource leak repairs, evaluating these repairs introduces substantial metric-dependent biases. Rather than measuring absolute model capabilities, this study diagnoses validator disagreement and evaluator bias across traditional and modern verification paradigms. Using 300 patches generated by GPT-5.4, Claude Opus 4.6, and Gemini 3.1 as a diagnostic vehicle, we evaluate three distinct verification layers: lexical analysis (TF-IDF), structural verification (AST nodes), and neural semantic extraction (GraphCodeBERT). Our results show that the choice of evaluation method drastically alters the reported effectiveness of automated repairs. Specifically, string-matching metrics such as TF-IDF introduce severe false-negative biases, underestimating modern repair patterns (such as try-with-resources) by up to 20 percentage points due to a historical mismatch with legacy ground-truth datasets.

4. SBES

   Dependency Version Migration in Software Projects: A Rapid Review of Motivations, Techniques, Tools, and Challenges

   Arthur Bezerra Silva, Leopoldo Teixeira, Wesley K. G. Assunção, and Bruno Cartaxo

   In Proceedings of the XL Brazilian Symposium on Software Engineering, São Paulo, Brazil, 2026

   Abs PDF

   Software projects increasingly rely on third-party libraries and frameworks that evolve independently of client applications. When dependencies release new versions, client projects must decide whether and how to migrate, a decision that may require adapting client code to breaking changes, altered APIs, or shifted behaviors. Despite the practical importance of this activity, existing research on dependency version migration is scattered across ecosystems, motivations, and support approaches, with no prior synthesis consolidating what is known across all these dimensions. This paper presents a rapid review characterizing the state of research on dependency version migration. Guided by seven research questions, we retrieved 2,637 candidate papers. After applying predefined inclusion and exclusion criteria through a three-phase screening process, we selected 63 primary studies for data extraction and synthesis. The results show that dependency migration is not yet a widespread practice: studies consistently report that most projects rely on outdated dependency versions, and migration tends to be reactive rather than proactive. Where motivations are reported, bug fixes, compatibility requirements, and security vulnerabilities are the primary drivers. However, these findings derive from a limited number of primary studies and should be interpreted with caution. Breaking change detection relies predominantly on automated tooling, while identification of affected client code typically combines automated analysis with manual inspection. The broader repertoire of migration support techniques spans static and structural analysis, rule-based transformations, and AI-driven or example-based approaches. Each category presents recurring trade-offs between precision, ecosystem generalizability, and required developer effort. Across the 63 studies, no single technique demonstrates broad effectiveness across diverse migration scenarios. These findings reveal a fragmented research area characterized by ecosystem-specific solutions, limited cross-study comparability, and sparse empirical evaluation under realistic developer conditions.

5. SBCARS

   How Rust Projects Use Macros: A Large-Scale Empirical Study

   Leopoldo Teixeira, and Nilo Drumond

   In Proceedings of the XX Brazilian Symposium on Software Components, Architectures, and Reuse, São Paulo, Brazil, 2026

   Abs PDF

   Macros are a central feature of the Rust programming language, enabling metaprogramming and compile-time code generation. However, there is limited empirical understanding into how they are used in practice. Using a descriptive survey design, we analyze macro usage across the 99 most popular open-source Rust repositories on GitHub, comprising 4,001 crates and 2,215,517 total invocations, with a custom Tree-sitter-based static analysis pipeline. We address three research questions: (RQ1) how are invocations distributed across macro categories (declarative, derive, attribute, function-like); (RQ2) how concentrated is macro usage around a small set of widely-used ecosystem crates; and (RQ3) how does invocation density vary across project domains. We find that declarative macros dominate macro definitions while function-like and declarative call sites jointly dominate macro invocations. Derive and attribute macros are concentrated among a small set of widely-used ecosystem crates: three crates alone account for 31.9% of user-defined attribute invocations. Finally, educational and AI/LLM-oriented projects exhibit higher density than general-purpose application code.

6. SAST

   Evaluating Shaker for Flaky Test Detection in Python Projects

   Gabriela Leal, Denini Silva, and Leopoldo Teixeira

   In Proceedings of the XI Brazilian Symposium on Systematic and Automated Software Testing, São Paulo, Brazil, 2026

   Abs PDF

   Flaky tests pass or fail non-deterministically on unchanged code, eroding trust in test suites and inflating the cost of every failure. Shaker detects them by injecting resource contention (CPU, memory, and I/O stress) to amplify non-determinism caused by concurrent execution, and was reported to detect 95% of the flaky tests in a Java and Android benchmark against 37.5% for plain re-execution (ReRun). We present the first empirical evaluation of Shaker for Python. Drawing non-order-dependent flaky tests from the ground-truth dataset of Gruber et al., we compare Shaker against a budget-matched ReRun baseline in a paired design, giving both techniques the same number of test executions: Each of 137 tests is run 100 times under each. As configured for Java and Android, Shaker provides no statistically significant detection advantage over plain re-execution (37.2% vs. 35.8%; McNemar exact p = 0.84). Two findings explain why. First, fewer than half of the ground-truth flaky tests reproduce as flaky at all on independent hardware under either technique, and most of the tests that fail to reproduce never diverge once across 100 runs. Second, the tests that do reproduce are dominated by flakiness from network interactions and randomness rather than the concurrency Shaker targets. Beyond the tool, this exposes a broader hazard for the field: reusing a flaky-test ground truth across execution environments silently converts genuine flaky tests into apparent true negatives, deflating any tool’s measured recall.

7. SBLP

   Bleach: A Programming Language for Teaching Compilers

   Victor Costa, and Leopoldo Teixeira

   In Proceedings of the XXX Brazilian Symposium on Programming Languages, São Paulo, Brazil, 2026

   Abs PDF

   Programming languages designed as teaching tools for undergraduate Compilers courses occupy a constrained design space. Existing options such as COOL and MiniJava are deliberately minimal and statically typed, while ChocoPy targets compilation rather than interpretation. This paper presents Bleach, a dynamically typed, object-oriented programming language with a tree-walk interpreter implemented in C++, designed to fill the gap left by these alternatives. Structurally inspired by Lox (from Crafting Interpreters), Bleach extends it with multi-line comments, do-while and for loops, elif clauses, a ternary operator, a list type, break/continue statements, an expanded standard library, and a resolver that statically detects ten distinct classes of scoping and control-flow errors. We present the language’s design rationale, describe the architecture and key implementation decisions of its interpreter, and compare Bleach feature-by-feature with ChocoPy, COOL, and MiniJava, positioning it in the space of compiler-teaching languages. We validated the interpreter through a 44-case test suite covering all AST node types and by implementing eleven standard algorithms and data structures in the language; all test cases pass, and every algorithm runs correctly without modification to the language. We also outline how Bleach can be incorporated into a 15-week undergraduate Compilers course.

8. VEM

   Django-Specific Code Smells: Catalog, Prevalence, and Automated Detection

   Leopoldo Teixeira, and Eduardo Luiz Silva

   In Proceedings of the 14th Workshop on Software Visualization, Evolution and Maintenance, São Paulo, Brazil, 2026

   Abs PDF

   Django is a widely used Python web framework for database-backed application development. As with any actively used framework, Django projects can accumulate code smells: patterns that do not break functionality but signal design or implementation choices likely to hurt maintainability, readability, or performance. Existing Django-aware static analysis tools primarily target schema- and configuration-level issues, leaving performance-oriented and behavioral smells largely unaddressed. This repository contains an open-source static analysis tool, derived from a review of Django-focused grey literature, that detects five Django-specific smells spanning the Model, View, and Template layers. It uses Python’s built-in ast module for checks within Python code, and a lightweight regex-based tokenizer over HTML templates. The accompanying paper investigates three research questions concerning the catalog’s provenance (RQ1), its prevalence in real-world projects (RQ2), and the reliability of automated detection (RQ3). The tool was applied to a sample of 33 public Django repositories of varying size, where it flagged 4,157 occurrences across the five smells; a manual inspection of 50 flagged occurrences (44 of them genuine, 88% overall precision) indicates the tool’s detections are reasonably but not uniformly reliable across smells.

9. JBCS

   Integrating ZBus into Zephyr RTOS: An Experience Report of Knowledge Transfer from Academia to Industry Through Open-Source Contributions

   Rodrigo Peixoto, Leopoldo Teixeira, and Baldoino Fonseca

   Journal of the Brazilian Computer Society, Jun 2026

   Abs PDF

   Embedded systems are present in a wide range of products, and advances in the Internet of Things, wireless sensor networks, and cyber-physical systems have increased their use. This growth has made embedded software more complex, requiring new real-time operating systems, development kits, libraries, and platforms. Despite these tools, the need for better software engineering practices remains a significant issue in embedded software, to prevent lower software quality and increased maintenance costs. To make matters worse, the knowledge transfer of research advances from academia to industry is still challenging. This paper presents ZBus, an advanced software bus that enables many-to-many communication between threads, enhancing modularity and decoupling in embedded software development. ZBus is a result of a collaborative effort between industry and academia. We also detail the development process, the challenges encountered, the lessons learned, and the collaborative efforts that culminated in integrating ZBus into the widely adopted Zephyr real-time operating system. This integration serves as an experience report on technological knowledge transfer from academia to industry through open-source contributions, as well as a practical guide for researchers and practitioners seeking to engage with industrial open-source initiatives in the embedded software domain.

10. EASE

    Can Small LLMs Detect Defect-Prone Code Smells? An Empirical Evaluation of 8B-30B Models Against a Ground-Truth Dataset

    Rodrigo Lima, Jairo Souza, Baldoino Fonseca, Leopoldo Teixeira, and Márcio Ribeiro

    In International Conference on Evaluation and Assessment in Software Engineering - AI Models/Data track, Jun 2026

    Abs PDF

    Code smells are structural indicators of design problems, yet not all smells are equally harmful—only a fraction co-occurs with actual software defects. While Large Language Models (LLMs) are increasingly used for code analysis tasks, most evaluations rely on large proprietary models (e.g., GPT-4, Claude), leaving open whether smaller, locally deployable models can perform comparably. More importantly, the ability of any LLM to distinguish defect-prone (harmful) smells from benign ones remains underexplored. We present an empirical study evaluating four small, open-source LLMs (8B–30B parameters: Qwen3-Coder 30B, DeepSeek-Coder-V2 16B, Llama 3.1 8B, and Granite 3.1 Dense 8B)—all runnable on consumer hardware via Ollama—on two tasks: (1) detecting code smells in real-world code, and (2) classifying detected smells as harmful (co-occurring with bugs) or merely smelly. We build a metric-augmented SZZ dataset comprising 269,513 code smell instances and 13,590 bug locations mined from 10 open-source Java and Python projects via static analysis and the SZZ algorithm, from which we draw a stratified sample of 1,200 labeled snippets (600 harmful, 600 merely smelly) for LLM evaluation. Our results show that small LLMs achieve variable accuracy for smell detection (average F1: 0.20–0.67 depending on model and prompting strategy), with substantial variation across smell types—God Class (F1 up to 0.88) and Long Method (F1 up to 0.81) are detected reliably, while design smells like Feature Envy and Inappropriate Intimacy remain challenging for most models. For the novel harmfulness classification task, all models achieve MCC values near zero (−0.19 to 0.10), revealing a fundamental gap: even when small LLMs recognize structural anomalies, they cannot reliably assess their defect-inducing potential from code alone. Notably, prompting strategy has a dramatic model-dependent effect—one-shot prompting doubles Llama 3.1’s detection F1 from 0.25 to 0.67, while chain-of-thought is most effective for Qwen3-Coder. We release our labeled dataset and evaluation framework as reusable artifacts for future research on AI-driven code quality assessment.

11. MSR

    Test Coverage of Code Changes in AI-Generated Pull Requests

    Tales Alves, and Leopoldo Teixeira

    In Proceedings of the 23rd International Conference on Mining Software Repositories - Mining Challenge Track, Apr 2026

    Abs PDF

    As autonomous coding agents increasingly integrate into software development workflows, understanding their testing practices is essential. We study how well tests in a pull request (PR) exercise the code changed by that PR, and whether those tests contain meaningful assertions. Using AIDev dataset v2, we compare three authorship types: AI-Only (all commits authored by agents), Coauthor (mixed human-AI commits), and Human (baseline PRs from the same repository). Analyzing 2,314 Python PRs that modify tests, we measure diff-coverage: the percentage of modified non-test source lines executed by the PR’s tests. AI-Only PRs achieve higher mean diff-coverage (19.96%) than Coauthor (17.35%) and Human PRs (13.09%). Moreover, 80.4% of AI-Only PRs have non-zero diff-coverage, compared to 62.3% for Coauthor and 66.2% for Human. To assess oracle strength, we manually classify assertions in 255 diffs using a four-level taxonomy (L1–L4) with three independent evaluators. Functional assertions (L3) are dominant, regardless of authorship type: 66.7% AI-Only, 80.0% Coauthor, and 69.9% Human. High-quality assertions (L3+L4) appear in over 90% of test files across all groups, with no statistically significant pairwise differences (Fisher’s exact, p>0.05). Overall, within PRs that include test changes, AI-authored submissions tend to achieve higher coverage of changed code without evidence of weaker assertions, providing empirical evidence to inform strategies for integrating AI-assisted development into software projects.

2025

1. SAST

   Evaluating LLMs for Multimodal GUI Test Generation in Android Applications

   Nayse Fagundes, and Leopoldo Teixeira

   In Proceedings of the X Brazilian Symposium on Systematic and Automated Software Testing, Sep 2025

   Abs PDF

   Graphical User Interface (GUI) testing is an important task in mobile application development but remains time-consuming when done manually. With the rise of Large Language Models (LLMs), there is growing interest in their potential to automate software development tasks, including GUI test generation. This study investigates the ability of LLMs to generate GUI test intentions and scripts for Android applications using multimodal inputs, such as screenshots and structured UI data. We present an approach that combines visual and textual input from eight open-source Android apps and evaluate the performance of four LLMs. The results show significant variation in the models’ ability to generate GUI tests: Claude 3 Sonnet produced the most detailed and complete test sequences, GPT-4o generated simpler test scripts with fewer test intentions and user interactions, focusing on more basic user flows, while Gemini 2.5 and Gemma 3 presented moderate and similar results. These findings indicate that while LLMs can aid GUI test automation, their effectiveness varies significantly across models.

2. SBLP

   An Interpreter-based Framework for Static Analysis of Variability in Space and Time

   Tayná Vieira, Vander Alves, and Leopoldo Teixeira

   In Brazilian Symposium on Programming Languages, Sep 2025

   Abs PDF

   Software Product Lines (SPLs) enable the systematic development of configurable software systems by organizing products as families that share commonalities and differ in selected features. However, static analysis in SPLs poses scalability challenges due to variability in space (across configurations) and variability in time (across software revisions). This paper presents an interpreter-based framework that combines variational lifting and memoization to support scalable and reusable static analysis of evolving SPLs. Analyses are implemented as PCF+ programs and executed over variational representations of object programs, annotated with presence conditions. Memoization mechanisms allow the reuse of previously computed results across object program evolutions, reducing redundant computations and contributing to performance improvements. The framework is evaluated using benchmarks simulating software evolution scenarios. Results indicate that the combined use of variational lifting and memoization effectively reduces execution time, suggesting the advantages of addressing both dimensions of variability. This work contributes a reusable infrastructure for control-flow-based analyses in SPLs and provides empirical evidence supporting its efficiency.

3. JSERD

   Exploring Transfer Learning for Multilingual Software Quality: Code Smells, Bugs, and Harmful Code

   Rodrigo Lima, Durval Pereira, Caio Barbosa, Leonardo Leite, Davy Baia, Baldoino Fonseca, Leopoldo Teixeira, and Jairo Souza

   Journal of Software Engineering Research and Development, Apr 2025

   Abs PDF

   Code smells are indicators of poor design implementation and decision-making that can potentially harm the quality of software. Therefore, detecting these smells is crucial to prevent such issues. Some studies aim to comprehend the impact of code smells on software quality, while others propose rules or machine learning-based approaches to identify code smells. Previous research has focused on labeling and analyzing code snippets that significantly impair software quality using machine learning techniques. These snippets are classified as Clean, Smelly, Buggy, and Harmful Code. Harmful Code refers to smelly code segments that have one or more reported bugs, whether fixed or not. Consequently, the presence of a Harmful Code increases the risk of introducing new defects and/or design issues during the remediation process. We perform our study as an extension of the previous study, with the scope of 5 smell types. The total number of commits across all four tables (Java, C++, C#, and Python projects) is 641,736, versions of 91 open-source projects, 17,022 bugs, and 24,737 code smells. The findings revealed promising transferability of knowledge between Java and C# in the presence of various code smell types, while C++ and Python exhibited more challenging transferability. Also, our study discovered that a sample size of 32 demonstrated favorable outcomes for most harmful codes, underscoring the efficiency of transfer learning even with limited data. Moreover, the exploration of transfer learning between bugs and code smells represents a not-very-ineffective avenue within the realm of software engineering.

2024

1. OOPSLA

   On the Expressive Power of Languages for Static Variability

   Paul Maximilian Bittner, Alexander Schultheiß, Benjamin Moosherr, Jeffrey M. Young, Leopoldo Teixeira, Eric Walkingshaw, Parisa Ataei, and Thomas Thüm

   Proc. ACM Program. Lang., Oct 2024

   Abs PDF

   Variability permeates software development to satisfy ever-changing requirements and mass-customization needs. A prime example is the Linux kernel, which employs the C preprocessor to specify a set of related but distinct kernel variants. To study, analyze, and verify variational software, several formal languages have been proposed. For example, the choice calculus has been successfully applied for type checking and symbolic execution of configurable software, while other formalisms have been used for variational model checking, change impact analysis, among other use cases. Yet, these languages have not been formally compared, hence, little is known about their relationships. Crucially, it is unclear to what extent one language subsumes another, how research results from one language can be applied to other languages, and which language is suitable for which purpose or domain. In this paper, we propose a formal framework to compare the expressive power of languages for static (i.e., compile-time) variability. By establishing a common semantic domain to capture a widely used intuition of explicit variability, we can formulate the basic, yet to date neglected, properties of soundness, completeness, and expressiveness for variability languages. We then prove the (un)soundness and (in)completeness of a range of existing languages, and relate their ability to express the same variational systems. We implement our framework as an extensible open source Agda library in which proofs act as correct compilers between languages or differencing algorithms. We find different levels of expressiveness as well as complete and incomplete languages w.r.t. our unified semantic domain, with the choice calculus being among the most expressive languages.

2. ASE

   Blackbox Observability of Features and Feature Interactions

   Kallistos Weis, Leopoldo Teixeira, Clemens Dubslaff, and Sven Apel

   In Proceedings of the 39th IEEE/ACM International Conference on Automated Software Engineering, Oct 2024

   Abs PDF

   Configurable software systems offer user-selectable features to tailor them to the target hardware and user requirements. It is almost a rule that, as the number of features increases over time, unintended and inadvertent feature interactions arise. Despite numerous definitions of feature interactions and methods for detecting them, there is no procedure for determining whether the effect of a feature interaction could be, in principle, observed from an external perspective. In this paper, we devise a decision procedure to verify whether the effect of a given feature or potential feature interaction could be isolated by blackbox observations of a set of system configurations. For this purpose, we introduce the notion of blackbox observability, which is based on recent work on counterfactual reasoning on configuration decisions. Direct observability requires a single reference configuration to isolate the effect in question, while the broader notion of general observability relaxes this precondition and suffices with a set of reference configurations. We report on a series of experiments on community benchmarks as well as real-world configuration spaces and models. We found that (1) deciding observability is indeed tractable in real-world settings, (2) constraints in real-world configuration spaces frequently limit observability, and (3) blackbox performance models often include effects that are de facto not observable.

3. SBES

   Exception Miner: Multi-language Static Analysis Tool to Identify Exception Handling Anti-Patterns

   Jairo Souza, Tales Alves, Robson Oliveira, Leopoldo Teixeira, and Baldoino Fonseca

   In Proceedings of the XXXVIII Brazilian Symposium on Software Engineering, Curitiba, Brazil, Oct 2024

   PDF
4. SQJ

   Towards Effective Gamification of Existing Systems: Method and Experience Report

   Anderson Uchôa, Rafael Mello, Jairo Souza, Leopoldo Teixeira, Baldoino Fonseca, and Alessandro Garcia

   Software Quality Journal, Oct 2024

   PDF
5. JSERD

   Investigating the Social Representations of Harmful Code

   Rodrigo Lima, Jairo Souza, Baldoino Fonseca, Leopoldo Teixeira, Rafael Maiani, Márcio Ribeiro, Alessandro Garcia, and Rohit Gheyi

   Journal of Software Engineering Research and Development, Apr 2024

   PDF

2023

1. SBQS

   Do you see any problem? On the Developers Perceptions in Test Smells Detection

   Rodrigo Lima, Keila Costa, Jairo Souza, Leopoldo Teixeira, Baldoino Fonseca, Marcelo d’Amorim, Márcio Ribeiro, and Breno Miranda

   In Proceedings of the XXII Brazilian Symposium on Software Quality, SBQS 2023, Brasilia, Brazil, November 7-10, Apr 2023

   PDF
2. IST

   Towards a better understanding of the mechanics of refactoring detection tools

   Jonhnanthan Oliveira, Rohit Gheyi, Leopoldo Teixeira, Márcio Ribeiro, Osmar Leandro, and Baldoino Fonseca

   Information and Software Technology, Apr 2023

   PDF

2022

1. SBES

   A Technique to Test Refactoring Detection Tools

   Osmar Leandro, Rohit Gheyi, Leopoldo Teixeira, Márcio Ribeiro, and Alessandro F. Garcia

   In SBES 2022: XXXVI Brazilian Symposium on Software Engineering, Virtual Event Brazil, October 5 - 7, Apr 2022

   PDF
2. SBES

   A Decade of Internationalization of the Brazilian Symposium on Software Engineering: The Good, the Bad, and the Ugly

   Nabor Mendonça, Leopoldo Teixeira, Sérgio Soares, Vinicius Cardoso Garcia, Uirá Kulesza, César França, Daniel Lucrédio, Elder Cirilo, and Ivan Machado

   In SBES 2022: XXXVI Brazilian Symposium on Software Engineering, Virtual Event Brazil, October 5 - 7, Apr 2022

   PDF
3. IEEE Access

   Distributed Repository for Software Packages Using Blockchain

   Felipe Zimmerle N. Costa, Ruy J. G. B. Queiroz, Gustavo P. Bittencourt, and Leopoldo Teixeira

   IEEE Access, Apr 2022

   PDF
4. SoSym

   Guiding the Evolution of Product-Line Configurations

   Michael Nieke, Gabriela Sampaio, Thomas Thüm, Christoph Seidl, Leopoldo Teixeira, and Ina Schaefer

   Software and Systems Modeling (SoSyM), Apr 2022

   PDF

2021

1. ASE

   Shaker: a Tool for Detecting More Flaky Tests Faster

   Marcello Cordeiro, Denini Silva, Leopoldo Teixeira, Breno Miranda, and Marcelo d’Amorim

   In IEEE/ACM International Conference on Automated Software Engineering (Tool Demonstrations), Nov 2021

   Code
2. SBLP

   TSDolly: A program generator for TypeScript

   Gabriela Araujo Britto, Leopoldo Teixeira, and Rohit Gheyi

   In Brazilian Symposium on Programming Languages, Sep 2021

   PDF
3. SBES

   Evolving Delta-Oriented Product Lines: A Case Study on Feature Interaction, Safe and Partially Safe Evolution

   Leomar Camargo, Luisa Fantin, Gabriel Lobão, Thiago Figueiredo, Rodrigo Bonifacio, Karine Gomes, and Leopoldo Teixeira

   In Brazilian Symposium on Software Engineering, Sep 2021

   PDF
4. TOSEM

   A Formal Framework of Software Product Line Analyses

   Thiago Castro, Leopoldo Teixeira, Vander Alves, Sven Apel, Maxime Cordy, and Rohit Gheyi

   ACM Transactions on Software Engineering and Methodology (TOSEM), Apr 2021

   PDF Code
5. ICSE

   Shipwright: A Human-in-the-Loop System for Dockerfile Repair

   Jordan Henkel, Denini Silva, Leopoldo Teixeira, Marcelo d’Amorim, and Thomas W. Reps

   In IEEE/ACM International Conference on Software Engineering, May 2021

   arXiv PDF Code
6. ICST

   Demystifying the Challenges to Formally Specifying API Properties for Runtime Verification

   Leopoldo Teixeira, Breno Miranda, Henrique Rebelo, and Marcelo d’Amorim

   In IEEE International Conference on Software Testing, Verification and Validation, Apr 2021

   PDF Code
7. IST

   Identifying method-level mutation subsumption relations using Z3

   Rohit Gheyi, Márcio Ribeiro, Beatriz Souza, Marcio Augusto Guimarães, Leo Fernandes, Marcelo d’Amorim, Vander Alves, Leopoldo Teixeira, and Baldoino Fonseca

   Information and Software Technology, Apr 2021

   PDF

2020

1. ICSME

   Shake It! Detecting Flaky Tests Caused by Concurrency with Shaker

   Denini Silva, Leopoldo Teixeira, and Marcelo d’Amorim

   In IEEE International Conference on Software Maintenance and Evolution, Sep 2020

   PDF
2. SBES

   A Catalog of Object-Relational Mapping Code Smells for Java

   Samuel Loli, Leopoldo Teixeira, and Bruno Cartaxo

   In Brazilian Symposium on Software Engineering, Oct 2020

   PDF
3. SBES

   Understanding and Detecting Harmful Code

   Rodrigo Lima, Jairo Souza, Baldoino Fonseca, Leopoldo Teixeira, Rohit Gheyi, Márcio Ribeiro, Alessandro F. Garcia, and Rafael Maiani Mello

   In Brazilian Symposium on Software Engineering, Oct 2020

   PDF
4. SBMF

   Porting the Software Product Line Refinement Theory to the Coq Proof Assistant

   Thayonara Alves, Leopoldo Teixeira, Vander Alves, and Thiago M. Castro

   In Brazilian Symposium on Formal Methods: Foundations and Applications, Nov 2020

   PDF
5. SBMF

   Safe Evolution of Product Lines Using Configuration Knowledge Laws

   Leopoldo Teixeira, Rohit Gheyi, and Paulo Borba

   In Brazilian Symposium on Formal Methods: Foundations and Applications, Nov 2020

   PDF
6. GuyDance: Guiding Configuration Updates for Product-Line Evolution

   Michael Nieke, Gabriela Sampaio, Thomas Thüm, Christoph Seidl, Leopoldo Teixeira, and Ina Schaefer

   In International Workshop on Variability and Evolution of Software-Intensive Systems, co-located with SPLC 2020, Oct 2020

   PDF
7. SANER

   On the Adoption of Kotlin on Android Development: A Triangulation Study

   Victor Oliveira, Leopoldo Teixeira, and Felipe Ebert

   In IEEE International Conference on Software Analysis, Evolution and Reengineering, Feb 2020

   PDF

2019

1. JSS

   Partially safe evolution of software product lines

   Gabriela Sampaio, Paulo Borba, and Leopoldo Teixeira

   Journal of Systems and Software, Feb 2019

   PDF
2. On gamifying an existing healthcare system: method, conceptual model and evaluation

   Anderson G. Uchôa, Eduardo Fernandes, Baldoino Fonseca, Rafael Maiani Mello, Caio Barbosa, Gabriel Nunes, Alessandro Garcia, and Leopoldo Teixeira

   In International Workshop on Software Engineering for Healthcare, co-located with ICSE 2019, May 2019

   PDF
3. SBES

   Willow: A Tool for Interactive Programming Visualization to Help in the Data Structures and Algorithms Teaching-Learning Process

   Pedro Moraes, and Leopoldo Teixeira

   In Brazilian Symposium on Software Engineering - Insightful Ideas & Emerging Results Track, Sep 2019

   PDF
4. Towards efficient analysis of variation in time and space

   Thomas Thüm, Leopoldo Teixeira, Klaus Schmid, Eric Walkingshaw, Mukelabai Mukelabai, Mahsa Varshosaz, Goetz Botterweck, Ina Schaefer, and Timo Kehrer

   In International Workshop on Variability and Evolution of Software-Intensive Systems, co-located with SPLC 2019, Sep 2019

   PDF
5. VaMoS

   Characterizing safe and partially safe evolution scenarios in product lines: An Empirical Study

   Karine Gomes, Leopoldo Teixeira, Thayonara Alves, Márcio Ribeiro, and Rohit Gheyi

   In International Workshop on Variability Modelling of Software-Intensive Systems, Feb 2019

   PDF

2018

1. ComLan

   A change-aware per-file analysis to compile configurable systems with #ifdefs

   Larissa Braz, Rohit Gheyi, Melina Mongiovi, Márcio Ribeiro, Flávio Medeiros, Leopoldo Teixeira, and Sabrina Souto

   Computer Languages, Systems and Structures, Feb 2018

   PDF
2. SCP

   All roads lead to Rome: Commuting strategies for product-line reliability analysis

   Thiago M. Castro, André Lanna, Vander Alves, Leopoldo Teixeira, Sven Apel, and Pierre-Yves Schobbens

   Science of Computer Programming, Feb 2018

   PDF
3. TSE

   Detecting Overly Strong Preconditions in Refactoring Engines

   Melina Mongiovi, Rohit Gheyi, Gustavo Soares, Márcio Ribeiro, Paulo Borba, and Leopoldo Teixeira

   IEEE Transactions on Software Engineering, Feb 2018

   PDF
4. SAST

   Testing Strategies for Smart Cities applications: A Systematic Mapping Study

   Alex Costa, and Leopoldo Teixeira

   In Brazilian Symposium on Systematic and Automated Software Testing, Sep 2018

   PDF

2016

1. EMSE

   Coevolution of variability models and related software artifacts - A fresh look at evolution patterns in the Linux kernel

   Leonardo Teixeira Passos, Leopoldo Teixeira, Nicolas Dintzner, Sven Apel, Andrzej Wasowski, Krzysztof Czarnecki, Paulo Borba, and Jianmei Guo

   Empirical Software Engineering, Sep 2016

   PDF
2. GPCE

   A change-centric approach to compile configurable systems with #ifdefs

   Larissa Braz, Rohit Gheyi, Melina Mongiovi, Márcio Ribeiro, Flávio Medeiros, and Leopoldo Teixeira

   In ACM SIGPLAN International Conference on Generative Programming: Concepts and Experiences, Oct 2016

   PDF
3. SBCARS

   Safe Evolution of Software Product Lines: Feature Extraction Scenarios

   Fernando Benbassat, Paulo Borba, and Leopoldo Teixeira

   In Brazilian Symposium on Software Components, Architectures and Reuse, Sep 2016

   PDF
4. SPLC

   Partially safe evolution of software product lines

   Gabriela Sampaio, Paulo Borba, and Leopoldo Teixeira

   In International Systems and Software Product Line Conference, Sep 2016

   PDF

2015

1. JSS

   Safe evolution templates for software product lines

   Laı́s Neves, Paulo Borba, Vander Alves, Lucinéia Turnes, Leopoldo Teixeira, Demóstenes Sena, and Uirá Kulesza

   Journal of Systems and Software, Sep 2015

   PDF
2. GPCE

   An empirical study on configuration-related issues: investigating undeclared and unused identifiers

   Flávio Medeiros, Iran Rodrigues, Márcio Ribeiro, Leopoldo Teixeira, and Rohit Gheyi

   In ACM SIGPLAN International Conference on Generative Programming: Concepts and Experiences, Oct 2015

   PDF
3. SPLC

   A product line of theories for reasoning about safe evolution of product lines

   Leopoldo Teixeira, Vander Alves, Paulo Borba, and Rohit Gheyi

   In International Conference on Software Product Lines, Jul 2015

   PDF
4. SPLC

   Safe evolution of product populations and multi product lines

   Leopoldo Teixeira, Paulo Borba, and Rohit Gheyi

   In International Conference on Software Product Lines, Jul 2015

   PDF

2014

1. RE

   Evaluating scenario-based SPL requirements approaches: the case for modularity, stability and expressiveness

   Mauricio Alférez, Rodrigo Bonifácio, Leopoldo Teixeira, Paola R. G. Accioly, Uirá Kulesza, Ana Moreira, João Araújo, and Paulo Borba

   Requirements Engineering, Jul 2014

   PDF
2. SCP

   Making refactoring safer through impact analysis

   Melina Mongiovi, Rohit Gheyi, Gustavo Soares, Leopoldo Teixeira, and Paulo Borba

   Science of Computer Programming, Jul 2014

   PDF
3. SEKE

   On the Requirements and Design Decisions of an In-House Component-Based SPL Automated Environment

   Elder Macedo Rodrigues, Leonardo Teixeira Passos, Leopoldo Teixeira, Avelino F. Zorzo, Flávio Moreira Oliveira, and Rodrigo S. Saad

   In International Conference on Software Engineering and Knowledge Engineering, Jul 2014

2013

1. JSS

   Safe composition of configuration knowledge-based software product lines

   Leopoldo Teixeira, Paulo Borba, and Rohit Gheyi

   Journal of Systems and Software, Jul 2013

   PDF
2. SPLC

   Coevolution of variability models and related artifacts: a case study from the Linux kernel

   Leonardo Teixeira Passos, Jianmei Guo, Leopoldo Teixeira, Krzysztof Czarnecki, Andrzej Wasowski, and Paulo Borba

   In International Software Product Line Conference, Aug 2013

   PDF

2012

1. TCS

   A theory of software product line refinement

   Paulo Borba, Leopoldo Teixeira, and Rohit Gheyi

   Theoretical Computer Science, Aug 2012

   PDF

2011

1. GPCE

   Investigating the safe evolution of software product lines

   Laı́s Neves, Leopoldo Teixeira, Demóstenes Sena, Vander Alves, Uirá Kulesza, and Paulo Borba

   In International Conference on Generative Programming And Component Engineering, Oct 2011

   PDF
2. SBES

   Safe Composition of Configuration Knowledge-Based Software Product Lines

   Leopoldo Teixeira, Paulo Borba, and Rohit Gheyi

   In Brazilian Symposium on Software Engineering, Sep 2011

   PDF

2010

1. FOSD

   Assessment of product derivation tools in the evolution of software product lines: an empirical study

   Mário Henrique C. Torres, Uirá Kulesza, Matheus Sousa, Thaı́s Vasconcelos Batista, Leopoldo Teixeira, Paulo Borba, Elder Cirilo, Carlos José Pereira Lucena, Rosana T. V. Braga, and Paulo Cesar Masiero

   In International Workshop on Feature-Oriented Software Development, Oct 2010
2. ICTAC

   A Theory of Software Product Line Refinement

   Paulo Borba, Leopoldo Teixeira, and Rohit Gheyi

   In International Colloquium on Theoretical Aspects of Computing, Sep 2010

   PDF
3. Onward!

   Emergent feature modularization

   Márcio Ribeiro, Humberto Pacheco, Leopoldo Teixeira, and Paulo Borba

   In ACM SIGPLAN International Conference on Systems, Programming, Languages and Applications: Software for Humanity SPLASH/OOPSLA, Sep 2010

   PDF

2009

1. SBCARS

   Hephaestus: A tool for managing SPL variabilities

   Rodrigo Bonifácio, Leopoldo Teixeira, and Paulo Borba

   In Tools Session of the Brazilian Symposium on Software Components, Architectures, and Reuse, Sep 2009

   PDF