@article{niu_zhang_mayr-dorn_assuncao_huang_ge_luo_egyed_2024, title={An extensive replication study of the ABLoTS approach for bug localization}, volume={29}, ISSN={["1573-7616"]}, DOI={10.1007/s10664-024-10537-6}, number={6}, journal={EMPIRICAL SOFTWARE ENGINEERING}, author={Niu, Feifei and Zhang, Enshuo and Mayr-Dorn, Christoph and Assuncao, Wesley Klewerton Guez and Huang, Liguo and Ge, Jidong and Luo, Bin and Egyed, Alexander}, year={2024}, month={Nov} }
 @article{herac_marchezan_assuncao_egyed_2024, title={Conflict-based Change Awareness for Collaborative Model-driven Software Engineering}, volume={23}, ISSN={["1660-1769"]}, DOI={10.5381/jot.2024.23.3.a7}, number={3}, journal={JOURNAL OF OBJECT TECHNOLOGY}, author={Herac, Edvin and Marchezan, Luciano and Assuncao, Wesley K. G. and Egyed, Alexander}, year={2024}, pages={14–14} }
 @article{carvalho_colanzi_assuncao_garcia_pereira_kalinowski_mello_lima_lucena_2024, title={On the Usefulness of Automatically Generated Microservice Architectures}, volume={50}, ISSN={["1939-3520"]}, DOI={10.1109/TSE.2024.3361209}, number={3}, journal={IEEE TRANSACTIONS ON SOFTWARE ENGINEERING}, author={Carvalho, Luiz and Colanzi, Thelma Elita and Assuncao, Wesley K. G. and Garcia, Alessandro and Pereira, Juliana Alves and Kalinowski, Marcos and Mello, Rafael Maiani and Lima, Maria Julia and Lucena, Carlos}, year={2024}, month={Mar}, pages={651–667} }
 @article{assuncao_2024, title={Software Modernization: from industry needs to developers' perception}, DOI={10.1145/3643665.3648568}, journal={PROCEEDINGS 2024 IEEE/ACM WORKSHOP ON SOFTWARE ENGINEERING CHALLENGES IN FINANCIAL FIRMS, FINANSE 2024}, author={Assuncao, Wesley K. G.}, year={2024}, pages={21–22} }
 @article{wolfart_martinez_assuncao_colanzi_egyed_2024, title={Variability debt in opportunistic reuse: A multi-project field study}, volume={210}, ISSN={["1873-1228"]}, DOI={10.1016/j.jss.2024.111969}, abstractNote={Technical debt is a metaphor to guide the identification, measurement, and general management of decisions that are appropriate in the short term but create obstacles in the future evolution and maintenance of systems. Variability management, which is the ability to create system variants to satisfy different business or technical needs, is a potential source of technical debt. Variability debt, recently characterized in a systematic literature review we conducted, is caused by suboptimal solutions in the implementation of variability management in software systems. In this work, we present a field study in which we report quantitative and qualitative analysis of variability debt through artifact analysis (e.g., requirements, source code, and tests) and a survey with stakeholders (e.g., analysts, developers, managers, and a user). The context is a large company with three different systems, where opportunistic reuse (a.k.a., copy-and-paste or clone-and-own reuse) of almost all project artifacts was performed to create variants for each system. We analyze the variability debt phenomenon related to opportunistic reuse, and we assess the validity of the metaphor to create awareness to stakeholders and guide technical debt management research related to variability aspects. The results of the field study show evidences of factors that complicate the evolution of the variants, such as code duplication and non-synchronized artifacts. Time pressure is identified as the main cause for not considering other options than opportunistic reuse. Technical practitioners mostly agree on the creation of usability problems and complex maintenance of multiple independent variants. However, this is not fully perceived by managerial practitioners.}, journal={JOURNAL OF SYSTEMS AND SOFTWARE}, author={Wolfart, Daniele and Martinez, Jabier and Assuncao, Wesley K. G. and Colanzi, Thelma E. and Egyed, Alexander}, year={2024}, month={Apr} }
 @article{herac_assun?ão_marchezan_haas_egyed_2023, title={A flexible operation-based infrastructure for collaborative model-driven engineering}, volume={22}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-85166964579&partnerID=MN8TOARS}, DOI={10.5381/jot.2023.22.2.a5}, abstractNote={Collaborative model-driven engineering infrastructures are used to concurrently deal with models from diverse engineering domains.However, studies within the industry have shown that existing infrastructures often offer insufficient collaborative support or do not incorporate features to handle multiple engineering domains, which leads to inefficient collaboration and reduced team productivity.In this paper, we propose a flexible operation-based infrastructure for collaborative model-driven engineering that addresses these issues.The infrastructure supports lock-free collaboration within co-existing metamodels of different domains.It also allows engineers to arbitrarily push or pull changes of divergent versions and to deal with appearing conflicts.To achieve those functionalities, the infrastructure relies on operations that represent atomic changes on our simplified version of the Meta-Object Facility, such as creating and deleting new types, instances, or modifying properties.The infrastructure manages those operations within a tree-like structure that grows incrementally.Sequences of operations, going from the root to a leaf, represent different versions of a complete model history (including metamodels).Model versions can be merged by concatenating their corresponding branches and handling occurring conflicts.We evaluated the infrastructure by applying it in practical scenarios in collaboration with an industrial partner.These scenarios demonstrate the feasibility of our infrastructure by complying with our derived requirements for collaborative model-driven engineering infrastructures.}, number={2}, journal={Journal of Object Technology}, author={Herac, E. and Assun?ão, W.K.G. and Marchezan, L. and Haas, R. and Egyed, A.}, year={2023} }
 @inproceedings{michelon_assuncao_grunbacher_egyed_2023, title={Analysis and Propagation of Feature Revisions in Preprocessor-based Software Product Lines}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-85160555463&partnerID=MN8TOARS}, DOI={10.1109/SANER56733.2023.00035}, abstractNote={Preprocessor-based software product lines (SPLs) are used to deal with evolution in space, in which features (so-called configuration options)—annotated in source code with #ifdefs—are included, removed, and systematically reused. Inevitably, feature implementations also evolve over time, i.e., when existing features are revised. Nowadays, Version control systems (VCSs) are well-integrated into SPL development processes for versioning support of releases. Changes to existing features in one version, a.k.a. release of an SPL, usually developed in a branch, frequently need to be propagated to other active releases. However, there is no automated support for analyzing and propagating features in SPL releases. For instance, VCSs can only propagate changes at the commit level, but miss support at the feature level, i.e., the building blocks of SPLs. Manually analyzing and propagating a version of a feature, i.e., a feature revision, through #ifdefs is risky, time-consuming, and error-prone because a feature can be interacting with multiple features and it can be spread in multiple blocks of code across different files. We thus present a novel and tool-supported approach for the analysis and propagation of feature revisions. We evaluated our approach quantitatively by computing its correct behavior and runtime. Our approach analyzes and propagates a feature implementation in ≈63 seconds, with, on average, precision and recall of 99%. In total, we propagated 3,134 features in space and time between 200 pairs of releases on four real-world preprocessor-based SPLs. In addition, we qualitatively evaluated the usefulness of our tool support by conducting interviews with five experienced core developers of three popular preprocessor-based SPLs. The qualitative results confirm that our tool support is useful to speed up the analysis and propagation of feature revisions.}, booktitle={Proceedings - 2023 IEEE International Conference on Software Analysis, Evolution and Reengineering, SANER 2023}, author={Michelon, G.K. and Assuncao, W.K.G. and Grunbacher, P. and Egyed, A.}, year={2023}, pages={284–295} }
 @inproceedings{fischer_michelon_assun?ão_ramler_egyed_2023, title={Designing a Test Model for a Configurable System: An Exploratory Study of Preprocessor Directives and Feature Toggles}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-85147451370&partnerID=MN8TOARS}, DOI={10.1145/3571788.3571795}, abstractNote={Testing is important in software development, but it has high cost. Thus, techniques to reduce the cost of software testing have been proposed. Model-based testing, one of such techniques, focuses on automatizing the generation of test cases. In the context of highly configurable systems, model-based testing must capture the system behavior and also encode the variability that exists among the variants. Previous research has shown promising results in applying model-based testing to configurable systems. Test models that encode variability into them directly improve the reasoning for faults from interactions. However, there is no study about the use of different variability mechanisms to encode variability in test models. In this paper, we investigate advantages and drawbacks of test model designs exploring the use of two variability mechanisms, namely preprocessor directives and feature toggles. The results are discussed in regard to run-time reasoning and re-configuration, alongside with metrics about complexity and maintainability. With this work, we contribute to the testing activity of highly configurable systems by providing engineers insights of comparing two well-known and widely used variability mechanisms, which can support informed decisions when choosing for which mechanisms to use for model-based testing.}, booktitle={ACM International Conference Proceeding Series}, author={Fischer, S. and Michelon, G.K. and Assun?ão, W.K.G. and Ramler, R. and Egyed, A.}, year={2023}, pages={31–39} }
 @inproceedings{marchezan_assuncao_michelon_egyed_2023, title={Do Developers Benefit from Recommendations when Repairing Inconsistent Design Models? a Controlled Experiment}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-85162204288&partnerID=MN8TOARS}, DOI={10.1145/3593434.3593482}, abstractNote={Repairing design models is a laborious task that requires a considerable amount of time and effort from developers. Repair recommendation (RR) approaches focus on reducing the effort and improving the quality of the repairs performed. Such approaches have been evaluated in terms of scalability, correctness, and minimalism. These evaluations, however, have not investigated how developers can benefit from using RRs and how they perceive the difficulty of applying RRs. Investigating and discussing the use of RRs from the developers' perspective is important to demonstrate the benefits of applying such approaches in practice. We explore this opportunity by conducting a controlled experiment carried out with 24 developers where they repaired UML design models in eight different tasks, with and without RRs. The findings indicate that developers can benefit from RRs in complex tasks by improving their effectiveness and efficiency. The results also evidence that the use of RRs does not impact the developers' perceived difficulty and confidence when repairing models. Furthermore, our findings show that not all developers choose the same RR, but rather, have varied preferences. Thus, the provision of RRs leads to developers considering additional alternatives to repair an inconsistency.}, booktitle={ACM International Conference Proceeding Series}, author={Marchezan, L. and Assuncao, W.K.G. and Michelon, G.K. and Egyed, A.}, year={2023}, pages={131–140} }
 @inproceedings{oliveira_correia_sousa_assuncao_coutinho_garcia_oizumi_barbosa_uchoa_pereira_2023, title={Don't Forget the Exception! : Considering Robustness Changes to Identify Design Problems}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-85166319889&partnerID=MN8TOARS}, DOI={10.1109/MSR59073.2023.00064}, abstractNote={Modern programming languages, such as Java, use exception-handling mechanisms to guarantee the robustness of software systems. Although important, the quality of exception code is usually poor and neglected by developers. Indiscriminate robustness changes (e.g., the addition of empty catch blocks) can indicate design decisions that negatively impact the internal quality of software systems. As it is known in the literature, multiple occurrences of poor code structures, namely code smells, are strong indicators of design problems. Still, existing studies focus mainly on the correlation of maintainability smells with design problems. However, using only these smells may not be enough since developers need more context (e.g., system domain) to identify the problems in certain scenarios. Moreover, these studies do not explore how changes in the exceptional code of the methods combined with maintainability smells can give complementary evidence of design problems. By covering both regular and exception codes, the developer can have more context about the system and find complementary code smells that reinforce the presence of design problems. This work aims to leverage the identification of design problems by tracking poor robustness changes combined with maintainability smells. We investigated the correlation between robustness changes and maintainability smells on the commit history of more than 160k methods from different releases of 10 open-source software systems. We observed that maintainability smells can be worsened or even introduced when robustness changes are performed. This scenario mainly happened for the smells Feature Envy, Long Method, and Dispersed Coupling. We also analyzed the co-occurrence between robustness and maintainability smells. We identified that the empty catch block and catch throwable robustness smells were the ones that co-occurred the most with maintainability smells related to the Concern Overload and Misplaced Concern design problems. The contribution of our work is to reveal that poor exception code, usually neglected by developers, negatively impacts the quality of methods and classes, signaled by the maintainability smells. Therefore, existing code smell detecting tools can be enhanced to leverage robustness changes to identify design problems.}, booktitle={Proceedings - 2023 IEEE/ACM 20th International Conference on Mining Software Repositories, MSR 2023}, author={Oliveira, A. and Correia, J. and Sousa, L. and Assuncao, W.K.G. and Coutinho, D. and Garcia, A. and Oizumi, W. and Barbosa, C. and Uchoa, A. and Pereira, J.A.}, year={2023}, pages={417–429} }
 @inproceedings{barros_peldszus_assun?ão_berger_2023, title={Editing Support for Software Languages: Implementation Practices in Language Server Protocols (Summary)}, volume={P-332}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-85150073016&partnerID=MN8TOARS}, booktitle={Lecture Notes in Informatics (LNI), Proceedings - Series of the Gesellschaft fur Informatik (GI)}, author={Barros, D. and Peldszus, S. and Assun?ão, W.K.G. and Berger, T.}, year={2023}, pages={35–36} }
 @article{assuncao_kruger_mosser_selaoui_2023, title={How do microservices evolve? An empirical analysis of changes in open-source microservice repositories}, volume={204}, ISSN={["1873-1228"]}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-85163866409&partnerID=MN8TOARS}, DOI={10.1016/j.jss.2023.111788}, abstractNote={Microservice architectures are an emergent service-oriented paradigm widely used in industry to develop and deploy scalable software systems. The underlying idea is to design highly independent services that implement small units of functionality and can interact with each other through lightweight interfaces. Even though microservices are often used with success, their design and maintenance pose novel challenges to software engineers. In particular, it is questionable whether the intended independence of microservices can actually be achieved in practice. So, it is important to understand how and why microservices evolve during a system's life-cycle, for instance, to scope refactorings and improvements of a system's architecture or to develop supporting tools. To provide insights into how microservices evolve, we report a large-scale empirical study on the (co-)evolution of microservices in 11 open-source systems, involving quantitative and qualitative analyses of 7,319 commits. Our quantitative results show that there are recurring patterns of (co-)evolution across all systems, for instance, "shotgun surgery" commits and microservices that are largely independent, evolve in tuples, or are evolved in almost all changes. We refine our results by analyzing service-evolving commits qualitatively to explore the (in-)dependence of microservices and the causes for their specific evolution. The contributions in this article provide an understanding for practitioners and researchers on how microservices evolve in what way, and how microservice-based systems may be improved.}, journal={JOURNAL OF SYSTEMS AND SOFTWARE}, author={Assuncao, Wesley K. G. and Kruger, Jacob and Mosser, Sebastien and Selaoui, Sofiane}, year={2023}, month={Oct} }
 @article{mashkoor_assuncao_egyed_2024, title={Teaching Engineering of AI-Intensive Systems}, volume={41}, ISSN={["1937-4194"]}, DOI={10.1109/MS.2023.3346996}, abstractNote={With the increasing prevalence of AI, a key question is how to adequately prepare the next generation of software engineers to build AIintensive systems. This article presents our teaching experience for the "Engineering of AI-intensive Systems" course to postgraduate students. This course is tailored for computer science students, bridging the disciplines of software engineering (SE) and artificial intelligence (AI). The primary goal is to equip participants with the knowledge and skills to adeptly engineer AI-intensive systems with a strong foundation in conventional SE principles. The article delves into the course's structure, teaching methods, and assessment techniques, underscoring the advantages inherent in this interdisciplinary educational approach.}, number={2}, journal={IEEE SOFTWARE}, author={Mashkoor, Atif and Assuncao, Wesley K. G. and Egyed, Alexander}, year={2024}, pages={30–35} }
 @inproceedings{niu_mayr-dorn_assuncao_huang_ge_luo_egyed_2023, title={The ABLoTS Approach for Bug Localization: is it replicable and generalizable?}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-85166293566&partnerID=MN8TOARS}, DOI={10.1109/MSR59073.2023.00083}, abstractNote={Bug localization is the task of recommending source code locations (typically files) that probably contain the cause of a bug and hence need to be changed to fix the bug. Along these lines, information retrieval-based bug localization (IRBL) approaches have been adopted, which identify the most bug-prone files from the source code space. In current practice, a series of state-of-the-art IRBL techniques leverage the combination of different components, e.g., similar reports, version history, code structure, to achieve better performance. ABLoTS is a recently proposed approach with the core component, TraceScore, that utilizes requirements and traceability information between different issue reports, i.e., feature requests and bug reports, to identify buggy source code snippets with promising results. To evaluate the accuracy of these results and obtain additional insights into the practical applicability of ABLoTS, supporting of future more efficient and rapid replication and comparison, we conducted a replication study of this approach with the original data set and also on an extended data set. The extended data set includes 16 more projects comprising 25,893 bug reports and corresponding source code commits. While we find that the TraceScore component as the core of ABLoTS produces comparable results with the extended data set, we also find that the ABLoTS approach no longer achieves promising results, due to an overlooked side effect of incorrectly choosing a cut-off date that led to training data leaking into test data with significant effects on performance.}, booktitle={Proceedings - 2023 IEEE/ACM 20th International Conference on Mining Software Repositories, MSR 2023}, author={Niu, F. and Mayr-Dorn, C. and Assuncao, W.K.G. and Huang, L. and Ge, J. and Luo, B. and Egyed, A.}, year={2023}, pages={576–587} }
 @article{shafiq_assun?ão_mashkoor_mayr-dorn_egyed_2023, title={Towards Recommending Refactoring Operations Based on Bugs}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-85150898764&partnerID=MN8TOARS}, DOI={10.2139/ssrn.4397230}, abstractNote={This paper investigates the relationship between groups of bugs that triggers specific refactoring operations in software development. Refactoring is a process of improving the internal quality of a system without altering its behavior. Prior studies have shown that refactoring operations can introduce bugs and deviate from the original intentions, but little is known about how refactorings are applied during bug fixing. Knowing the groups of bugs that trigger certain refactoring operations can help developers and managers proactively improve software maintenance activities and make better design decisions. The literature has not addressed the relationship between bugs and refactoring operations. Consequently, this study employs natural language processing techniques to analyze a dataset of 13 Java projects consisting of 13k bugs and 84 types of refactoring operations, totaling more than 125k instances. The study evaluates the groups of bugs that lead to specific kinds of refactoring operations using three semantic similarity measures and performs a statistical test to compare these groups with a random number of bugs associated with different types of refactoring operations. The study explores predicting the types of refactoring operations a developer/newcomer should consider when addressing newly reported bugs by conducting a comprehensive benchmark study with 13 machine-learning techniques.}, journal={SSRN}, author={Shafiq, S. and Assun?ão, W.K.G. and Mashkoor, A. and Mayr-Dorn, C. and Egyed, A.}, year={2023} }
 @inproceedings{oliveira_oizumi_sousa_assun?ão_garcia_lucena_cedrim_2022, title={A characterization study of testing contributors and their contributions in open source projects}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-85139115973&partnerID=MN8TOARS}, DOI={10.1145/3555228.3555243}, abstractNote={Design degradation problems occur as a result of sub-optimal decisions that negatively impact internal software quality. These problems can affect isolated elements (e.g., a class) or multiple code elements (e.g., components). When neglected, design degradation increases maintenance costs. In this scenario, refactoring is paramount to keep internal software quality. However, the identification and removal of design degradation problems are not trivial tasks. For example, architectural documentation is an artifact that facilitates the identification of architectural problems, but often the documentation is unavailable or outdated. Hence, developers rely on the source code, mainly by identifying code smells. A code smell is a sub-optimal decision in the system implementation that can often be considered a counterpart of design degradation problems. Code smells allow developers to spot a design degradation problem and use them to reason about which refactoring operations need to be applied. Certain groups of code smells, called smell patterns, seem to indicate some specific design degradation problems. Intending to investigate the usefulness of smell patterns to help developers in the identification and removal of design degradation problems, we have conducted a quasi-experiment with 13 professional developers. Developers agree that smell patterns are indicators of design degradation problems, but their perceptions are influenced by factors such as the development platform (e.g., Android), type of functionality, and effort for refactoring the problem. Furthermore, they see as degradation problems only the sub-optimal decisions not intentionally taken. Among the smell patterns investigated, the patterns for Fat Interface, Concern Overload, and Scattered Concern were the most useful indicators of design degradation. We also observed that refactorings associated with code smells contribute to the (partial) removal of degradation problems. Our results led us to develop an automated tool to support developers during the identification and removal of some design degradation problems.}, booktitle={ACM International Conference Proceeding Series}, author={Oliveira, A. and Oizumi, W. and Sousa, L. and Assun?ão, W.K.G. and Garcia, A. and Lucena, C. and Cedrim, D.}, year={2022}, pages={311–320} }
 @article{assun?ão_colanzi_carvalho_garcia_pereira_lima_lucena_2022, title={Analysis of a many-objective optimization approach for identifying microservices from legacy systems}, volume={27}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-85124031840&partnerID=MN8TOARS}, DOI={10.1007/s10664-021-10049-7}, number={2}, journal={Empirical Software Engineering}, author={Assun?ão, W.K.G. and Colanzi, T.E. and Carvalho, L. and Garcia, A. and Pereira, J.A. and Lima, M.J. and Lucena, C.}, year={2022} }
 @inproceedings{marchezan_assuncao_kretschmer_egyed_2022, title={Change-Oriented Repair Propagation}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-85130801371&partnerID=MN8TOARS}, DOI={10.1145/3529320.3529330}, abstractNote={Repairing software models may be a laborious task, as the number of alternatives that must be considered by engineers can be large. This is more evident in collaborative environments, where the stream of changes applied to models by different engineers is constant and unanticipated. These changes can cause multiple inconsistencies that must be fixed while preserving the changes applied. However, performing this task is not trivial, as analyzing the changes and the possible large amount of repair alternatives requires time and effort. In this work, we present an approach that aids this repair process by analyzing the stream of changes (i.e., history of changes) while exploring repair alternatives alongside their side effects. The approach generates repairs for inconsistencies identified in the model. These repairs are explored by simulating their execution while re-analyzing the model to find potential new inconsistencies created. Then, new repairs are generated to fix these new inconsistencies. This cycle repeats until the model reaches a consistent state or until repairs can no longer be generated. The approach also analyzes conflicts between repairs and changes. This analysis brings valuable information to engineers regarding how each repair alternative would impact their models and may conflict with changes as well as other repairs. We evaluated our approach in a set of 11 UML models that contain a history of changes. Our findings show how our approach can be applied in a variety of models with a different number of model elements and inconsistencies within a reasonable amount of time.}, booktitle={ACM International Conference Proceeding Series}, author={Marchezan, L. and Assuncao, W.K.G. and Kretschmer, R. and Egyed, A.}, year={2022}, pages={82–92} }
 @inproceedings{marchezan_assun?ão_michelon_herac_egyed_2022, title={Code Smell Analysis in Cloned Java Variants: the Apo-games Case Study}, volume={A}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-85139116073&partnerID=MN8TOARS}, DOI={10.1145/3546932.3547015}, abstractNote={Families of software products are usually created using opportunistic reuse (clone-and-own) in which products are cloned and adapted to meet new requirements, user preferences, or non-functional properties. Opportunistic reuse brings short-term benefits, e.g., reduced time-to-market, whereas creating long-term drawbacks, e.g., the need of changing multiple variants for any maintenance and evolution activity. This situation is even worse when the individual products have poor design or implementation choices, the so-called code smells. Due to their harmfulness to software quality, code smells should be detected and removed as early as possible. In a family of software products, the same code smell must be identified and removed in all variants where it is are present. Identifying instances of similar code smells affecting different variants has not been investigated in the literature yet. This is the case of the Apo-Games family, which has the challenge of identifying the flaws in the design and implementation of cloned games. To address this challenge, we applied our inconsistency and repair approach to detect and suggest solutions for six types of code smells in 19 products of the Apo-games family. Our results show that a considerable number of smells were identified, most of them for the long parameter list and data class types. The number of the same smells identified in multiple variants ranged between 2.9 and 20.2 on average, showing that clone-and-own may lead to the replication of code smells in multiple products. Lastly, our approach was able to generate between 4.9 and 28.98 repair alternatives per smell on average.}, booktitle={26th ACM International Systems and Software Product Line Conference, SPLC 2022 - Proceedings}, author={Marchezan, L. and Assun?ão, W.K.G. and Michelon, G. and Herac, E. and Egyed, A.}, year={2022}, pages={250–254} }
 @article{bibiano_uchôa_assun?ão_tenório_colanzi_vergilio_garcia_2022, title={Composite Refactoring: Representations, Characteristics and Effects on Software Projects}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-85131229272&partnerID=MN8TOARS}, journal={SSRN}, author={Bibiano, A.C.G. and Uchôa, A. and Assun?ão, W.K.G. and Tenório, D. and Colanzi, T.E. and Vergilio, S.R. and Garcia, A.}, year={2022} }
 @article{bibiano_uchôa_assun?ão_tenório_colanzi_vergilio_garcia_2023, title={Composite refactoring: Representations, characteristics and effects on software projects}, volume={156}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-85145966825&partnerID=MN8TOARS}, DOI={10.1016/j.infsof.2022.107134}, journal={Information and Software Technology}, author={Bibiano, A.C. and Uchôa, A. and Assun?ão, W.K.G. and Tenório, D. and Colanzi, T.E. and Vergilio, S.R. and Garcia, A.}, year={2023} }
 @article{prado lima_mendon?a_vergilio_assun?ão_2022, title={Cost-effective learning-based strategies for test case prioritization in continuous integration of highly-configurable software}, volume={27}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-85134618992&partnerID=MN8TOARS}, DOI={10.1007/s10664-021-10093-3}, number={6}, journal={Empirical Software Engineering}, author={Prado Lima, J.A. and Mendon?a, W.D.F. and Vergilio, S.R. and Assun?ão, W.K.G.}, year={2022} }
 @article{oliveira_assun?ão_garcia_fonseca_ribeiro_2022, title={Developers’ perception matters: machine learning to detect developer-sensitive smells}, volume={27}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-85139719867&partnerID=MN8TOARS}, DOI={10.1007/s10664-022-10234-2}, number={7}, journal={Empirical Software Engineering}, author={Oliveira, D. and Assun?ão, W.K.G. and Garcia, A. and Fonseca, B. and Ribeiro, M.}, year={2022} }
 @inproceedings{barros_peldszus_assun?ão_berger_2022, title={Editing Support for Software Languages: Implementation Practices in Language Server Protocols}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-85141876964&partnerID=MN8TOARS}, DOI={10.1145/3550355.3552452}, abstractNote={Effectively using software languages, be it programming or domain-specific languages, requires effective editing support. Modern IDEs, modeling tools, and code editors typically provide sophisticated support to create, comprehend, or modify instances---programs or models---of particular languages. Unfortunately, building such editing support is challenging. While the engineering of languages is well understood and supported by modern model-driven techniques, there is a lack of engineering principles and best practices for realizing their editing support. Especially domain-specific languages---often created by smaller organizations or individual developers, sometimes even for single projects---would benefit from better methods and tools to create proper editing support.}, booktitle={Proceedings - 25th ACM/IEEE International Conference on Model Driven Engineering Languages and Systems, MODELS 2022}, author={Barros, D. and Peldszus, S. and Assun?ão, W.K.G. and Berger, T.}, year={2022}, pages={232–243} }
 @article{michelon_obermann_assun?ão_linsbauer_grünbacher_fischer_lopez-herrejon_egyed_2022, title={Evolving software system families in space and time with feature revisions}, volume={27}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-85131041492&partnerID=MN8TOARS}, DOI={10.1007/s10664-021-10108-z}, abstractNote={Abstract Software companies commonly develop and maintain variants of systems, with different feature combinations for different customers. Thus, they must cope with variability in space. Software companies further must cope with variability in time, when updating system variants by revising existing software features. Inevitably, variants evolve orthogonally along these two dimensions, resulting in challenges for software maintenance. Our work addresses this challenge with ECSEST (Extraction and Composition for Systems Evolving in Space and Time), an approach for locating feature revisions and composing variants with different feature revisions. We evaluated ECSEST using feature revisions and variants from six highly configurable open source systems. To assess the correctness of our approach, we compared the artifacts of input variants with the artifacts from the corresponding composed variants based on the implementation of the extracted features. The extracted traces allowed composing variants with 99-100% precision, as well as with 97-99% average recall. Regarding the composition of variants with new configurations, our approach can combine different feature revisions with 99% precision and recall on average. Additionally, our approach retrieves hints when composing new configurations, which are useful to find artifacts that may have to be added or removed for completing a product. The hints help to understand possible feature interactions or dependencies. The average time to locate feature revisions ranged from 25 to 250 seconds, whereas the average time for composing a variant was 18 seconds. Therefore, our experiments demonstrate that ECSEST is feasible and effective.}, number={5}, journal={Empirical Software Engineering}, author={Michelon, G.K. and Obermann, D. and Assun?ão, W.K.G. and Linsbauer, L. and Grünbacher, P. and Fischer, S. and Lopez-Herrejon, R.E. and Egyed, A.}, year={2022} }
 @article{marchezan_kretschmer_assun?ão_reder_egyed_2023, title={Generating repairs for inconsistent models}, volume={22}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-85127543863&partnerID=MN8TOARS}, DOI={10.1007/s10270-022-00996-0}, abstractNote={Abstract There are many repair alternatives for resolving model inconsistencies, each involving one or more model changes. Enumerating them all could overwhelm the developer because the number of possible repairs can grow exponentially. To address this problem, this paper focuses on the immediate cause of an inconsistency. By focusing on the cause, we can generate a repair tree with a subset of repair actions focusing on fixing this cause. This strategy identifies model elements that must be repaired, as opposed to additional model elements that may or may not have to be repaired later. Furthermore, our approach can provide an ownership-based filter for filtering repairs that modify model elements not owned by a developer. This filtering can further reduce the repair possibilities, aiding the developer when choosing repairs to be performed. We evaluated our approach on 24 UML models and four Java systems, using 17 UML consistency rules and 14 Java consistency rules. The evaluation data contained 39,683 inconsistencies, showing our approach’s usability as the repair trees sizes ranged from five to nine on average per model. Also, these repair trees were generated in 0.3 seconds on average, showing our approach’s scalability. Based on the results, we discuss the correctness and minimalism with regard to the cause of the inconsistency. Lastly, we evaluated the filtering mechanism, showing that it is possible to further reduce the number of repairs generated by focusing on ownership.}, number={1}, journal={Software and Systems Modeling}, author={Marchezan, L. and Kretschmer, R. and Assun?ão, W.K.G. and Reder, A. and Egyed, A.}, year={2023}, pages={297–329} }
 @book{lopez-herrejon_martinez_assun?ão_ziadi_acher_vergilio_2022, title={Handbook of re-engineering software intensive systems into software product lines}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-85160496931&partnerID=MN8TOARS}, DOI={10.1007/978-3-031-11686-5}, journal={Handbook of Re-Engineering Software Intensive Systems into Software Product Lines}, author={Lopez-Herrejon, R.E. and Martinez, J. and Assun?ão, W.K.G. and Ziadi, T. and Acher, M. and Vergilio, S.}, year={2022}, pages={1–517} }
 @article{silva_okada_assun?ão_colanzi_2022, title={Intensifying the search-based optimization of product line architectures with crossover operators}, volume={27}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-85138402577&partnerID=MN8TOARS}, DOI={10.1007/s10664-022-10198-3}, number={7}, journal={Empirical Software Engineering}, author={Silva, D.F. and Okada, L.F. and Assun?ão, W.K.G. and Colanzi, T.E.}, year={2022} }
 @inproceedings{krüger_assun?ão_ayala_mosser_2022, title={International Workshop on Variability Management for Modern Technologies (VM4ModernTech 2022)}, volume={A}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-85139136446&partnerID=MN8TOARS}, DOI={10.1145/3546932.3547019}, abstractNote={Implementing variability in a software system allows developers to deal with different customer needs and requirements---establishing a family of related system variants. Variability can be managed through opportunistic (e.g., clone-and-own) or systematic strategies (e.g., a software product line). In the product-line community, variability management has been researched for systems in numerous domains, such as defense, avionics, or finance, and for various platforms, such as desktops, web applications, or embedded systems. Unfortunately, other research communities; especially those working on modern technologies, such as microservice architectures, cyber-physical systems, robotics, cloud computing, autonomous driving, or ML/AI-based systems; are less aware of the respective state-of-the-art in variability management. Consequently, these communities face similar problems and start to redeveloped similar solutions as the product-line community already did. With the International Workshop on Variability Management for Modern Technologies, we intend to foster and strengthen synergies between the communities regarding variability management for modern technologies. We aim to attract researchers and practitioners to contribute processes, techniques, tools, empirical studies, problem descriptions, or solutions that are connected to reuse and variability management for modern technologies. By inviting different communities and initiating collaborations between them, we hope that VM4ModernTech raises the interest of researchers outside the product-line community for variability management, and thus avoid expensive redevelopments.}, booktitle={26th ACM International Systems and Software Product Line Conference, SPLC 2022 - Proceedings}, author={Krüger, J. and Assun?ão, W.K.G. and Ayala, I. and Mosser, S.}, year={2022}, pages={266} }
 @inbook{assun?ão_vergilio_lopez-herrejon_2022, title={ModelVars2SPL: From UML class diagram variants to software product line core assets}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-85160501497&partnerID=MN8TOARS}, DOI={10.1007/978-3-031-11686-5_9}, booktitle={Handbook of Re-Engineering Software Intensive Systems into Software Product Lines}, author={Assun?ão, W.K.G. and Vergilio, S.R. and Lopez-Herrejon, R.E.}, year={2022}, pages={221–250} }
 @inproceedings{coutinho_uchoa_barbosa_soares_garcia_schots_pereira_assuncao_2022, title={On the Influential Interactive Factors on Degrees of Design Decay: A Multi-Project Study}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-85135844683&partnerID=MN8TOARS}, DOI={10.1109/SANER53432.2022.00093}, abstractNote={Developers constantly perform code changes throughout the lifetime of a project. These changes may induce the introduction of design problems (design decay) over time, which may be reduced or accelerated by interacting with different factors (e.g., refactorings) that underlie each change. However, existing studies lack evidence about how these factors interact and influence design decay. Thus, this paper reports a study aimed at investigating whether and how (associations of) process and developer factors influence design decay. We studied seven software systems, containing an average of 45K commits in more than six years of project history. Design decay was characterized in terms of five internal quality attributes: cohesion, coupling, complexity, inheritance, and size. We observed and characterized 12 (sub-)factors and how they associate with design decay. To this end, we employed association rule mining. Moreover, we also differentiate between the associations found on modules with varying levels of decay. Process- and developer-related factors played a key role in discriminating these different levels of design decay. Then, we focused on analyzing the effects of potentially interacting factors regarding slightly- and largely-decayed modules. Finally, we observed diverging decay patterns in these modules. For example, individually, the developer-related sub-factor that represented first-time contributors, as well as the process-related one that represented the size of a change did not have negative effects on the changed classes. However, when analyzing specific factor interactions, we saw that changes in which both of these factors interacted tended to have a negative effect on the code, leading to decay.}, booktitle={Proceedings - 2022 IEEE International Conference on Software Analysis, Evolution and Reengineering, SANER 2022}, author={Coutinho, D. and Uchoa, A. and Barbosa, C. and Soares, V. and Garcia, A. and Schots, M. and Pereira, J. and Assuncao, W.K.G.}, year={2022}, pages={753–764} }
 @article{moreira_assun?ão_martinez_figueiredo_2022, title={Open-source software product line extraction processes: the ArgoUML-SPL and Phaser cases}, volume={27}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-85128087422&partnerID=MN8TOARS}, DOI={10.1007/s10664-021-10104-3}, abstractNote={Abstract Software Product Lines (SPLs) are rarely developed from scratch. Commonly, they emerge from one product when there is a need to create tailored variants, or from existing variants created in an ad-hoc way once their separated maintenance and evolution become challenging. Despite the vast literature about re-engineering systems into SPLs and related technical approaches, there is a lack of detailed analysis of the process itself and the effort involved. In this paper, we provide and analyze empirical data of the extraction processes of two open-source case studies, namely ArgoUML and Phaser. Both cases emerged from the transition of a monolithic system into an SPL. The analysis relies on information mined from the version control history of their respective source-code repositories and the discussion with developers that took part in the process. Unlike previous works that focused mostly on the structural results of the final SPL, the contribution of this study is an in-depth characterization of the processes. With this work, we aimed at providing a deeper understanding of the strategies for SPL extraction and their implications. Our results indicate that the source code changes can range from almost a fourth to over half of the total lines of code. Developers may or may not use branching strategies for feature extraction. Additionally, the problems faced during the extraction process may be due to lack of tool support, complexity on managing feature dependencies and issues with feature constraints. We made publicly available the datasets and the analysis scripts of both case studies to be used as a baseline for extractive SPL adoption research and practice.}, number={4}, journal={Empirical Software Engineering}, author={Moreira, R.A.F. and Assun?ão, W.K.G. and Martinez, J. and Figueiredo, E.}, year={2022} }
 @inbook{marchezan_rodrigues_carbonell_bernardino_basso_assun?ão_2022, title={PAxSPL: A framework for aiding SPL reengineering planning}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-85160504871&partnerID=MN8TOARS}, DOI={10.1007/978-3-031-11686-5_13}, booktitle={Handbook of Re-Engineering Software Intensive Systems into Software Product Lines}, author={Marchezan, L. and Rodrigues, E. and Carbonell, J. and Bernardino, M. and Basso, F.P. and Assun?ão, W.K.G.}, year={2022}, pages={319–353} }
 @book{lopez-herrejon_martinez_assun?ão_ziadi_acher_vergilio_2022, title={Preface}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-85160008772&partnerID=MN8TOARS}, journal={Handbook of Re-Engineering Software Intensive Systems into Software Product Lines}, author={Lopez-Herrejon, R.E. and Martinez, J. and Assun?ão, W.K.G. and Ziadi, T. and Acher, M. and Vergilio, S.}, year={2022}, pages={ix-xii} }
 @inbook{carvalho_garcia_assun?ão_colanzi_bonifácio_tizzei_mello_cerqueira_ribeiro_lucena_2022, title={Re-engineering legacy systems as microservices: An industrial survey of criteria to deal with modularity and variability of features}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-85160494747&partnerID=MN8TOARS}, DOI={10.1007/978-3-031-11686-5_19}, booktitle={Handbook of Re-Engineering Software Intensive Systems into Software Product Lines}, author={Carvalho, L. and Garcia, A. and Assun?ão, W.K.G. and Colanzi, T.E. and Bonifácio, R. and Tizzei, L.P. and Mello, R. and Cerqueira, R. and Ribeiro, M. and Lucena, C.}, year={2022}, pages={471–494} }
 @inproceedings{ra??iu_assun?ão_haas_egyed_2022, title={Reactive links across multi-domain engineering models}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-85141855846&partnerID=MN8TOARS}, DOI={10.1145/3550355.3552446}, abstractNote={As the engineering world moves towards collaborative model-driven development, it is becoming increasingly difficult to keep all model artifacts synchronized and consistent across a myriad of tools and domains. The existing literature proposes a variety of solutions, from passive trace links to computing change propagation paths. However, these solutions require manual propagation and the use of a limited set of tools, while also lacking the efficiency and granularity required during the development of complex systems. To overcome these limitations, this paper proposes a solution based on reactive propagation links between property values across multi-domain models managed in different tools. As opposed to the traditional passive links, the propagation links automatically react to changes during engineering to assure the synchronization and consistency of the models. The feasibility and performance of our solution were evaluated in two practical scenarios. We identified a set of change propagation cases, all of which could be resolved using our solution, while also rendering a great improvement in terms of efficiency as compared to manual propagation. The contribution of our solution to the state of the practice is to enhance the engineering process by reducing the burden of manually keeping models synchronized, eliminating inconsistencies that can be originated in artifacts managed in a variety of tool from different domains.}, booktitle={Proceedings - 25th ACM/IEEE International Conference on Model Driven Engineering Languages and Systems, MODELS 2022}, author={Ra??iu, C.C. and Assun?ão, W.K.G. and Haas, R. and Egyed, A.}, year={2022}, pages={76–86} }
 @inbook{assun?ão_vergilio_lopez-herrejon_2023, title={Reengineering UML class diagram variants into a product line architecture}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-85160471773&partnerID=MN8TOARS}, DOI={10.1007/978-3-031-18556-4_18}, booktitle={UML-Based Software Product Line Engineering with SMarty}, author={Assun?ão, W.K.G. and Vergilio, S.R. and Lopez-Herrejon, R.E.}, year={2023}, pages={393–414} }
 @inproceedings{ratzenböck_grünbacher_assun?ão_egyed_linsbauer_2022, title={Refactoring product lines by replaying version histories}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-85125365198&partnerID=MN8TOARS}, DOI={10.1145/3510466.3510484}, abstractNote={When evolving software product lines, new features are added over time and existing features are revised. Engineers also decide to merge different features or split features in other cases. Such refactoring tasks are difficult when using manually maintained feature-to-code mappings. Intensional version control systems such as ECCO overcome this issue with automatically computed feature-to-code mappings. Furthermore, they allow creating variants that have not been explicitly committed before. However, such systems are still rarely used compared to extensional version control systems like Git, which keep track of the evolution history by assigning revisions to states of a system. This paper presents an approach combining both extensional and intensional version control systems, which relies on the extensional version control system Git to store versions. Developers selectively tag existing versions to describe the evolution at the level of features. Our approach then automatically replays the evolution history to create a repository of the intensional variation control system ECCO. The approach contributes to research on refactoring features of existing product lines and migrating existing systems to product lines. We provide an initial evaluation of the approach regarding correctness and performance based on an existing system.}, booktitle={ACM International Conference Proceeding Series}, author={Ratzenböck, M. and Grünbacher, P. and Assun?ão, W.K.G. and Egyed, A. and Linsbauer, L.}, year={2022} }
 @inbook{assun?ão_vergilio_lopez-herrejon_linsbauer_2022, title={Search-based variability model synthesis from variant configurations}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-85160493541&partnerID=MN8TOARS}, DOI={10.1007/978-3-031-11686-5_5}, booktitle={Handbook of Re-Engineering Software Intensive Systems into Software Product Lines}, author={Assun?ão, W.K.G. and Vergilio, S.R. and Lopez-Herrejon, R.E. and Linsbauer, L.}, year={2022}, pages={115–141} }
 @inproceedings{mendon?a_assun?ão_vergilio_2022, title={Software Product Line Regression Testing: A Research Roadmap}, volume={2}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-85140904095&partnerID=MN8TOARS}, DOI={10.5220/0010959700003179}, booktitle={International Conference on Enterprise Information Systems, ICEIS - Proceedings}, author={Mendon?a, W.D.F. and Assun?ão, W.K.G. and Vergilio, S.R.}, year={2022}, pages={81–89} }
 @inproceedings{marchezan_rodrigues_assun?ão_bernardino_basso_carbonell_2022, title={Software product line scoping: A systematic literature review}, volume={A}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-85139099289&partnerID=MN8TOARS}, DOI={10.1145/3546932.3547012}, abstractNote={In this extended abstract, we discuss the Journal First summary of our work published in the Journal of Systems and Software (JSS) [3].}, booktitle={26th ACM International Systems and Software Product Line Conference, SPLC 2022 - Proceedings}, author={Marchezan, L. and Rodrigues, E. and Assun?ão, W.K.G. and Bernardino, M. and Basso, F.P. and Carbonell, J.}, year={2022}, pages={256} }
 @article{michelon_martinez_sotto-mayor_arrieta_assun?ão_abreu_egyed_2023, title={Spectrum-based feature localization for families of systems}, volume={195}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-85140380777&partnerID=MN8TOARS}, DOI={10.1016/j.jss.2022.111532}, abstractNote={In large code bases, locating the elements that implement concrete features of a system is challenging. This information is paramount for maintenance and evolution tasks, although not always explicitly available. In this work, motivated by the needs of locating features as a first step for feature-based Software Product Line adoption, we propose a solution for improving the performance of existing approaches. For this, relying on an automatic feature localization approach to locate features in single-systems, we propose approaches to deal with feature localization in the context of families of systems, e.g., variants created through opportunistic reuse such as clone-and-own. Our feature localization approaches are built on top of Spectrum-based feature localization (SBFL) techniques, supporting both dynamic feature localization (i.e., using execution traces as input) and static feature localization (i.e., relying on the structural decomposition of the variants' implementation). Concretely, we provide (i) a characterization of different settings for dynamic SBFL in single systems, (ii) an approach to improve accuracy of dynamic SBFL for families of systems, and (iii) an approach to use SBFL as a static feature localization technique for families of systems. The proposed approaches are evaluated using the consolidated ArgoUML SPL feature localization benchmark. The results suggest that some settings of SBFL favor precision such as using the ranking metrics Wong2, Ochiai2, or Tarantula with high threshold values, while most of the ranking metrics with low thresholds favor recall. The approach to use information from variants increase the precision of dynamic SBFL while maintaining recall even with few number of variants, namely two or three. Finally, the static SBFL approach performs equally in terms of accuracy to other state-of-the-art approaches, such as Formal Concept Analysis and Interdependent Elements.}, journal={Journal of Systems and Software}, author={Michelon, G.K. and Martinez, J. and Sotto-Mayor, B. and Arrieta, A. and Assun?ão, W.K.G. and Abreu, R. and Egyed, A.}, year={2023} }
 @inbook{linsbauer_fischer_michelon_assun?ão_grünbacher_lopez-herrejon_egyed_2022, title={Systematic software reuse with automated extraction and composition for clone-and-own}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-85125379114&partnerID=MN8TOARS}, DOI={10.1007/978-3-031-11686-5_15}, booktitle={Handbook of Re-Engineering Software Intensive Systems into Software Product Lines}, author={Linsbauer, L. and Fischer, S. and Michelon, G.K. and Assun?ão, W.K.G. and Grünbacher, P. and Lopez-Herrejon, R.E. and Egyed, A.}, year={2022}, pages={379–404} }
 @inproceedings{mendon?a_vergilio_michelon_egyed_assun?ão_2022, title={Test2Feature: Feature-based Test Traceability Tool for Highly Configurable Software}, volume={B}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-85139151610&partnerID=MN8TOARS}, DOI={10.1145/3503229.3547031}, abstractNote={To ensure the quality of Highly Configurable Software (HCS) in an evolution and maintenance scenario is a challenging task. As HCSs evolve, new features are added, changed, or removed, which hampers the selection and evolution of test cases. The use of test traceability reports can help in this task, but there is a lack of studies addressing HCS test-to-feature traceability. Existing work usually are based on the variability model, which is not always available or updated. Some tools only link test cases to code lines. Considering this gap, this paper introduces Test2Feature, a tool that traces test cases to features using the source code of annotated HCSs, written in C/C++. The tool produces the following outputs: the code lines that correspond to each feature, the lines that correspond to each test case, and the test cases that are linked to each feature. Test2Feature is based only on the static analysis of the code. The traceability report produced can be used to ease different tasks related, for instance, to regression testing, feature management, and HCS evolution and maintenance.}, booktitle={26th ACM International Systems and Software Product Line Conference, SPLC 2022 - Proceedings}, author={Mendon?a, W.D.F. and Vergilio, S.R. and Michelon, G.K. and Egyed, A. and Assun?ão, W.K.G.}, year={2022}, pages={62–65} }
 @inbook{allian_nakagawa_martinez_assun?ão_oliveirajr_2023, title={Variability implementation and UML-based software product lines}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-85160481737&partnerID=MN8TOARS}, DOI={10.1007/978-3-031-18556-4_2}, booktitle={UML-Based Software Product Line Engineering with SMarty}, author={Allian, A.P. and Nakagawa, E.Y. and Martinez, J. and Assun?ão, W.K. and OliveiraJr, E.}, year={2023}, pages={27–40} }
 @inproceedings{michelon_linsbauer_assun?ão_fischer_egyed_2021, title={A Hybrid Feature Location Technique for Re-engineeringSingle Systems into Software Product Lines}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-85101062048&partnerID=MN8TOARS}, DOI={10.1145/3442391.3442403}, abstractNote={Software product lines (SPLs) are known for improving productivity and reducing time-to-market through the systematic reuse of assets. SPLs are adopted mainly by re-engineering existing system variants. Feature location techniques (FLTs) support the re-engineering process by mapping the variants' features to their implementation. However, such FLTs do not perform well when applied to single systems. In this way, there is a lack of FLTs to aid the re-engineering process of a single system into an SPL. In this work, we present a hybrid technique that consists of two complementary types of analysis: i) a dynamic analysis by runtime monitoring traces of scenarios in which features of the system are exercised individually, and ii) a static analysis for refining overlapping traces. We evaluate our technique on three subject systems by computing the common metrics used in FL research. We thus computed Precision, Recall, and F-Score at the line- and method-level of source code. In addition to that, one of the systems has a ground truth available, which we also used for comparing results. Results show that our FLT reached an average of 68-78% precision and 72-81% recall on two systems at the line-level, and 67-65% precision and 68-48% recall at the method-level. In these systems, most of the implementation can be covered by the exercise of the features. For the largest system, our technique reached a precision of up to 99% at the line-level, 94% at the method-level, and 44% when comparing to traces. However, due to its size, it was difficult to reach high code coverage during execution, and thus the recall obtained was on average of 28% at the line-level, 25% at the method-level, and 30% when comparing to traces. The main contribution of this work is a hybrid FLT, its publicly available implementation, and a replication package for comparisons and future studies.}, booktitle={ACM International Conference Proceeding Series}, author={Michelon, G.K. and Linsbauer, L. and Assun?ão, W.K.G. and Fischer, S. and Egyed, A.}, year={2021} }
 @inproceedings{assun?ão_colanzi_carvalho_pereira_garcia_de lima_lucena_2021, title={A Multi-Criteria Strategy for Redesigning Legacy Features as Microservices: An Industrial Case Study}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-85106562484&partnerID=MN8TOARS}, DOI={10.1109/SANER50967.2021.00042}, abstractNote={Microservices are small and autonomous services that communicate through lightweight protocols. Companies have often been adopting microservices to incrementally redesign legacy systems as part of a modernization process. Microservices promote better reuse and customization of existing features while increasing business capabilities, if appropriate design decisions are made. There are some partially-automated approaches supporting the re-design of legacy features into microservices. However, they fail in covering two key aspects: (i) provide an architectural design of the features being redesigned, and (ii) simultaneously support relevant criteria, e.g., feature modularization and decrease of network communication overhead. Also, these two aspects tend to be poorly discussed along industrial case studies. To fulfill these gaps, we propose a redesign strategy to support the re-engineering of features legacy code as microservices. This strategy covers key possibly-conflicting criteria on microservice-based architectures. We employ search-based optimization to deal with such conflicting criteria. The output of the strategy is a set of redesign candidates of legacy features as microservices. We reflect upon the benefits and drawbacks of the proposed strategy through an industrial case study. In particular, we perform an in-depth analysis of the resulting microservice candidates, and a discussion about their potential for customization and reuse. The reflections/discussions are also supported by observations of developers involved in the process.}, booktitle={Proceedings - 2021 IEEE International Conference on Software Analysis, Evolution and Reengineering, SANER 2021}, author={Assun?ão, W.K.G. and Colanzi, T.E. and Carvalho, L. and Pereira, J.A. and Garcia, A. and De Lima, M.J. and Lucena, C.}, year={2021}, pages={377–387} }
 @inproceedings{colanzi_amaral_assun?ão_zavadski_tanno_garcia_lucena_2021, title={Are we speaking the industry language? The practice and literature of modernizing legacy systems with microservices}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-85117334257&partnerID=MN8TOARS}, DOI={10.1145/3483899.3483904}, abstractNote={Microservice architecture has gained much attention in the last few years in both industry and academia. Microservice is an architectural style that enables developing systems as a suite of small loosely coupled, and autonomous (micro)services that encapsulate business capabilities and communicate with each other using language-agnostic APIs. Despite the microservice adoption for modernizing legacy systems, few studies investigate how microservices are used in practice. Furthermore, the literature still scarce on presenting studies on why and how the modernization is conducted in practice in comparison to existing literature on the subject. Thus, our goal is to investigate if industry and academy are speaking the same language concerning the modernization of legacy systems with microservices, by means of a rigorous study on the use of microservices in the industry. For doing so, we design a survey to understand the state of practice from the perspective of a modernization process roadmap derived from the literature. In this paper, we report the results of a survey with 56 software companies, from which 35 (63.6%) adopt the microservice architecture in their legacy systems. Results pointed out the most expected benefits that drive the migration to microservices are easier software maintenance, better scalability, ease of deployment, and technology flexibility. Besides, we verified, based on a set of activities defined in the modernization process, that the practitioners are performing their migration process according to the best literature practices.}, booktitle={ACM International Conference Proceeding Series}, author={Colanzi, T. and Amaral, A. and Assun?ão, W. and Zavadski, A. and Tanno, D. and Garcia, A. and Lucena, C.}, year={2021}, pages={61–70} }
 @inproceedings{uchôa_assun?ão_garcia_2021, title={Do Critical Components Smell Bad? An Empirical Study with Component-based Software Product Lines}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-85117275523&partnerID=MN8TOARS}, DOI={10.1145/3483899.3483907}, abstractNote={Component-based software product line (SPL) consists of a set of software products that share common components. For a proper SPL product composition, each component has to follow three principles: encapsulating a single feature, restricting data access, and be replaceable. However, it is known that developers usually introduce anomalous structures, i.e., code smells, along the implementation of components. These code smells might violate one or more component principles and hinder the SPL product composition. Thus, developers should identify code smells in component-based SPLs, especially those affecting highly interconnected components, which are called critical components. Nevertheless, there is limited evidence of how smelly these critical components tend to be in component-based SPLs. To address this limitation, this paper presents a survey with developers of three SPLs. We inquire these developers about their perceptions of a critical component. Then, we characterize critical components per SPL, and identify nine recurring types of code smells. Finally, we quantitatively assess the smelliness of the critical components. Our results suggest that: (i) critical components are ten times more prone to have code smells than non-critical ones; (ii) the most frequent code smell types affecting critical components violate several component principles together; and (iii) these smell types affect multiple SPL components.}, booktitle={ACM International Conference Proceeding Series}, author={Uchôa, A. and Assun?ão, W.K.G. and Garcia, A.}, year={2021}, pages={21–30} }
 @inproceedings{eler_assun?ão_2021, title={Foreword}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-85118220917&partnerID=MN8TOARS}, booktitle={ACM International Conference Proceeding Series}, author={Eler, M.M. and Assun?ão, W.K.G.}, year={2021}, pages={V} }
 @inproceedings{assun?ão_ayala_krüger_mosser_2021, title={International Workshop on Variability Management for Modern Technologies (VM4ModernTech 2021)}, volume={Part F171624-A}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-85115317023&partnerID=MN8TOARS}, DOI={10.1145/3461001.3475157}, abstractNote={Variability is an inherent property of software systems that allows developers to deal with the needs of different customers and environments, creating a family of related systems. Variability can be managed in an opportunistic fashion, for example, using clone-and-own, or by employing a systematic approach, for instance, using a software product line (SPL). In the SPL community, variability management has been discussed for systems in various domains, such as defense, avionics, or finance, and for different platforms, such as desktops, web applications, or embedded systems. Unfortunately, other research communities---particularly those working on modern technologies, such as microservice architectures, cyber-physical systems, robotics, cloud computing, autonomous driving, or ML/AI-based systems---are less aware of the state-of-the-art in variability management, which is why they face similar problems and start to redeveloped the same solutions as the SPL community already did. With the International Workshop on Variability Management for Modern Technologies, we aim to foster and strengthen synergies between the communities researching variability management and modern technologies. More precisely, we aim to attract researchers and practitioners to contribute processes, techniques, tools, empirical studies, and problem descriptions or solutions that are related to reuse and variability management for modern technologies. By inviting different communities and establishing collaborations between them, we hope that the workshop can raise the interest of researchers outside the SPL community for variability management, and thus reduce the extent of costly redevelopments in research.}, booktitle={ACM International Conference Proceeding Series}, author={Assun?ão, W.K.G. and Ayala, I. and Krüger, J. and Mosser, S.}, year={2021}, pages={202} }
 @inproceedings{bibiano_assuncao_coutinho_santos_soares_gheyi_garcia_fonseca_ribeiro_oliveira_et al._2021, title={Look Ahead! Revealing Complete Composite Refactorings and their Smelliness Effects}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-85123331891&partnerID=MN8TOARS}, DOI={10.1109/ICSME52107.2021.00033}, abstractNote={Recent studies have revealed that developers often apply composite refactorings (or, simply, composites). A composite consists of two or more interrelated refactorings applied together. Previous studies investigated the effect of composites on code smells. A composite is considered "complete" whenever it completely removes one target code smell. They proposed descriptions of complete composites with recommendations to remove certain code smell types, such as Long Methods and Feature Envies. These studies also present different recommendations to remove the same code smell type. However, these studies: (i) are limited to composites only consisting of a small subset of Fowler's refactoring types, (ii) do not detail the scenarios in which each recommendation can be applied to remove the code smell, and (iii) fail in reporting possible side effects of the described composites, such as adversely introducing certain smell types. This paper aims to cover these limitations by performing a systematic analysis of 618 complete composites on removing four common smell types identified in 20 software projects. Our results indicated that: (i) 64% complete composites consisted of refactoring types not covered by existing descriptions of complete composites, and (ii) 36% complete composites formed by Extract Methods can introduce Feature Envies and Intensive Couplings. This information is not documented by existing descriptions, and it can alert developers about alternatives to remove Feature Envy, mainly in methods that are fully envious. These results suggest existing descriptions of complete composites should be either revisited or enhanced to explicitly highlight known side effects. We present a catalog of composites with details about side effects, recommendations to remove or minimize them, and some scenarios in which each recommendation can be applied to remove the code smell. Our catalog can be useful to improve existing tooling support for refactorings, such as IDEs, informing about possible side effects when refactorings are composed.}, booktitle={Proceedings - 2021 IEEE International Conference on Software Maintenance and Evolution, ICSME 2021}, author={Bibiano, A.C. and Assuncao, W.K.G. and Coutinho, D. and Santos, K. and Soares, V. and Gheyi, R. and Garcia, A. and Fonseca, B. and Ribeiro, M. and Oliveira, D. and et al.}, year={2021}, pages={298–308} }
 @inproceedings{michelon_obermann_assun?ão_linsbauer_grünbacher_egyed_2021, title={Managing systems evolving in space and time: Four challenges for maintenance, evolution and composition of variants}, volume={Part F171624-A}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-85115294106&partnerID=MN8TOARS}, DOI={10.1145/3461001.3461660}, abstractNote={Software companies need to provide a large set of features satisfying functional and non-functional requirements of diverse customers, thereby leading to variability in space. Feature location techniques have been proposed to support software maintenance and evolution in space. However, so far only one feature location technique also analyses the evolution in time of system variants, which is required for feature enhancements and bug fixing. Specifically, existing tools for managing a set of systems over time do not offer proper support for keeping track of feature revisions, updating existing variants, and creating new product configurations based on feature revisions. This paper presents four challenges concerning such capabilities for feature (revision) location and composition of new product configurations based on feature/s (revisions). We also provide a benchmark containing a ground truth and support for computing metrics. We hope that this will motivate researchers to provide and evaluate tool-supported approaches aiming at managing systems evolving in space and time. Further, we do not limit the evaluation of techniques to only this benchmark: we introduce and provide instructions on how to use a benchmark extractor for generating ground truth data for other systems. We expect that the feature (revision) location techniques maximize information retrieval in terms of precision, recall, and F-score, while keeping execution time and memory consumption low.}, booktitle={ACM International Conference Proceeding Series}, author={Michelon, G.K. and Obermann, D. and Assun?ão, W.K.G. and Linsbauer, L. and Grünbacher, P. and Egyed, A.}, year={2021}, pages={75–80} }
 @inproceedings{wolfart_assun?ão_da silva_domingos_schmeing_villaca_paza_2021, title={Modernizing legacy systems with microservices: A roadmap}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-85108906702&partnerID=MN8TOARS}, DOI={10.1145/3463274.3463334}, abstractNote={Legacy systems are long-lived applications, with obsolete technology and degraded architecture. These systems hamper digital transformation and innovation, and require a great amount of resources for maintenance. The modernization of monolithic legacy systems is a strategy to promote better evolution and maintenance, taking advantage of new technologies such as microservices. Microservice architectural style is a paradigm to develop systems as a suite of small and autonomous services, communicating through a lightweight protocol. However, the migration of legacy systems to microservices is complex. Although we can find several studies on this topic, they usually focus on specific activities, e.g., the identification of the microservice boundaries in the legacy code. Also, existing pieces of work do not cover real-world scenarios, since they do not take into account organizational, operational, and technical aspects. To overcome this limitation, in this paper we present a roadmap for modernizing monolithic legacy systems with microservices. The roadmap is distilled from the existing body of knowledge, describing common activities and input/output information. The proposed roadmap is composed of eight activities, grouped in four phases, namely initiation, planning, execution, and monitoring. The main contributions are: (i) serve as a basis for practitioners to plan, execute, and monitor the modernization process; (ii) be a reference for researchers to design new studies; and (iii) motivate tool builders to deal with existing needs.}, booktitle={ACM International Conference Proceeding Series}, author={Wolfart, D. and Assun?ão, W.K.G. and Da Silva, I.F. and Domingos, D.C.P. and Schmeing, E. and Villaca, G.L.D. and Paza, D.D.N.}, year={2021}, pages={149–159} }
 @inproceedings{uchoa_barbosa_coutinho_oizumi_assuncao_vergilio_pereira_oliveira_garcia_2021, title={Predicting design impactful changes in modern code review: A large-scale empirical study}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-85113692154&partnerID=MN8TOARS}, DOI={10.1109/MSR52588.2021.00059}, abstractNote={Companies have adopted modern code review as a key technique for continuously monitoring and improving the quality of software changes. One of the main motivations for this is the early detection of design impactful changes, to prevent that design-degrading ones prevail after each code review. Even though design degradation symptoms often lead to changes' rejections, practices of modern code review alone are actually not sufficient to avoid or mitigate design decay. Software design degrades whenever one or more symptoms of poor structural decisions, usually represented by smells, end up being introduced by a change. Design degradation may be related to both technical and social aspects in collaborative code reviews. Unfortunately, there is no study that investigates if code review stakeholders, e.g, reviewers, could benefit from approaches to distinguish and predict design impactful changes with technical and/or social aspects. By analyzing 57,498 reviewed code changes from seven open-source systems, we report an investigation on prediction of design impactful changes in modern code review. We evaluated the use of six ML algorithms to predict design impactful changes. We also extracted and assessed 41 different features based on both social and technical aspects. Our results show that Random Forest and Gradient Boosting are the best algorithms. We also observed that the use of technical features results in more precise predictions. However, the use of social features alone, which are available even before the code review starts (e.g., for team managers or change assigners), also leads to highly-accurate prediction. Therefore social and/or technical prediction models can be used to support further design inspection of suspicious changes early in a code review process. Finally, we provide an enriched dataset that allows researchers to investigate the context behind design impactful changes during the code review process.}, booktitle={Proceedings - 2021 IEEE/ACM 18th International Conference on Mining Software Repositories, MSR 2021}, author={Uchoa, A. and Barbosa, C. and Coutinho, D. and Oizumi, W. and Assuncao, W.K.G. and Vergilio, S.R. and Pereira, J.A. and Oliveira, A. and Garcia, A.}, year={2021}, pages={471–482} }
 @inproceedings{assun?ão_lopez-herrejon_ziadi_martinez_2021, title={REVE 2021: 9th International Workshop on Reverse Variability Engineering}, volume={Part F171624-A}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-85115346054&partnerID=MN8TOARS}, DOI={10.1145/3461001.3473054}, abstractNote={Software Product Line (SPL) migration remains a challenging endeavour. From organizational issues to purely technical challenges, there is a wide range of barriers that complicates SPL adoption. This workshop aims to foster research about making the most of the two main inputs for SPL migration: 1) domain knowledge and 2) legacy assets. Domain knowledge, usually implicit and spread across an organization, is key to define the SPL scope and to validate the variability model and its semantics. At the technical level, domain expertise is also needed to create or extract the reusable software components. Legacy assets can be, for instance, similar product variants (e.g., requirements, models, source code, etc.) that were implemented using ad-hoc reuse techniques such as clone-and-own. More generally, the workshop REverse Variability Engineering attracts researchers and practitioners contributing to processes, techniques, tools, or empirical studies related to the automatic, semi-automatic or manual extraction or refinement of SPL assets.}, booktitle={ACM International Conference Proceeding Series}, author={Assun?ão, W.K.G. and Lopez-Herrejon, R.E. and Ziadi, T. and Martinez, J.}, year={2021}, pages={203} }
 @inproceedings{marchezan_assun?ão_carbonell_rodrigues_bernardino_basso_2021, title={SPLReePlan - Automated Support for Software Product Line Reengineering Planning}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-85117301344&partnerID=MN8TOARS}, DOI={10.1145/3483899.3483902}, abstractNote={The extractive adoption of Software Product Lines (SPL) relies on the reuse of the already developed systems, employing a reengineering process. However, due to the diversity of options found in the daily practice of SPL development, rigorous planning of scenarios is critical to perform SPL reengineering. This diversity is the result of different organizational aspects, such as team experience and product portfolio. Hence, a proper planning process must consider technical and organizational aspects, however, most existing studies in the field do not take into account organizational aspects of the companies. In this work, we present SPLReePlan, an automated framework to aid the SPL reengineering planning taking into account technical and organizational aspects. Our framework is supported by a web-based tool, ready to be used in the industry. To investigate how flexible is SPLReePlan to support the SPL reengineering planning in diverse situations, we extracted eight different scenarios from the SPL literature, which are used as input for the evaluation of SPLReePlan. The results indicate that SPLReePlan can be satisfactorily customized to a variety of scenarios with different artifacts, feature retrieval techniques, and reengineering activities. As a contribution, we discuss the lessons learned within the evaluation, and present challenges that were faced, being a source of information for tool builders or motivating new studies.}, booktitle={ACM International Conference Proceeding Series}, author={Marchezan, L. and Assun?ão, W.K.G. and Carbonell, J. and Rodrigues, E. and Bernardino, M. and Basso, F.}, year={2021}, pages={1–10} }
 @article{marchezan_rodrigues_assun?ão_bernardino_basso_carbonell_2022, title={Software product line scoping: A systematic literature review}, volume={186}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-85121926915&partnerID=MN8TOARS}, DOI={10.1016/j.jss.2021.111189}, journal={Journal of Systems and Software}, author={Marchezan, L. and Rodrigues, E. and Assun?ão, W.K.G. and Bernardino, M. and Basso, F.P. and Carbonell, J.}, year={2022} }
 @inproceedings{michelon_sotto-mayor_martinez_arrieta_abreu_assun?ão_2021, title={Spectrum-based feature localization: A case study using ArgoUML}, volume={Part F171624-A}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-85115345131&partnerID=MN8TOARS}, DOI={10.1145/3461001.3473065}, abstractNote={Feature localization (FL) is a basic activity in re-engineering legacy systems into software product lines. In this work, we explore the use of the Spectrum-based localization technique for this task. This technique is traditionally used for fault localization but with practical applications in other tasks like the dynamic FL approach that we propose. The ArgoUML SPL benchmark is used as a case study and we compare it with a previous hybrid (static and dynamic) approach from which we reuse the manual and testing execution traces of the features. We conclude that it is feasible and sound to use the Spectrum-based approach providing promising results in the benchmark metrics.}, booktitle={ACM International Conference Proceeding Series}, author={Michelon, G.K. and Sotto-Mayor, B. and Martinez, J. and Arrieta, A. and Abreu, R. and Assun?ão, W.K.G.}, year={2021}, pages={126–130} }
 @inproceedings{michelon_assun?ão_obermann_linsbauer_grünbacher_egyed_2021, title={The life cycle of features in highly-configurable software systems evolving in space and time}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-85120903950&partnerID=MN8TOARS}, DOI={10.1145/3486609.3487195}, abstractNote={Feature annotation based on preprocessor directives is the most common mechanism in Highly-Configurable Software Systems (HCSSs) to manage variability. However, it is challenging to understand, maintain, and evolve feature fragments guarded by #ifdef directives. Yet, despite HCSSs being implemented in Version Control Systems, the support for evolving features in space and time is still limited. To extend the knowledge on this topic, we analyze the feature life cycle in space and time. Specifically, we introduce an automated mining approach and apply it to four HCSSs, analyzing commits of their entire development life cycle (13 to 20 years and 37,500 commits). This goes beyond existing studies, which investigated only differences between specific releases or entire systems. Our results show that features undergo frequent changes, often with substantial modifications of their code. The findings of our empirical analyses stress the need for better support of system evolution in space and time at the level of features. In addition to these analyses, we contribute an automated mining approach for the analysis of system evolution at the level of features. Furthermore, we also make available our dataset to foster new studies on feature evolution in HCSSs.}, booktitle={GPCE 2021 - Proceedings of the 20th ACM SIGPLAN International Conference on Generative Programming: Concepts and Experiences, co-located with SPLASH 2021}, author={Michelon, G.K. and Assun?ão, W.K.G. and Obermann, D. and Linsbauer, L. and Grünbacher, P. and Egyed, A.}, year={2021}, pages={2–15} }
 @inproceedings{wolfart_assun?ão_martinez_2022, title={Variability Debt: Characterization, Causes and Consequences}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-85147665494&partnerID=MN8TOARS}, DOI={10.1145/3493244.3493250}, abstractNote={Variability is an inherent property of software systems to create families of products dealing with needs of different customers and environments. However, some practices to manage variability may incur technical debt. For example, the use of opportunistic reuse strategies, e.g., clone-and-own, harms maintenance and evolution activities; or deciding to abandon variability management and deriving a single product with all the features might threaten system usability. These examples are common problems found in practice but, to the best of or knowledge, not properly investigated from the perspective of technical debt. To expand the knowledge on the research and practice of technical debt in the perspective of variability management, we report results of this phenomenon, which we defined as variability debt. Our work is based on 52 industrial case studies that report problems observed in the use of opportunistic reuse. The results show that variability debt is caused by business, operational and technical aspects; leads to complex maintenance, creates difficulties to customize and create new products, misuse of human resources, usability problems; and impacts artifacts along the whole life-cycle. Although some of these issues are investigated in the field of systematic variability management, e.g., software product lines, our contribution is to present them from a technical debt perspective to enrich and create synergies between the two fields. As additional contribution, we present a catalog of variability debts in the light of technical debts found in the literature.}, booktitle={ACM International Conference Proceeding Series}, author={Wolfart, D. and Assun?ão, W.K.G. and Martinez, J.}, year={2022} }
 @inproceedings{oliveira_assun?ão_souza_oizumi_garcia_fonseca_2020, title={Applying Machine Learning to Customized Smell Detection: A Multi-Project Study}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-85099375786&partnerID=MN8TOARS}, DOI={10.1145/3422392.3422427}, abstractNote={Code smells are considered symptoms of poor implementation choices, which may hamper the software maintainability. Hence, code smells should be detected as early as possible to avoid software quality degradation. Unfortunately, detecting code smells is not a trivial task. Some preliminary studies investigated and concluded that machine learning (ML) techniques are a promising way to better support smell detection. However, these techniques are hard to be customized to promote an early and accurate detection of specific smell types. Yet, ML techniques usually require numerous code examples to be trained (composing a relevant dataset) in order to achieve satisfactory accuracy. Unfortunately, such a dependency on a large validated dataset is impractical and leads to late detection of code smells. Thus, a prevailing challenge is the early customized detection of code smells taking into account the typical limited training data. In this direction, this paper reports a study in which we collected code smells, from ten active projects, that were actually refactored by developers, differently from studies that rely on code smells inferred by researchers. These smells were used for evaluating the accuracy regarding early detection of code smells by using seven ML techniques. Once we take into account such smells that were considered as important by developers, the ML techniques are able to customize the detection in order to focus on smells observed as relevant in the investigated systems. The results showed that all the analyzed techniques are sensitive to the type of smell and obtained good results for the majority of them, especially JRip and Random Forest. We also observe that the ML techniques did not need a high number of examples to reach their best accuracy results. This finding implies that ML techniques can be successfully used for early detection of smells without depending on the curation of a large dataset.}, booktitle={ACM International Conference Proceeding Series}, author={Oliveira, D. and Assun?ão, W.K.G. and Souza, L. and Oizumi, W. and Garcia, A. and Fonseca, B.}, year={2020}, pages={233–242} }
 @inproceedings{nicolodi_colanzi_assun?ão_2020, title={Architectural feature re-modularization for software product line evolution}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-85095844499&partnerID=MN8TOARS}, DOI={10.1145/3425269.3425271}, abstractNote={Extensive maintenance leads to the Software Product Line Architecture (PLA) degradation over time. When there is the need of evolving the Software Product Line (SPL) to include new features, or move to a new platform, a degraded PLA requires considerable effort to understand and modify, demanding expensive refactoring activity. In the state of the art, search-based algorithms are used to improve PLA at package level. However, recent studies have shown that the most variability and implementation details of an SPL are described in the level of classes. There is a gap between existing approaches and existing practical needs. In this work, we extend the current state of the art to deal with feature modularization in the level of classes by introducing a new search operator and a set of objective functions to deal with feature modularization in a finer granularity of the architectural elements, namely at class level. We evaluated the proposal in an exploratory study with a PLA widely investigated and a real-world PLA. The results of quantitative and qualitative analysis point out that our proposal provides solutions to properly re-modularize features in a PLA, being preferred by practitioners, in order to support the evolution of SPLs.}, booktitle={ACM International Conference Proceeding Series}, author={Nicolodi, L.B. and Colanzi, T.E. and Assun?ão, W.K.G.}, year={2020}, pages={31–40} }
 @inproceedings{silva_okada_colanzi_assuncao_2020, title={Enhancing search-based product line design with crossover operators}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-85091762574&partnerID=MN8TOARS}, DOI={10.1145/3377930.3390215}, abstractNote={The Product Line Architecture (PLA) is one of the most important artifacts of a Software Product Line. PLA designing has been formulated as a multi-objective optimization problem and successfully solved by a state-of-the-art search-based approach. However, the majority of empirical studies optimize PLA designs without applying one of the fundamental genetic operators: the crossover. An operator for PLA design, named Feature-driven Crossover, was proposed in a previous study. In spite of the promising results, this operator occasionally generated incomplete solutions. To overcome these limitations, this paper aims to enhance the search-based PLA design optimization by improving the Feature-driven Crossover and introducing a novel crossover operator specific for PLA design. The proposed operators were evaluated in two well-studied PLA designs, using three experimental configurations of NSGA-II in comparison with a baseline that uses only mutation operators. Empirical results show the usefulness and efficiency of the presented operators on reaching consistent solutions. We also observed that the two operators complement each other, leading to PLA design solutions with better feature modularization than the baseline experiment.}, booktitle={GECCO 2020 - Proceedings of the 2020 Genetic and Evolutionary Computation Conference}, author={Silva, D.F.D. and Okada, L.F. and Colanzi, T.E. and Assuncao, W.K.G.}, year={2020}, pages={1250–1258} }
 @inproceedings{marchezan_carbonell_rodrigues_bernardino_basso_assun?ão_2020, title={Enhancing the Feature Retrieval Process with Scoping and Tool Support: PAxSPL-v2}, volume={Part F164402-B}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-85097607776&partnerID=MN8TOARS}, DOI={10.1145/3382026.3425767}, abstractNote={Software Product Lines (SPLs) are commonly adopted with an extractive approach, by performing a reengineering process in legacy systems, when dealing with variability and reuse became challenging. As a starting activity of the process, the legacy systems are analyzed to retrieve, categorize, and group their features in terms of commonality and variability. Due to the importance of this feature retrieving, we proposed the Prepare, Assemble, and Execute framework for SPL reengineering (PAxSPL). PAxSPL aims at guiding users to customize the feature retrieval for their scenario. In an initial evaluation of the PAxSPL in a real-world scenario, we could observe the need for including scoping activities and implementing a tool to make the framework more adoptable in practice. In this paper, we describe how we performed these improvements. We performed the evolution of PAxSPL by including SPL scoping concepts and activities into our framework as well as developing a supporting tool. We also conducted a pilot study to evaluate how PAxSPL allows instantiating a scenario where the SPL reengineering were conducted. The results show that all artifacts, activities, and techniques from the scenario could be properly represented. However, we also identified a potential limitation during the assembly of techniques regarding parallel activities. The main contribution is PAxSPL_v2 that makes the framework more adherent to industries performing the reengineering of legacy systems into SPLs.}, booktitle={ACM International Conference Proceeding Series}, author={Marchezan, L. and Carbonell, J. and Rodrigues, E. and Bernardino, M. and Basso, F.P. and Assun?ão, W.K.G.}, year={2020}, pages={29–36} }
 @inproceedings{martinez_wolfart_assun?ão_figueiredo_2020, title={Insights on software product line extraction processes: ArgoUML to ArgoUML-SPL revisited}, volume={Part F164267-A}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-85097838269&partnerID=MN8TOARS}, DOI={10.1145/3382025.3414971}, abstractNote={Software Product Lines (SPLs) are rarely developed from scratch. Commonly, they emerge from monolithic architectures when there is a need to create tailored variants, or from existing variants created in an ad-hoc way once their separated maintenance and evolution become challenging. Despite the vast literature about re-engineering systems into SPLs and related technical approaches, there is a lack of detailed analysis about the process itself and the effort that is involved. We provide and analyze empirical data of an existing SPL extraction process: the ArgoUML monolithic architecture transition to ArgoUML-SPL. The analysis relies on information mined from the version control history of the source-code repository and the discussion with developers that took part in the process. The contribution of this study is an in-depth characterization of the process compared to previous works that focused only on the structural results of the final SPL. We made publicly available the dataset and the analysis scripts to be used as baseline for extractive SPL adoption research and practice.}, booktitle={ACM International Conference Proceeding Series}, author={Martinez, J. and Wolfart, D. and Assun?ão, W.K.G. and Figueiredo, E.}, year={2020}, pages={274–284} }
 @inproceedings{lima_mendon?a_vergilio_assun?ão_2020, title={Learning-based prioritization of test cases in continuous integration of highly-configurable software}, volume={Part F164267-A}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-85097852161&partnerID=MN8TOARS}, DOI={10.1145/3382025.3414967}, abstractNote={Continuous Integration (CI) is a practice widely adopted in the industry to allow frequent integration of code changes. During the CI process, many test cases are executed multiple times a day, subject to time constraints. In this scenario, a learning-based approach, named COLEMAN, has been successfully applied. COLEMAN allows earlier execution of the most promising test cases to reveal faults. This approach considers CI particularities such as time budget and volatility of test cases, related to the fact that test cases can be added/removed along the CI cycles. In the CI of Highly Configuration System (HCS), many product variants must be tested, each one with different configuration options, but having test cases that are common to or reused from other variants. In this context, we found, by analogy, another particularity, the volatility of variants, that is, some variants can be included/discontinued along CI cycles. Considering this context, this work introduces two strategies for the application of COLEMAN in the CI of HCS: the Variant Test Set Strategy (VTS) that relies on the test set specific for each variant, and the Whole Test Set Strategy (WST) that prioritizes the test set composed by the union of the test cases of all variants. Both strategies are evaluated in a real-world HCS, considering three test budgets. The results show that the proposed strategies are applicable regarding the time spent for prioritization. They perform similarly regarding early fault detection, but WTS better mitigates the problem of beginning without knowledge, and is more suitable when a new variant to be tested is added.}, booktitle={ACM International Conference Proceeding Series}, author={Lima, J.A.P. and Mendon?a, W.D.F. and Vergilio, S.R. and Assun?ão, W.K.G.}, year={2020}, pages={242–247} }
 @inproceedings{michelon_obermann_linsbauer_assun?ão_grünbacher_egyed_2020, title={Locating feature revisions in software systems evolving in space and time}, volume={Part F164267-A}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-85097625158&partnerID=MN8TOARS}, DOI={10.1145/3382025.3414954}, abstractNote={Software companies encounter variability in space as variants of software systems need to be produced for different customers. At the same time, companies need to handle evolution in time because the customized variants need to be revised and kept up-to-date. This leads to a predicament in practice with many system variants significantly diverging from each other. Maintaining these variants consistently is difficult, as they diverge across space, i.e., different feature combinations, and over time, i.e., revisions of features. This work presents an automated feature revision location technique that traces feature revisions to their implementation. To assess the correctness of our technique, we used variants and revisions from three open source highly configurable software systems. In particular, we compared the original artifacts of the variants with the composed artifacts that were located by our technique. The results show that our technique can properly trace feature revisions to their implementation, reaching traces with 100% precision and 98% recall on average for the three analyzed subject systems, taking on average around 50 seconds for locating feature revisions per variant used as input.}, booktitle={ACM International Conference Proceeding Series}, author={Michelon, G.K. and Obermann, D. and Linsbauer, L. and Assun?ão, W.K.G. and Grünbacher, P. and Egyed, A.}, year={2020}, pages={142–147} }
 @inproceedings{michelon_obermann_assun?ão_linsbauer_grünbacher_egyed_2020, title={Mining Feature Revisions in Highly-Configurable Software Systems}, volume={Part F164402-B}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-85097600056&partnerID=MN8TOARS}, DOI={10.1145/3382026.3425776}, abstractNote={Highly-Configurable Software Systems (HCSSs) support the systematic evolution of systems in space, i.e., the inclusion of new features, which then allow users to configure software products according to their needs. However, HCSSs also change over time, e.g., when adapting existing features to new hardware or platforms. In practice, HCSSs are thus developed using both version control systems (VCSs) and preprocessor directives (#ifdefs). However, the use of a preprocessor as variability mechanism has been criticized regarding the separation of concerns and code obfuscation, which complicates the analysis of HCSS evolution in VCSs. For instance, a single commit may contain changes of totally unrelated features, which may be scattered over many variation points (#ifdefs), thus making the evolution history hard to understand. This complexity often leads to error-prone changes and high costs for maintenance and evolution. In this paper, we propose an automated approach to mine HCSS features taking into account evolution in space and time. Our approach uses constraint satisfaction problem solving to mine newly introduced, removed and changed features. It finds a configuration containing the feature revisions which are needed to activate a specific program location. Furthermore, it increments the revision number of each changed feature. Thus, our approach enables to analyze when and which features often change over time, as well as their interactions, for every single commit of a HCSS. Our approach can contribute to future research on understanding the characteristics of HCSS and supporting developers during maintenance and evolution tasks.}, booktitle={ACM International Conference Proceeding Series}, author={Michelon, G.K. and Obermann, D. and Assun?ão, W.K.G. and Linsbauer, L. and Grünbacher, P. and Egyed, A.}, year={2020}, pages={74–78} }
 @inproceedings{carvalho_garcia_colanzi_assuncao_pereira_fonseca_ribeiro_de lima_lucena_2020, title={On the Performance and Adoption of Search-Based Microservice Identification with toMicroservices}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-85096666893&partnerID=MN8TOARS}, DOI={10.1109/ICSME46990.2020.00060}, abstractNote={The expensive maintenance of legacy systems leads companies to migrate such systems to microservice architectures. This migration requires the identification of system's legacy parts to become microservices. However, the successful identification of microservices, which are promising to be adoptable in practice, requires the simultaneous satisfaction of many criteria, such as coupling, cohesion, reuse and communication overhead. Search-based microservice identification has been recently investigated to address this problem. However, state-of-the-art search-based approaches are limited as they only consider one or two criteria (namely cohesion and coupling), possibly not fulfilling the practical needs of developers. To overcome these limitations, we propose toMicroservices, a many-objective search-based approach that considers five criteria, the most cited by practitioners in recent studies. Our approach was evaluated in a real-life industrial legacy system undergoing a microservice migration process. The performance of toMicroservices was quantitatively compared to a baseline. We also gathered qualitative evidence based on developers' perceptions, who judged the adoptability of the recommended microservices. The results show that our approach is both: (i) very similar to the most recent proposed approach on optimizing the traditional criteria of coupling and cohesion, but (ii) much better when taking into account all the five criteria. Finally, most of the microservice candidates were considered adoptable by practitioners.}, booktitle={Proceedings - 2020 IEEE International Conference on Software Maintenance and Evolution, ICSME 2020}, author={Carvalho, L. and Garcia, A. and Colanzi, T.E. and Assuncao, W.K.G. and Pereira, J.A. and Fonseca, B. and Ribeiro, M. and De Lima, M.J. and Lucena, C.}, year={2020}, pages={569–580} }
 @inproceedings{assun?ão_acher_ziadi_martinez_2020, title={REVE 2020: 8th International Workshop on Reverse Variability Engineering}, volume={Part F164267-A}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-85097806798&partnerID=MN8TOARS}, DOI={10.1145/3382025.3414947}, abstractNote={Software Product Line (SPL) migration remains a challenging endeavour. From organizational issues to purely technical challenges, there is a wide range of barriers that complicates SPL adoption. This workshop aims to foster research about making the most of the two main inputs for SPL migration: 1) domain knowledge and 2) legacy assets. Domain knowledge, usually implicit and spread across an organization, is key to define the SPL scope and to validate the variability model and its semantics. At the technical level, domain expertise is also needed to create or extract the reusable software components. Legacy assets can be, for instance, similar product variants (e.g., requirements, models, source code, etc.) that were implemented using ad-hoc reuse techniques such as clone-and-own. More generally, the workshop REverse Variability Engineering attracts researchers and practitioners contributing to processes, techniques, tools, or empirical studies related to the automatic, semi-automatic or manual extraction or refinement of SPL assets.}, booktitle={ACM International Conference Proceeding Series}, author={Assun?ão, W.K.G. and Acher, M. and Ziadi, T. and Martinez, J.}, year={2020}, pages={65–76} }
 @inproceedings{carvalho_garcia_colanzi_assun?ão_lima_fonseca_ribeiro_lucena_2020, title={Search-based many-criteria identification of microservices from legacy systems}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-85089747024&partnerID=MN8TOARS}, DOI={10.1145/3377929.3390030}, abstractNote={The expensive maintenance of legacy systems lead companies to migrate such systems to a microservice architecture. This migration requires the identification of microservice candidates, which requires analysis of many criteria. Existing search-based approaches to solve this problem are only based on the coupling and cohesion criteria. To overcome these limitations, we propose a many-objective search-based approach for identifying microservice candidates. Its five objectives correspond to criteria pointed as useful by experienced developers. Our approach was evaluated in the context of a legacy system. The results show that our approach is very similar on optimizing the traditional criteria of coupling and cohesion, but much better when taking into account the additional criteria.}, booktitle={GECCO 2020 Companion - Proceedings of the 2020 Genetic and Evolutionary Computation Conference Companion}, author={Carvalho, L. and Garcia, A. and Colanzi, T.E. and Assun?ão, W.K.G. and Lima, M.J. and Fonseca, B. and Ribeiro, M. and Lucena, C.}, year={2020}, pages={305–306} }
 @article{colanzi_assun?ão_vergilio_farah_guizzo_2020, title={The Symposium on Search-Based Software Eengineering: Past, Present and Future}, volume={127}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-85087589181&partnerID=MN8TOARS}, DOI={10.1016/j.infsof.2020.106372}, journal={Information and Software Technology}, author={Colanzi, T.E. and Assun?ão, W.K.G. and Vergilio, S.R. and Farah, P.R. and Guizzo, G.}, year={2020} }
 @inproceedings{mendonca_assuncao_estanislau_vergilio_garcia_2020, title={Towards a Microservices-Based Product Line with Multi-Objective Evolutionary Algorithms}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-85092059111&partnerID=MN8TOARS}, DOI={10.1109/CEC48606.2020.9185776}, abstractNote={Microservices are small and independently deployable services. They can be developed on different platforms and communicate via lightweight protocols, what makes them highly interoperable. The interoperability between microservices, as well as their reuse and customization needs make this kind of systems adequate to constitute a Software Product Line. However, there is no automatic approach to support the designing of Microservices-Based Product Lines (MBPLs). To move towards the development of MBPLs, this work presents an approach, named MOEA4MBPL, to extract Feature Models (FMs) from a set of microservices-based systems. These FMs intent to leverage interoperability, enabling the practitioners to reason about reuse and/or customization of functionalities. The proposed approach is based on multi-objective evolutionary algorithms, optimizing three objectives, namely precision and recall of products denoted by an FM, and conformance with existing dependencies between microservices. MOEA4MBPL was evaluated with six microservices-based systems, using the algorithms NSGA-II and SPEA2. Our approach was capable of finding FMs with good trade-off values of precision and recall, satisfying all dependencies among the microservices. SPEA2 found better fronts of solutions than NSGA-II, but the latter always executed faster and could find single solutions closer to an ideal solution than the former.}, booktitle={2020 IEEE Congress on Evolutionary Computation, CEC 2020 - Conference Proceedings}, author={Mendonca, W.D.F. and Assuncao, W.K.G. and Estanislau, L.V. and Vergilio, S.R. and Garcia, A.}, year={2020} }
 @inproceedings{assun?ão_krüger_mendon?a_2020, title={Variability management meets microservices: six challenges of re-engineering microservice-based webshops}, volume={Part F164267-A}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-85097831169&partnerID=MN8TOARS}, DOI={10.1145/3382025.3414942}, abstractNote={A microservice implements a small unit of functionality that it provides through a network using lightweight protocols. So, microservices can be combined to fulfill tasks and implement features of a larger software system---resembling a variability mechanism in the context of a software product line (SPL). Microservices and SPLs have similar goals, namely facilitating reuse and customizing, but they are usually employed in different contexts. Any developer who has access to the network can provide a microservice for any task, while SPLs are usually intended to implement features of a specific domain. Due to their different concepts, using microservices to implement an SPL or adopting SPL practices (e.g., variability management) for microservices is a challenging cross-area research problem. However, both techniques can complement each other, and thus tackling this problem promises benefits for organizations that employ either technique. In this paper, we reason on the importance of advancing in this direction, and sketch six concrete challenges to initiate research, namely (1) feature identification, (2) variability modeling, (3) variable microservice architectures, (4) interchangeability, (5) deep customization, and (6) re-engineering an SPL. We intend these challenges to serve as a starting point for future research in this cross-area research direction---avoiding that the concepts of one area are reinvented in the other.}, booktitle={ACM International Conference Proceeding Series}, author={Assun?ão, W.K.G. and Krüger, J. and Mendon?a, W.D.F.}, year={2020}, pages={14–24} }
 @book{colanzi_assun?ão_farah_vergilio_guizzo_2019, title={A Review of Ten Years of the Symposium on Search-Based Software Engineering}, volume={11664 LNCS}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-85072863599&partnerID=MN8TOARS}, DOI={10.1007/978-3-030-27455-9_4}, journal={Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)}, author={Colanzi, T.E. and Assun?ão, W.K.G. and Farah, P.R. and Vergilio, S.R. and Guizzo, G.}, year={2019}, pages={42–57} }
 @article{adopting a software product line engineering approach in industrial development contexts: a protocol for a systematic literature review_2019, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-85093998102&partnerID=MN8TOARS}, journal={arXiv}, year={2019} }
 @inproceedings{carvalho_garcia_assuncao_de mello_julia de lima_2019, title={Analysis of the Criteria Adopted in Industry to Extract Microservices}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-85072880614&partnerID=MN8TOARS}, DOI={10.1109/CESSER-IP.2019.00012}, abstractNote={A microservice architecture is expected to provide a better modularization and management of small and autonomous services. Other expected benefits include increased availability and time to market. There is a growing interest of both industry and academia on streamlining the migration of existing systems to a microservice architecture. However, the success of this migration is largely dependent on the use of appropriate criteria for extracting microservices from a code base. Recent studies indicate the selection and decomposition of microservices represent the main challenge along the migration. Academic techniques tend to support the extraction of microservices with either one or two conventional criteria, namely coupling and cohesion. There is limited knowledge on the criteria actually considered as useful by practitioners. Thus, we have performed an exploratory online survey with 15 specialists experienced on migrating systems to a microservices architecture. In particular, we question the relative usefulness of seven possible criteria for supporting decision-making along microservice extraction. The participants were also questioned about tools they have used, their limitations, and whether the decisions on extracted microservices were considered unsuccessful. Overall, the survey results suggest academic techniques do not totally satisfy the needs of practitioners. Practitioners often need to consider simultaneously at least four dominant criteria as well as their trade-offs to support their decisions. Most practitioners consider existing tooling support insufficient or even irrelevant to support their microservice extraction decisions.}, booktitle={Proceedings - 2019 IEEE/ACM Joint 7th International Workshop on Conducting Empirical Studies in Industry and 6th International Workshop on Software Engineering Research and Industrial Practice, CESSER-IP 2019}, author={Carvalho, L. and Garcia, A. and Assuncao, W.K.G. and De Mello, R. and Julia De Lima, M.}, year={2019}, pages={22–29} }
 @article{assun?ão_vergilio_lopez-herrejon_2020, title={Automatic extraction of product line architecture and feature models from UML class diagram variants}, volume={117}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-85073249376&partnerID=MN8TOARS}, DOI={10.1016/j.infsof.2019.106198}, journal={Information and Software Technology}, author={Assun?ão, W.K.G. and Vergilio, S.R. and Lopez-Herrejon, R.E.}, year={2020} }
 @inproceedings{michelon_linsbauer_assun?ão_egyed_2019, title={Comparison-based feature location in ArgoUML variants}, volume={A}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-85123042169&partnerID=MN8TOARS}, DOI={10.1145/3336294.3342360}, abstractNote={Identifying and extracting parts of a system's implementation for reuse is an important task for re-engineering system variants into Software Product Lines (SPLs). An SPL is an approach that enables systematic reuse of existing assets across related product variants. The re-engineering process to adopt an SPL from a set of individual variants starts with the location of features and their implementation, to be extracted and migrated into an SPL and reused in new variants. Therefore, feature location is of fundamental importance to the success in the adoption of SPLs. Despite its importance, existing feature location techniques struggle with huge, complex, and numerous system artifacts. This is the scenario of ArgoUML-SPL, which stands out as the most used case study for the validation of feature location approaches. In this paper we use an automated feature location technique and apply it to the ArgoUML feature location challenge posed.}, booktitle={ACM International Conference Proceeding Series}, author={Michelon, G.K. and Linsbauer, L. and Assun?ão, W.K.G. and Egyed, A.}, year={2019} }
 @inproceedings{carvalho_garcia_assun?ão_bonifácio_tizzei_colanzi_2019, title={Extraction of configurable and reusable microservices from legacy systems: An exploratory study}, volume={A}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-85123041488&partnerID=MN8TOARS}, DOI={10.1145/3336294.3336319}, abstractNote={Microservices is an emerging industrial technique to promote better modularization and management of small and autonomous services. Microservice architecture is widely used to overcome the limitations of monolithic legacy systems, such as limited maintainability and reusability. Migration to a microservice architecture is increasingly becoming the focus of academic research. However, there is little knowledge on how microservices are extracted from legacy systems in practice. Among these limitations, there is a lack of understanding if variability is considered useful along the microservice extraction from a configurable system. In order to address this gap, we performed an exploratory study composed of two phases. Firstly, we conducted an online survey with 26 specialists that contributed to the migration of existing systems to a microservice architecture. Secondly, we performed individual interviews with seven survey participants. A subset of the participants (13 out of 26) dealt with systems with variability during the extraction, which stated that variability is a key criterion for structuring the microservices. Moreover, variability in the legacy system is usually implemented with simple mechanisms. Finally, initial evidence points out that microservices extraction can increase software customization.}, booktitle={ACM International Conference Proceeding Series}, author={Carvalho, L. and Garcia, A. and Assun?ão, W.K.G. and Bonifácio, R. and Tizzei, L.P. and Colanzi, T.E.}, year={2019} }
 @article{lima_assun?ão_martinez_mendon?a_machado_chavez_2019, title={Product line architecture recovery with outlier filtering in software families: the Apo-Games case study}, volume={25}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-85067872359&partnerID=MN8TOARS}, DOI={10.1186/s13173-019-0088-4}, abstractNote={Software product line (SPL) approach has been widely adopted to achieve systematic reuse in families of software products. Despite its benefits, developing an SPL from scratch requires high up-front investment. Because of that, organizations commonly create product variants with opportunistic reuse approaches (e.g., copy-and-paste or clone-and-own). However, maintenance and evolution of a large number of product variants is a challenging task. In this context, a family of products developed opportunistically is a good starting point to adopt SPLs, known as extractive approach for SPL adoption. One of the initial phases of the extractive approach is the recovery and definition of a product line architecture (PLA) based on existing software variants, to support variant derivation and also to allow the customization according to customers' needs. The problem of defining a PLA from existing system variants is that some variants can become highly unrelated to their predecessors, known as outlier variants. The inclusion of outlier variants in the PLA recovery leads to additional effort and noise in the common structure and complicates architectural decisions. In this work, we present an automatic approach to identify and filter outlier variants during the recovery and definition of PLAs. Our approach identifies the minimum subset of cross-product architectural information for an effective PLA recovery. To evaluate our approach, we focus on real-world variants of the Apo-Games family. We recover a PLA taking as input 34 Apo-Game variants developed by using opportunistic reuse. The results provided evidence that our automatic approach is able to identify and filter outlier variants, allowing to eliminate exclusive packages and classes without removing the whole variant. We consider that the recovered PLA can help domain experts to take informed decisions to support SPL adoption.}, number={1}, journal={Journal of the Brazilian Computer Society}, author={Lima, C. and Assun?ão, W.K. and Martinez, J. and Mendon?a, W. and Machado, I.C. and Chavez, C.F.}, year={2019} }
 @inproceedings{mendon?a_assun?ão_vergilio_2019, title={Reusing test cases on graph product line variants: Results from a state-of-the-practice test data generation tool}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-85076716548&partnerID=MN8TOARS}, DOI={10.1145/3356317.3356318}, abstractNote={Software testing is an essential activity for quality assurance, but, it is an error-prone and effort consuming task when conducted manually. Because of this, the use of automated tools is fundamental, as well as, the evaluation of these tools in practice. However, there is not so much evidence on how such tools perform on highly-configurable systems. Highly-configurable systems are commonly observed in industry as an approach to develop families of products, where products have different configuration options to meet customer needs. To fulfill such a gap, this paper reports results on the use of the tool Randoop, which is widely used in industry, to test variants of the Graph Product Line (GPL) family of products. Our goal is to evaluate reusability of a test data set generated by Randoop for one product when reused for testing other GPL products. Besides, we also investigate the impact of using different values of runtime, the main Randoop parameter, on the number of reused test data. The results show that the used value for runtime in general does not contribute to increase the coverage of test data reused in different products. Furthermore, similarity among products does not ensure a greater reusability.}, booktitle={ACM International Conference Proceeding Series}, author={Mendon?a, W.D.F. and Assun?ão, W.K.G. and Vergilio, S.R.}, year={2019}, pages={52–61} }
 @inproceedings{duchien_thüm_salinesi_ziadi_heymans_fogdal_martinez_kehrer_teixeira_rabiser_et al._2019, title={Welcome message}, volume={A}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-85123040152&partnerID=MN8TOARS}, booktitle={ACM International Conference Proceeding Series}, author={Duchien, L. and Thüm, T. and Salinesi, C. and Ziadi, T. and Heymans, P. and Fogdal, T. and Martinez, J. and Kehrer, T. and Teixeira, L. and Rabiser, R. and et al.}, year={2019}, pages={xi} }
 @inproceedings{mendon?a_assun?ão_linsbauer_2018, title={Multi-objective optimization for reverse engineering of apo-games feature models}, volume={1}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-85055522328&partnerID=MN8TOARS}, DOI={10.1145/3233027.3236397}, abstractNote={Software Product Lines Engineering (SPLE) is a software development approach intended for the development and maintenance of variable systems, i.e. systems that exist in many different variants. In the long run SPLE has many advantages. However, it requires a large upfront investment of time and money, which is why in practice Software Product Lines (SPLs) are rarely developed from scratch. Instead, they are often built using an extractive approach by which a set of existing system variants is consolidated (i.e. reverse engineered) into an SPL. A crucial part of this process is the construction of a variability model like a Feature Model (FM) that describes the common and variable parts of the system variants. In this paper we apply an approach for reverse engineering feature models based on a multi-objective optimization algorithm to the given challenge of constructing a feature model for a set of game variants and we present the results.}, booktitle={ACM International Conference Proceeding Series}, author={Mendon?a, W.D.F. and Assun?ão, W.K.G. and Linsbauer, L.}, year={2018}, pages={279–283} }
 @inproceedings{de oliveira júnior_assun?ão_jeronymo_2018, title={Multi-objective tuning of generalized predictive controller: A trade-off between performance and robustness}, volume={2018-November}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-85065104022&partnerID=MN8TOARS}, DOI={10.1109/SBESC.2018.00034}, abstractNote={This paper investigates the application of the Non-dominated Sorting Genetic Algorithm II (NSGA-II) to the Generalized Predictive Controller (GPC) parameter tuning. GPC stands out for using predictions of a future system behavior in order to evaluate an optimal control law according to certain performance criteria. GPC deals with multiple conflicting objectives such as minimizing set-point error, reducing variation of control actions and greater robustness. In this work, NSGA-II is applied to the problem of parameter tuning considering the trade-off between performance and robustness. A rule is deduced for choosing an adequate solution in the Pareto front which leads to overall best compromise between performance and robustness criteria. From the results we can observe that NSGA-II reaches satisfactory solutions that allows a better decision-making.}, booktitle={Brazilian Symposium on Computing System Engineering, SBESC}, author={De Oliveira Júnior, J.A. and Assun?ão, W.K.G. and Jeronymo, D.C.}, year={2018}, pages={178–183} }
 @inproceedings{lima_assuncaõ_martinez_do carmo machado_chavez_mendonca_2018, title={Towards an automated product line architecture recovery: The apo-games case study}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-85055700352&partnerID=MN8TOARS}, DOI={10.1145/3267183.3267187}, abstractNote={Software Product Line Engineering (SPLE) has been widely adopted for applying systematic reuse in families of systems. Given the high upfront investment required for SPLE adoption, organizations commonly start with more opportunistic reuse approaches (e.g., a single system that they clone and modify). However, maintenance problems appear when managing a large number of similar systems where each of them implements and evolves particular characteristics. One viable solution to solve this issue is to migrate to SPLs using an extractive approach. This initiative, in its early phases, includes the definition of a Product Line Architecture (PLA) supporting the variants derivation and also allowing the customization according to customers' needs. Our objective is to provide automatic support in PLA recovery to reduce the time and effort in this process. One of the main issues in the extractive approach is the explosion of the variability in the PLA representation. Our approach is based on identifying the minimum subset of cross-product architectural information for an effective PLA recovery. To evaluate our approach, we applied it in the case of the Apo-Games projects. The experimentation in this real family of systems showed that our automatic approach is able to identify variant outliers and help domain experts to take informed decisions to support PLA recovery.}, booktitle={ACM International Conference Proceeding Series}, author={Lima, C. and Assuncaõ, W.K.G. and Martinez, J. and Do Carmo MacHado, I. and Chavez, C.V.F.G. and Mendonca, W.D.F.}, year={2018}, pages={33–42} }
 @book{assun?ão_vergilio_lopez-herrejon_2017, title={Discovering software architectures with search-based merge of UML model variants}, volume={10221 LNCS}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-85019254375&partnerID=MN8TOARS}, DOI={10.1007/978-3-319-56856-0_7}, journal={Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)}, author={Assun?ão, W.K.G. and Vergilio, S.R. and Lopez-Herrejon, R.E.}, year={2017}, pages={95–111} }
 @inproceedings{martinez_assun?ão_ziadi_2017, title={ESPLA: A catalog of extractive SPL adoption case studies}, volume={2}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-85032298191&partnerID=MN8TOARS}, DOI={10.1145/3109729.3109748}, abstractNote={Building Software Product Lines (SPLs) from existing artefacts is known as the extractive approach for SPL adoption. The traditional case is that variants are created with ad-hoc reuse (e.g., copy-paste-modify to quickly respond to different customer needs) and practitioners want to reengineer them to an SPL. Several industrial cases have been presented in the literature to motivate the interest of the extraction and many case studies are used to validate methods and techniques for different activities during this adoption process.}, booktitle={ACM International Conference Proceeding Series}, author={Martinez, J. and Assun?ão, W.K.G. and Ziadi, T.}, year={2017}, pages={38–41} }
 @article{assun?ão_lopez-herrejon_linsbauer_vergilio_egyed_2017, title={Reengineering legacy applications into software product lines: a systematic mapping}, volume={22}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-85011923741&partnerID=MN8TOARS}, DOI={10.1007/s10664-017-9499-z}, number={6}, journal={Empirical Software Engineering}, author={Assun?ão, W.K.G. and Lopez-Herrejon, R.E. and Linsbauer, L. and Vergilio, S.R. and Egyed, A.}, year={2017}, pages={2972–3016} }
 @article{assun?ão_lopez-herrejon_linsbauer_vergilio_egyed_2017, title={Multi-objective reverse engineering of variability-safe feature models based on code dependencies of system variants}, volume={22}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-84991821880&partnerID=MN8TOARS}, DOI={10.1007/s10664-016-9462-4}, number={4}, journal={Empirical Software Engineering}, author={Assun?ão, W.K.G. and Lopez-Herrejon, R.E. and Linsbauer, L. and Vergilio, S.R. and Egyed, A.}, year={2017}, pages={1763–1794} }
 @inproceedings{assun?ão_lopez-herrejon_linsbauer_vergilio_egyed_2015, title={Extracting variability-safe feature models from source code dependencies in system variants}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-84963680002&partnerID=MN8TOARS}, DOI={10.1145/2739480.2754720}, abstractNote={To effectively cope with increasing customization demands, companies that have developed variants of software systems are faced with the challenge of consolidating all the variants into a Software Product Line, a proven development paradigm capable of handling such demands. A crucial step in this challenge is to reverse engineer feature models that capture all the required feature combinations of each system variant. Current research has explored this task using propositional logic, natural language, and search-based techniques. However, using knowledge from the implementation artifacts for the reverse engineering task has not been studied. We propose a multi-objective approach that not only uses standard precision and recall metrics for the combinations of features but that also considers variability-safety, i.e. the property that, based on structural dependencies among elements of implementation artifacts, asserts whether all feature combinations of a feature model are in fact well-formed software systems. We evaluate our approach with five case studies and highlight its benefits for the software engineer.}, booktitle={GECCO 2015 - Proceedings of the 2015 Genetic and Evolutionary Computation Conference}, author={Assun?ão, W.K.G. and Lopez-Herrejon, R.E. and Linsbauer, L. and Vergilio, S.R. and Egyed, A.}, year={2015}, pages={1303–1310} }
 @inproceedings{lopez-herrejon_linsbauer_assun?ão_fischer_vergilio_egyed_2015, title={Genetic improvement for software product lines: An overview and a roadmap}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-84959341361&partnerID=MN8TOARS}, DOI={10.1145/2739482.2768422}, abstractNote={Software Product Lines (SPLs) are families of related software systems that provide different combinations of features. Extensive research and application attest to the significant economical and technological benefits of employing SPL practices. However, there are still several challenges that remain open. Salient among them is reverse engineering SPLs from existing variants of software systems and their subsequent evolution. In this paper, we aim at sketching connections between research on these open SPL challenges and ongoing work on Genetic Improvement. Our hope is that by drawing such connections we can spark the interest of both research communities on the exciting synergies at the intersection of these subject areas.}, booktitle={GECCO 2015 - Companion Publication of the 2015 Genetic and Evolutionary Computation Conference}, author={Lopez-Herrejon, R.E. and Linsbauer, L. and Assun?ão, W.K.G. and Fischer, S. and Vergilio, S.R. and Egyed, A.}, year={2015}, pages={823–830} }
 @inproceedings{assuncao_2015, title={Search-Based Migration of Model Variants to Software Product Line Architectures}, volume={2}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-84951760881&partnerID=MN8TOARS}, DOI={10.1109/ICSE.2015.286}, abstractNote={Software Product Lines (SPLs) are families of related software systems developed for specific market segments or domains. Commonly, SPLs emerge from sets of existing variants when their individual maintenance becomes infeasible. However, current approaches for SPL migration do not support design models, are partially automated, or do not reflect constraints from SPL domains. To tackle these limitations, the goal of this doctoral research plan is to propose an automated approach to the SPL migration process at the design level. This approach consists of three phases: detection, analysis and transformation. It uses as input the class diagrams and lists of features for each system variant, and relies on search-based algorithms to create a product line architecture that best captures the variability present in the variants. Our expected contribution is to support the adoption of SPL practices in companies that face the scenario of migrating variants to SPLs.}, booktitle={Proceedings - International Conference on Software Engineering}, author={Assuncao, W.K.G.}, year={2015}, pages={895–898} }
 @article{assun?ão_colanzi_vergilio_pozo_2014, title={A multi-objective optimization approach for the integration and test order problem}, volume={267}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-84896390660&partnerID=MN8TOARS}, DOI={10.1016/j.ins.2013.12.040}, journal={Information Sciences}, author={Assun?ão, W.K.G. and Colanzi, T.E. and Vergilio, S.R. and Pozo, A.}, year={2014}, pages={119–139} }
 @article{assun?ão_colanzi_vergilio_ramirez pozo_2014, title={Evaluating different strategies for integration testing of aspect-oriented programs}, volume={20}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-84957571449&partnerID=MN8TOARS}, DOI={10.1186/1678-4804-20-9}, abstractNote={The determination of an order for integration and testing of aspects and classes is a difficult optimization problem. This order should be associated to a minimal possible stubbing cost. To determine such order, different approaches exist. For example, traditional approaches are based on Tarjan's algorithm; search-based approaches are based on metaheuristics, usually genetic algorithms (GA). In addition to such approaches, in the literature, there are different strategies to integrate aspect-oriented software. Some works suggest the integration of aspects and classes in a combined way. Other ones adopt an incremental strategy. Studies evaluating the approaches show that the multi-objective one presents better solutions. However, these studies were conducted applying only the combined strategy. In this paper, we present experimental results comparing both strategies with three different approaches: the traditional one, a simple GA-based, and a multi-objective one. The results show better performance of the multi-objective approach independently of the strategy adopted. A comparison of both strategies points out that the incremental strategy reaches a lower cost in most cases, considering a number of attributes and operations to be emulated in the stub. It seems that with Incremental+, the best choice is the multi-objective approach. If the system is very complex, PAES seems to be the best MOEA.}, number={1}, journal={Journal of the Brazilian Computer Society}, author={Assun?ão, W.K.G. and Colanzi, T.E. and Vergilio, S.R. and Ramirez Pozo, A.T.}, year={2014}, pages={1–17} }
 @book{assun?ão_vergilio_2014, title={Feature location for software product line migration: A mapping study}, volume={2}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-84907833307&partnerID=MN8TOARS}, DOI={10.1145/2647908.2655967}, abstractNote={Developing software from scratch is a high cost and error-prone activity. A possible solution to reduce time-to-market and produce high quality software is the reuse of existing software. But when the number of features in the system grows, the maintenance becomes more complex. In such cases, to adopt a systematic approach, such as Software Product Line Engineering, is necessary. Existing systems are generally migrated to a product line, allowing systematic reuse of artefacts and easing maintenance. To this end, some approaches have been proposed in the literature in the last years. A mapping of works on this subject and the identification of some research gaps can lead to an improvement of such approaches. This paper describes the main outcomes of a systematic mapping study on the evolution and migration of systems to SPL. The main works found are presented and classified according to adopted strategy, artefacts used, and evaluation conducted. Analysis of the evolution along the past years are also presented. At the end, we summarize some trends and open issues to serve as reference to new researches.}, journal={ACM International Conference Proceeding Series}, author={Assun?ão, W.K.G. and Vergilio, S.R.}, year={2014}, pages={52–59} }
 @inproceedings{assun?ão_vergilio_2013, title={A multi-objective solution for retrieving class diagrams}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-84894136461&partnerID=MN8TOARS}, DOI={10.1109/BRACIS.2013.49}, abstractNote={A problem related to software reuse is to locate and retrieve, from a repository, the most suitable model, such as the UML class diagram. The search space is generally huge, and several characteristics (objectives) need to be considered. Similar software engineering problems, which are dependent on different measures, have been efficiently solved by using multi-objective algorithms. Considering this fact, the goal of this paper is to introduce a multi-objective solution for retrieving class diagrams. This solution considers as objectives structural and semantic characteristics of models in a repository. Preliminary results with NSGA-II show that the solutions obtained by the multi-objective algorithm constitute better options to the developer than that ones based on simple GAs.}, booktitle={Proceedings - 2013 Brazilian Conference on Intelligent Systems, BRACIS 2013}, author={Assun?ão, W.K.G. and Vergilio, S.R.}, year={2013}, pages={249–255} }
 @inproceedings{assun?ão_vergilio_2013, title={Class diagram retrieval with particle swarm optimization}, volume={2013-January}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-84899440405&partnerID=MN8TOARS}, number={January}, booktitle={Proceedings of the International Conference on Software Engineering and Knowledge Engineering, SEKE}, author={Assun?ão, W.K.G. and Vergilio, S.R.}, year={2013}, pages={632–637} }
 @inproceedings{assun?ão_colanzi_vergilio_pozo_2013, title={Determining integration and test orders in the presence of modularization restrictions}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-84900324356&partnerID=MN8TOARS}, DOI={10.1109/SBES.2013.5}, abstractNote={The Integration and Test Order problem is very known in the software testing area. It is related to the determination of a test order of modules that minimizes stub creation effort, and consequently testing costs. A solution approach based on Multi-Objective and Evolutionary Algorithms (MOEAs) achieved promising results, since these algorithms allow the use of different factors and measures that can affect the stubbing process, such as number of attributes and operations to be simulated by the stub. However, works based on such approach do not consider different modularization restrictions related to the software development environment. For example, the fact that some modules can be grouped into clusters to be developed and tested by independent teams. This is a very common practice in most organizations, particularly in that ones that adopt a distributed development process. Considering this fact, this paper introduces an evolutionary and multi-objective strategy to deal with such restrictions. The strategy was implemented and evaluated with real systems and three MOEAs. The results are analysed in order to compare the algorithms performance, and to better understand the problem in the presence of modularization restrictions. We observe an impact in the costs and a more complex search, when restrictions are considered. The obtained solutions are very useful and the strategy is applicable in practice.}, booktitle={Proceedings - 2013 27th Brazilian Symposium on Software Engineering, SBES 2013}, author={Assun?ão, W.K.G. and Colanzi, T.E. and Vergilio, S.R. and Pozo, A.}, year={2013}, pages={31–40} }
 @article{colanzi_assun?ão_de freitas guilhermino trindade_zorzo_vergilio_2013, title={Evaluating different strategies for testing software product lines}, volume={29}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-84878495046&partnerID=MN8TOARS}, DOI={10.1007/s10836-012-5343-y}, number={1}, journal={Journal of Electronic Testing: Theory and Applications (JETTA)}, author={Colanzi, T.E. and Assun?ão, W.K.G. and De Freitas Guilhermino Trindade, D. and Zorzo, C.A. and Vergilio, S.R.}, year={2013}, pages={9–24} }
 @book{assun?ão_colanzi_vergilio_pozo_2013, title={On the application of the multi-evolutionary and coupling-based approach with different aspect-class integration testing strategies}, volume={8084 LNCS}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-84884959172&partnerID=MN8TOARS}, DOI={10.1007/978-3-642-39742-4_4}, journal={Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)}, author={Assun?ão, W.K.G. and Colanzi, T.E. and Vergilio, S.R. and Pozo, A.}, year={2013}, pages={19–33} }
 @article{colanzi_vergilio_guez assun?ão_pozo_2013, title={Search Based Software Engineering: Review and analysis of the field in Brazil}, volume={86}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-84875255074&partnerID=MN8TOARS}, DOI={10.1016/j.jss.2012.07.041}, number={4}, journal={Journal of Systems and Software}, author={Colanzi, T.E. and Vergilio, S.R. and Guez Assun?ão, W.K. and Pozo, A.}, year={2013}, pages={970–984} }
 @inproceedings{assun?ão_colanzi_pozo_vergilio_2011, title={Establishing integration test orders of classes with several coupling measures}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-84860389350&partnerID=MN8TOARS}, DOI={10.1145/2001576.2001827}, abstractNote={During the inter-class test, a common problem, named Class Integration and Test Order (CITO) problem, involves the determination of a test class order that minimizes stub creation effort, and consequently test costs. The approach based on Multi-Objective Evolutionary Algorithms (MOEAs) has achieved promising results because it allows the use of different factors and measures that can affect the stubbing process. Many times these factors are in conflict and usually there is no a single solution for the problem. Existing works on MOEAs present some limitations. The approach was evaluated with only two coupling measures, based on the number of attributes and methods of the stubs to be created. Other MOEAs can be explored and also other coupling measures. Considering this fact, this paper investigates the performance of two evolutionary algorithms: NSGA-II and SPEA2, for the CITO problem with four coupling measures (objectives) related to: attributes, methods, number of distinct return types and distinct parameter types. An experimental study was performed with four real systems developed in Java. The obtained results point out that the MOEAs can be efficiently used to solve this problem with several objectives, achieving solutions with balanced compromise between the measures, and of minimal effort to test.}, booktitle={Genetic and Evolutionary Computation Conference, GECCO'11}, author={Assun?ão, W.K.G. and Colanzi, T.E. and Pozo, A.T.R. and Vergilio, S.R.}, year={2011}, pages={1867–1874} }
 @inproceedings{assun?ão_de freitas guilhermino trindade_colanzi_vergilio_2011, title={Evaluating test reuse of a software product line oriented strategy}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-80052637047&partnerID=MN8TOARS}, DOI={10.1109/LATW.2011.5985891}, abstractNote={Software Product Line (SPL) test is an emergent research subject, and works found in the literature address some topics such as test process, plain and guidelines, and most recently, strategies to integrate test methods and criteria in the SPL engineering. Strategies that are SPL oriented allow reuse of test assets and were proposed as an alternative to those ones that test product by product in a separated way. However, studies conducted to evaluate the benefits of such strategies are necessary, and have not been conducted yet. Considering this fact, this paper presents results from the application of the SPL oriented strategy, named Reusable Asset Instantiation (RAI). A comparison with the strategy Product by Product is conducted, considering reuse, and test data generation based on use cases.}, booktitle={LATW 2011 - 12th IEEE Latin-American Test Workshop}, author={Assun?ão, W.K.G. and De Freitas Guilhermino Trindade, D. and Colanzi, T.E. and Vergilio, S.R.}, year={2011} }
 @book{colanzi_assun?ão_vergilio_pozo_2011, title={Integration test of classes and aspects with a multi-evolutionary and coupling-based approach}, volume={6956 LNCS}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-80052872148&partnerID=MN8TOARS}, DOI={10.1007/978-3-642-23716-4_18}, journal={Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)}, author={Colanzi, T.E. and Assun?ão, W.K.G. and Vergilio, S.R. and Pozo, A.}, year={2011}, pages={188–203} }
 @inproceedings{vergilio_colanzi_pozo_assuncao_2011, title={Search based software engineering: A review from the brazilian symposium on software engineering}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-82255166810&partnerID=MN8TOARS}, DOI={10.1109/SBES.2011.13}, abstractNote={Search Based Software Engineering (SBSE) is the field of software engineering research and practice that applies search based techniques to solve different Software Engineering problems. SBSE contributes to reduce efforts and costs associated to software development since the solutions found by search techniques satisfy constraints that are usually in conflict and, in general, are very difficult to be obtained for software engineers. The field is emerging in Brazil, the number of published works and research groups have significantly increased in the last three years. The goal of this paper is to divulge SBSE, serving as a reference to this novel field and contributing to its consolidation in Brazil. The paper introduces SBSE concerns and provides a review of works produced by the Brazilian community, related to the Brazilian Symposium on Software Engineering (SBES), discussing trends, challenges, and open research problems for this emergent area.}, booktitle={Proceedings - 25th Brazilian Symposium on Software Engineering, SBES 2011}, author={Vergilio, S.R. and Colanzi, T.E. and Pozo, A.T.R. and Assuncao, W.K.G.}, year={2011}, pages={50–55} }
 @inproceedings{colanzi_assun?ão_pozo_vendramin_pereira_2010, title={Empirical studies on application of genetic algorithms and ant colony optimization for data clustering}, url={http://www.scopus.com/inward/record.url?eid=2-s2.0-79955933361&partnerID=MN8TOARS}, DOI={10.1109/SCCC.2010.19}, abstractNote={Cluster analysis is used in several research areas to classify data sets in groups by their similar characteristics. Metaheuristic-based techniques, such as Genetic Algorithms (GAs) and Ant Colony Optimization (ACO), have been applied in order to increase the clustering algorithm performance. GA and ACO-based clustering algorithms are capable of efficiently and automatically forming natural groups from a pre-defined number of clusters. This paper presents a GA and an ACO algorithm to the clustering problem. Both algorithms were refined using local search in order to improve the clustering accuracy. The results are compared on numeric UCI databases.}, booktitle={Proceedings - International Conference of the Chilean Computer Science Society, SCCC}, author={Colanzi, T.E. and Assun?ão, W.K.G. and Pozo, A.T.R. and Vendramin, A.C.B.K. and Pereira, D.A.B.}, year={2010}, pages={1–10} }