An LLM-based Technique for Detection of Code Clones Across Open Source Microservice Repository Forks

No vasto e colaborativo mundo do desenvolvimento de software, programadores frequentemente constroem novas aplicações ao pegar códigos existentes e adaptá-los para um propósito diferente. Essa prática, conhecida como forking, é o motor da inovação de código aberto, permitindo que equipes se apoiem nos ombros de gigantes em vez de começar do zero. No entanto, à medida que esses projetos crescem e se ramificam, uma complexidade oculta surge: o código dentro deles pode se tornar uma teia emaranhada de duplicatas. Algumas cópias são réplicas exatas, linha por linha, enquanto outras são versões inteligentemente reescritas que fazem a mesma coisa, mas parecem completamente diferentes na superfície. Estas são conhecidas como clones de código. Para os mantenedores de grandes sistemas de software, especialmente aqueles construídos como uma coleção de pequenos serviços independentes, encontrar essas duplicatas é uma tarefa monumental. Ferramentas tradicionais são excelentes em detectar cópias exatas, mas frequentemente falham em reconhecer quando duas partes de código foram refatoradas para realizar a mesma função de maneiras inteiramente diferentes. Compreender onde e como essas duplicatas existem é crucial, pois revela como o software evolui, onde residem os riscos de inconsistência e quanto esforço é realmente necessário para manter um sistema funcionando perfeitamente.

Uma equipe de pesquisadores recentemente se propôs a resolver esse problema testando um novo tipo de ferramenta digital: modelos de linguagem de grande escala (LLMs). Estes são os mesmos sistemas de inteligência artificial poderosos que podem escrever histórias ou responder perguntas, mas aqui eles foram treinados para entender a lógica do código de computador. Os pesquisadores queriam ver se esses modelos poderiam agir como um microscópio sofisticado, detectando não apenas códigos idênticos, mas também o código semanticamente semelhante que as ferramentas tradicionais perdem. Eles focaram sua investigação em projetos de microsserviços de código aberto, que são sistemas de software modernos construídos a partir de muitas partes pequenas e intercambiáveis. Para começar, eles precisavam ensinar esses modelos a reconhecer os diferentes tipos de clones de código. Eles reuniram um conjunto de dados massivo de dez mil pares de trechos de código C++, metade dos quais eram conhecidamente idênticos funcionalmente, mas sintaticamente diferentes, e a outra metade era não relacionada. Eles testaram três modelos de inteligência artificial diferentes, variando de um sistema de propósito geral a dois modelos especializados projetados especificamente para tarefas de codificação. Eles também experimentaram diferentes formas de pedir aos modelos para realizar a tarefa, tentando de tudo, desde instruções simples até comandos complexos que forneciam exemplos e pediam pontuações de confiança.

Os resultados deste teste inicial foram reveladores. Os pesquisadores descobriram que os modelos de codificação especializados eram muito superiores ao de propósito geral. Entre eles, um modelo chamado Codestral emergiu como o mais preciso, alcançando a maior precisão geral de 65,5% e superando tanto o outro modelo especializado quanto o sistema de propósito geral. No entanto, o estudo também revelou uma limitação significativa: mesmo o melhor modelo cometia erros. Ele frequentemente perdia as próprias duplicatas que deveria encontrar, falhando em reconhecê-las cerca de quarenta por cento das vezes. Era bom em identificar códigos que eram definitivamente diferentes, mas era cauteloso demais quando se tratava de detectar as sutilezas de semelhança. Essa alta taxa de detecções perdidas significava que, por enquanto, essas ferramentas poderosas ainda não são confiáveis o suficiente para serem usadas como o único método para gerenciar código em um ambiente profissional e automatizado. Elas são assistentes úteis, mas ainda não podem substituir o julgamento humano ou os métodos de detecção estabelecidos.

Armados com o melhor modelo e a forma mais eficaz de instruí-lo, os pesquisadores voltaram sua atenção para o mundo real. Eles selecionaram vinte e duas duplas de repositórios de microsserviços de código aberto, onde um era o projeto original e o outro era um fork que havia sido modificado por um grupo diferente de desenvolvedores. Eles alimentaram essas bases de código em seu sistema para mapear exatamente quais tipos de duplicatas existiam entre o original e o fork. As descobertas pintaram um quadro claro de como esses projetos evoluem. O tipo mais comum de duplicata que encontraram foi a cópia exata, onde o código permaneceu inalterado. O segundo mais comum foi o clone do Tipo-3, onde o código havia sido alterado com adições ou exclusões, mas manteve sua funcionalidade original. Surpreendentemente, o código completamente reescrito que faz a mesma coisa de uma maneira totalmente diferente era menos comum do que os outros tipos nesses projetos específicos. Isso sugere que, quando desenvolvedores fazem um fork de um microsserviço, eles tendem a manter a estrutura central intacta em vez de reinventar completamente a roda.

Para garantir que suas descobertas automatizadas fossem confiáveis, os pesquisadores compararam a saída do modelo contra uma revisão manual de três dos projetos por especialistas humanos. Os revisores humanos confirmaram que o modelo era geralmente correto ao identificar os tipos mais comuns de duplicatas, embora os números específicos variassem dependendo de qual tecnologia subjacente o modelo usava para ler o código. O estudo concluiu que, embora a inteligência artificial ofereça uma nova maneira promissora de entender as relações semânticas profundas entre partes de código, ela ainda não é uma solução perfeita. A tecnologia é poderosa o suficiente para ver padrões que humanos e ferramentas mais antigas podem perder, mas ainda luta com as altas consequências de perder uma duplicata inteira. Por enquanto, esses modelos servem melhor como um guia para ajudar os desenvolvedores a navegar pelo histórico complexo de seu código, em vez de uma autoridade final. O caminho a seguir envolve o refinamento dessas ferramentas para reduzir seus erros e a combinação de sua compreensão semântica com métodos tradicionais para criar uma imagem mais completa da evolução do software.