Defesa de Proposta de Tese de Doutorado de André Lúcio de Oliveira, em 09/04/24, às 14:00h, na sala 310 do Instituto de Computação e por videoconferência
Link para defesa: https://meet.google.com/fhs-uiih-nsi
Do Code Refactorings Influence the Merge Effort?
Resumo:
No desenvolvimento colaborativo de software, diversos contribuidores alteram frequentemente o código-fonte em paralelo, com objetivo de implementar novos recursos, corrigir bugs, refatorar o código existente e fazer outras alterações. Essas alterações simultâneas devem ser incorporadas na mesma versão do código-fonte. No entanto, esta operação de mesclagem (merge) pode falhar e será necessária a intervenção do desenvolvedor para resolver os conflitos. Estudos na literatura mostram que 10 a 20 por cento de todas as tentativas de merge resultam em conflitos, as quais exigem a intervenção manual do desenvolvedor para concluir o processo. Vários tipos de alterações podem ser implementadas nos ramos (branches) de um commit de merge e serem a causa dos conflitos gerados. Dentre esses tipos, destacam-se as refatorações de código. Esse tipo de mudança é uma transformação de código que aprimora a estrutura interna do código, buscando melhorar o design de uma base de código existente, sem alterar o seu comportamento. Foram identificados alguns trabalhos na literatura que estudam a relação entre refatoração e merge de código. Na maioria deles, o objetivo foi analisar a influência de um número limitado de refatorações nas regiões de conflitos do merge. Entretanto, não encontramos nenhuma pesquisa considerando um conjunto mais amplo de refatorações de código, ou ainda o esforço necessário para resolver estes conflitos. A proposta deste trabalho é analisar a relação entre a ocorrência de refatorações e o esforço de merge. Nós visamos responder três macro questões de pesquisa neste estudo: RQ1) Como as refatorações influenciam o esforço de merge? RQ2) Como os tipos de refatoração influenciam o esforço de merge? e RQ3) Como os atributos contextuais de um repositório de software interferem nos achados anteriores? Para respondê-las, foram projetados experimentos quantitativos e qualitativos. Os experimentos quantitativos serão realizados em 70 repositórios de código aberto e 11 repositórios privados, que foram cuidadosamente selecionados. Nestes experimentos busca-se: i) identificar a implementação de refatorações nos ramos de um merge commit. ii) calcular o esforço, em quantidade de linhas de código (code churn), necessário para resolver conflitos de merge. iii) executar algoritmos de mineração de dados para analisar a influência das refatorações no esforço de merge e a intensidade desse relacionamento. Para complementar os resultados dos nossos experimentos quantitativos, propomos uma triangulação com os resultados dos experimentos qualitativos. Através de questionários e entrevistas com profissionais da indústria de software, busca-se melhor compreender os resultados quantitativos, o que contribuirá para responder às questões de pesquisa levantadas neste estudo. Os nossos resultados preliminares são promissores. Conseguimos observar que i) a ocorrência de refatorações aumenta em 24% as chances de haver esforço de merge; ii) quanto mais refatorações, maiores serão as chances de esforço de merge; Por exemplo, para merges com centenas ou mais refatorações nos seus ramos, as chances de haver esforço aumenta em 143%. iii) quanto mais refatorações, maior será o esforço de merge. Percebemos que, para merge com centenas ou mais refatorações nos seus ramos, as chances de ter centenas ou mais linhas de código alteradas durante o merge aumentaram em 232%. e iv) refatorações paralelas aumentam ainda mais as chances de haver esforço, bem como a intensidade do mesmo. Neste caso, as chances de haver esforço aumentam em 114%. Da mesma forma, quando há muitas refatorações (centenas ou mais) em ambos os ramos, esse percentual de haver esforço é ainda maior: 308%. Neste cenário, com muitas refatorações, observamos também um aumento de 751% nas chances da intensidade do esforço ser elevada. Os resultados podem sugerir mudanças comportamentais na forma como as equipes de desenvolvedores implementam refatorações. Além disso, podem indicar possíveis caminhos para melhorar as ferramentas que suportam merge de código e aquelas que recomendam refatorações, considerando o número de refatorações e os atributos do esforço de merge.
Abstract:
In collaborative software development, multiple contributors frequently change the source code in parallel to implement new features, fix bugs, refactor existing code, and make other changes. These simultaneous changes must be merged into the same source code version. However, the merge operation can fail, and developer intervention is required to resolve the conflicts. Studies in the literature show that 10 to 20 percent of all merge attempts result in conflicts, which require the manual developer’s intervention to complete the process. Various types of changes can be implemented in the branches of a merge commit and be the cause of conflicts generated. Among these types, we can highlight code refactorings. This kind of change is a code transformation that enhances the internal code structure, which seeks to improve the design of an existing code base without changing its behavior. We identified a few works in the literature that study the relationship between refactoring and code merging. In most of them, the objective was to analyze the influence of a limited number of refactorings in the regions of merge conflicts. However, we did not find any research considering a broader set of code refactorings or the effort required to resolve merge conflicts. In this work, we propose to analyze the relationship between the occurrence of refactorings and the merge effort. We aim to answer three macro research questions: RQ1) How do refactorings influence the merge effort? RQ2) How do refactoring types influence the merge effort? and RQ3) How do the contextual attributes of a software repository interfere with previous findings? To answer them, we design quantitative and qualitative experiments. The quantitative experiments will be carried out in 70 open-source repositories and 11 private repositories, which were carefully selected. In these experiments, we seek to: i) identify the implementation of refactorings in the branches of a merge commit; ii) calculate the effort, in code churn, necessary to resolve merge conflicts; iii) run data mining algorithms to analyze the influence of refactorings and merge effort and the intensity of this relationship. To complement the findings of our quantitative experiments, we propose a triangulation with the results of qualitative experiments. Through questionnaires and interviews with software industry professionals, we will seek to understand better the quantitative results, which will contribute to answering the research questions raised in this study. Our preliminary results are promising. We observed that i) the occurrence of refactorings increases by 24% the chances of having merge effort; ii) the more refactorings, the greater the chances of merge effort; For instance, for merges with hundreds or more refactorings, the chances of having effort increase by 143%. iii) the more refactorings, the greater the merge effort. We noticed that, for merges with hundreds or more refactorings, the chances of having hundreds or more lines of code changed during merge increased by 232%. and iv) parallel refactorings increase even more the chances of having effort, as well as the intensity of it. In this case, the chances of having effort increase by 114%. Likewise, when there are many refactorings (hundreds or more) in both branches, this percentage of having effort is even higher: 308%. In this scenario, with many refactorings, we also observed a 751% increase in the chances of the effort intensity being high. The results may suggest behavioral changes in how developer teams implement refactorings. In addition, they can indicate possible ways to improve tools that support code merging and those that recommend refactorings, considering the number of refactorings and merge effort attributes.
Banca examinadora:
Prof. Leonardo Gresta Paulino Murta, UFF – Presidente
Prof. Alexandre Plastino de Carvalho, UFF
Profa. Vânia de Oliveira Neves, UFF
Prof. José Viterbo Filho, UFF
Prof. Márcio de Medeiros Ribeiro, UFAL