Avaliando LLMs em Program Slicing para Java

Program slicing é uma técnica usada em engenharia de software que ajuda os desenvolvedores a focar em partes específicas do código relacionadas a tarefas determinadas. Isso é crucial para encontrar bugs, entender o código e depurar programas. Com o surgimento de grandes modelos de linguagem (LLMs), há um grande interesse em como esses LLMs podem ajudar no program slicing, especialmente em linguagens de programação populares como Java.

#O que é Program Slicing?

Program slicing isola partes do código que podem afetar o resultado de um cálculo específico. Ao identificar partes relevantes com base em critérios específicos, como uma variável ou um número de linha, os desenvolvedores conseguem entender melhor sistemas complexos e localizar problemas de forma mais eficiente. Existem dois tipos principais de program slicing:

1. Slicing Estático: Essa abordagem analisa o código sem executá-lo. Ajuda a entender a estrutura e as dependências do código, sendo útil para otimização e compreensão.

2. Slicing Dinâmico: Este método considera como um programa se comporta enquanto está rodando, capturando informações em tempo de execução. É particularmente eficaz para depuração e para resolver problemas que surgem durante a execução.

Ambas as técnicas foram estudadas e refinadas, levando a ferramentas confiáveis para muitas tarefas de slicing.

#Grandes Modelos de Linguagem em Engenharia de Software

Pesquisas recentes exploraram o uso de LLMs em várias tarefas de engenharia de software. Os LLMs podem ser usados para tarefas como teste de software, tradução de código e análise de requisitos. Esses modelos aproveitam vastas quantidades de dados para gerar texto semelhante ao humano, que também pode ser aplicado a tarefas de codificação. Apesar de seu potencial, houve uma avaliação limitada de suas capacidades em program slicing.

#Objetivos do Estudo

Este estudo tem como objetivo avaliar quão bem os LLMs podem realizar tarefas de program slicing, particularmente slicing estático e dinâmico para programas Java. Também pretende identificar as razões para falhas em slices gerados por LLMs e propor maneiras de melhorar seu desempenho.

#Metodologia

Para avaliar as capacidades dos LLMs em program slicing, realizamos vários experimentos usando um conjunto de dados de programas Java. O conjunto de dados foi retirado de problemas de codificação no LeetCode e incluiu 100 programas Java selecionados aleatoriamente. Aplicamos diferentes estratégias de prompting e comparamos os resultados dos LLMs com aqueles gerados por ferramentas tradicionais de program slicing.

#Modelos Avaliados

O estudo se concentrou em quatro LLMs de ponta:

1. GPT-4o: Projetado para lidar com tarefas complexas com Precisão superior.
2. GPT-3.5 Turbo: Conhecido por sua eficiência em gerar texto.
3. Llama-2-7B-Chat: Ajustado para aplicações conversacionais e assistência à codificação.
4. Gemma-7B: Otimizado para uma variedade de tarefas em inglês.

Cada modelo foi avaliado usando suas configurações padrão.

#Métricas de Desempenho

Para medir quão bem os LLMs se saíram, usamos duas métricas principais:

1. Exatidão de Correspondência Exata (Accuracy-EM): Isso mede o número de instâncias em que os slices previstos correspondem aos slices reais.
2. Exatidão de Dependência (Accuracy-D): Isso avalia a precisão das dependências previstas pelo modelo em comparação com as dependências reais no código.

#Resultados

#Desempenho dos LLMs em Slicing Estático

Nos nossos experimentos, o GPT-4o foi o que teve o melhor desempenho em slicing estático, alcançando uma Accuracy-D de 60,84%. O GPT-3.5 Turbo também mostrou resultados competitivos, especialmente em estratégias de prompting específicas. Em contraste, o Llama-2 consistentemente teve um desempenho mais fraco em comparação com os outros modelos.

#Desempenho dos LLMs em Slicing Dinâmico

Ao avaliar o slicing dinâmico, o GPT-4o novamente se destacou como o melhor, alcançando uma pontuação de Accuracy-D de 59,69%. No entanto, todos os modelos tiveram dificuldades para alcançar correspondências exatas, indicando que mesmo os melhores modelos tinham limitações em gerar slices de programa precisos.

#Análise de Casos Não-Sucedidos

Para entender melhor por que alguns slices não foram bem-sucedidos, fizemos uma análise detalhada dos casos em que os modelos falharam em corresponder aos slices reais. Nos concentramos em identificar padrões comuns, causas raízes e locais de falha.

#Taxonomia de Slicing de Programa Não-Sucedido

Através da análise, desenvolvemos uma taxonomia que categoriza as falhas em várias áreas-chave:

1. Falta de Compreensão Lógica: Muitos problemas surgem da incapacidade dos modelos de entender a estrutura lógica do programa, especialmente em seções que envolvem tomada de decisão e fluxo de controle.

2. Complexidade do Código: Estruturas de código complexas frequentemente sobrecarregavam os LLMs, resultando em erros na interpretação de como variáveis e instruções interagem.

3. Restrições Específicas do Modelo: Limitações inerentes ao design dos LLMs também contribuíram para erros de slicing, particularmente em casos onde o código excedia o limite de tokens do modelo ou continha conteúdo misto (como comentários).

#Locais Comuns de Falha

Identificamos seis categorias onde erros de slicing ocorriam frequentemente:

1. Instruções Condicionais: Erros costumam ocorrer quando o modelo avalia incorretamente a lógica de ramificação.

2. Estruturas de Laço: A má interpretação das condições de laço pode levar a slices imprecisos ou ausentes.

3. Chamadas e Retornos de Métodos: Dificuldade em propagar o critério de slicing através das chamadas de métodos criou imprecisões.

4. Declarações e Atribuições de Variáveis: Inicializações de variáveis ambíguas frequentemente resultavam em erros de dependência.

5. Declarações de Classe: Problemas nas definições de classes também impactaram a precisão do slicing.

6. Imports: Dificuldades em entender como bibliotecas importadas afetam o programa levaram a slices incompletos.

#Estratégias para Melhoria

Para melhorar o desempenho dos LLMs em program slicing, testamos duas estratégias principais:

1. Elaboração de Prompts Aprimorada: Refinando os prompts usados para guiar os modelos, visamos melhorar a precisão. Isso envolveu fornecer exemplos que incluíam cenários de falha comuns identificados em nossa análise. Essa estratégia resultou em um aumento significativo na precisão para vários modelos.

2. Prompting Iterativo: Essa técnica envolveu fornecer feedback aos modelos com base em seus erros anteriores. Ao guiar os modelos para evitar repetir erros específicos, essa abordagem levou a um desempenho melhorado, especialmente para o GPT-4o.

#Principais Descobertas das Estratégias de Melhoria

Ambas as estratégias mostraram que melhorias direcionadas poderiam gerar melhores resultados no slicing estático baseado em LLM. A elaboração de prompts aprimorada levou a aumentos de precisão de cerca de 4% para o GPT-4o, enquanto o prompting iterativo proporcionou uma melhoria de 3,9%.

#Conclusão

Este estudo fornece insights valiosos sobre a aplicação de LLMs em tarefas de program slicing. Embora o GPT-4o tenha demonstrado o melhor desempenho, desafios permanecem, especialmente na geração de correspondências exatas em cenários complexos. A taxonomia desenvolvida a partir da análise de casos não-sucedidos funciona como um guia para futuras pesquisas e melhorias nas técnicas de slicing baseadas em LLM.

Para futuras pesquisas, expandir a investigação para outras linguagens de programação e abordagens alternativas de elaboração de prompts poderia resultar em uma compreensão mais abrangente das capacidades dos LLMs em program slicing.

#Trabalho Futuro

No futuro, planejamos testar LLMs em mais linguagens de programação para avaliar ainda mais seu desempenho e forças. Também estamos ansiosos para experimentar com diferentes estratégias de prompting para ver o que funciona melhor na melhoria da precisão das tarefas de program slicing em vários contextos.

#Disponibilidade dos Dados

Todo o material usado neste estudo, incluindo conjuntos de dados e scripts, será disponibilizado para pesquisadores replicarem e construírem sobre nossas descobertas.