💻 computer science

Large Language Models for Multilingual Code Intelligence: A Survey

Esta pesquisa aborda o viés atual dos modelos de linguagem grandes em relação às linguagens de programação de alto recurso, revisando métodos, benchmarks e desafios para alcançar inteligência de código multilíngue robusta, com foco específico na geração de código entre linguagens e na tradução que preserva a semântica.

Autores originais: Chao Jiang, Dugang Liu, Cheng Wen, Zhiwu Xu, Hua Zheng, Muhammad Sadiq, Jawwad Ahmed Shamsi, Shengchao Qin, Zhong Ming

Publicado 2026-04-30

📖 6 min de leitura🧠 Leitura aprofundada

CC BY 4.0

Autores originais: Chao Jiang, Dugang Liu, Cheng Wen, Zhiwu Xu, Hua Zheng, Muhammad Sadiq, Jawwad Ahmed Shamsi, Shengchao Qin, Zhong Ming

Artigo original sob licença CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Esta é uma explicação gerada por IA do artigo abaixo. Não foi escrita nem endossada pelos autores. Para precisão técnica, consulte o artigo original. Ler aviso legal completo

Imagine que você tem um chef brilhante e onisciente (o Modelo de Linguagem de Grande Escala, ou LLM). Este chef é famoso por cozinhar pratos incríveis em inglês (como código Python). Ele consegue seguir uma receita escrita em inglês e criar uma refeição perfeita.

No entanto, o mundo não fala apenas inglês. O software do mundo real é como um grande potluck internacional onde as pessoas falam dezenas de idiomas diferentes (Rust, Java, C++, OCaml, etc.). O problema é que este chef é um pouco snob: ele é um mestre do inglês, mas tem dificuldade quando solicitado a cozinhar o mesmo prato exato em francês, alemão ou em um dialeto raro como "Rust".

Este artigo é uma pesquisa (um grande boletim de notas) sobre como estamos ensinando este chef a se tornar um verdadeiro poliglota—alguém que pode cozinhar perfeitamente em muitos idiomas.

Aqui está a divisão dos principais pontos do artigo usando analogias simples:

1. O Problema: O "Viés Monolíngue"

Atualmente, os modelos de IA são treinados principalmente com dados de idiomas populares como Python e Java. É como se o chef tivesse lido apenas livros de receitas em inglês.

O Resultado: Quando você pede ao chef para cozinhar um prato "Rust", ele pode usar as especiarias erradas, esquecer as regras de segurança ou servir uma refeição que parece certa, mas tem gosto terrível (bugs).
A Realidade: Sistemas de software reais são como uma Canivete Suíço. Eles têm um cabo feito de um material (Java), uma lâmina feita de outro (C++) e um abridor de parafusos feito de um terceiro (Rust). Se seu assistente de IA só fala um idioma, ele não pode ajudá-lo a construir ou consertar a ferramenta inteira.

2. Os Dois Trabalhos Principais

O artigo foca em duas maneiras específicas pelas quais a IA ajuda com este problema do "Canivete Suíço":

Trabalho A: O "Tradutor" (Geração de Código)
- A Analogia: Você dá ao chef uma descrição em inglês simples: "Preciso de um carro que dirija rápido."
- A Tarefa: O chef deve construir aquele carro em três idiomas diferentes ao mesmo tempo: um carro de madeira (Python), um carro de aço (C++) e um carro de vidro (Rust).
- O Desafio: O carro deve dirigir da mesma maneira nos três, mesmo que madeira, aço e vidro se comportem de forma muito diferente. A IA frequentemente luta para tornar o "carro de vidro" seguro e funcional.
Trabalho B: O "Renovador" (Tradução de Código)
- A Analogia: Você tem uma casa de madeira velha e rangente (código legado C/C++) que está cheia de buracos e insegura. Você quer mudar a família para uma casa moderna e à prova de fogo de aço (Rust).
- A Tarefa: A IA deve mover os móveis e a família (a lógica) da casa antiga para a nova sem perder nada ou mudar como a família vive.
- O Desafio: Não é apenas mover caixas; é reconstruir a fundação para que a casa se mantenha de pé em um novo mundo. Se a IA perder um detalhe, a família (o programa) pode cair pelo chão.

3. Como Estamos Ensinando o Chef? (Os Métodos)

O artigo revisa quatro maneiras principais pelas quais os pesquisadores estão tentando corrigir as habilidades linguísticas do chef:

O Truque do "Prompt" (Engenharia de Prompt):
- Analogia: Você não re-treina o chef; você apenas dá a ele uma nota muito específica e detalhada no pedido. "Por favor, lembre-se, em Rust, você deve usar óculos de proteção!"
- Prós/Contras: É barato e rápido, mas se o chef já não conhecer o idioma, uma nota não ajudará muito.
O Método da "Escola" (Pré-treinamento e Ajuste Fino):
- Analogia: Você manda o chef de volta para a escola de culinária para estudar livros de receitas em francês e alemão por meses.
- Prós/Contras: Isso o torna um verdadeiro especialista, mas é caro e leva muito tempo. Além disso, há muito poucos livros de receitas para idiomas raros, então ele pode ainda ficar confuso.
O Método da "Equipe" (Frameworks Multi-Agente):
- Analogia: Em vez de um chef, você contrata uma equipe. Um chef escreve a receita, um segundo chef verifica a gramática, um terceiro chef testa se a comida queima e um quarto chef corrige erros.
- Prós/Contras: Isso é ótimo para trabalhos complexos porque eles pegam os erros uns dos outros, mas leva mais tempo e coordenação.
O Método da "Biblioteca" (RAG):
- Analogia: O chef tem permissão para caminhar até a biblioteca e procurar as regras específicas para "cozinha Rust" enquanto está cozinhando.
- Prós/Contras: Isso garante que ele tenha as regras mais recentes e precisas, mas ele precisa saber como encontrar o livro certo rapidamente.

4. Como Nós Avaliamos o Chef? (Avaliação)

Testar uma IA que escreve código é mais difícil do que testar uma que escreve poemas.

O Teste "Aprovado/Reprovado": Na poesia, se um poema soa bem, é bom. No código, se a matemática estiver errada por uma casa decimal, todo o programa trava.
O Problema: É difícil testar se um carro "Rust" dirige da mesma forma que um carro "Python" porque eles rodam em motores diferentes. O artigo observa que precisamos de melhores maneiras de verificar se o significado permaneceu o mesmo, e não apenas se as palavras parecem semelhantes.
A Tendência: Estamos passando de testar frases únicas (trechos) para testar edifícios inteiros (projetos de software completos), o que é muito mais difícil.

5. A Conclusão

O artigo conclui que, embora a IA esteja ficando melhor em falar muitos idiomas de programação, ainda tem um longo caminho a percorrer.

Atualmente, ela é tendenciosa para idiomas populares.
Ela luta para manter o "significado" do código seguro ao mudar de idioma.
Precisamos de melhores testes para garantir que a IA não esteja apenas chutando.

Em resumo: Estamos tentando transformar um gênio de um único idioma em um verdadeiro cidadão global que pode construir, traduzir e corrigir software em qualquer idioma, de forma segura e correta. Estamos chegando lá, mas o "Canivete Suíço" ainda está um pouco instável.

1. Declaração do Problema

O artigo aborda uma lacuna crítica na engenharia de software assistida por IA atual: o "viés monolíngue" dos Modelos de Linguagem de Grande Escala (LLMs). Embora os modelos mais avançados (por exemplo, GPT-5, DeepSeek, Qwen3) exibam proficiência próxima à humana em linguagens de alto recurso como Python e Java, seu desempenho degrada-se significativamente em linguagens de nível de sistema, funcionais ou de baixo recurso (por exemplo, Rust, OCaml, C/C++, Lua).

Essa disparidade cria um gargalo porque os sistemas de software do mundo real são inerentemente poliglotas, combinando frequentemente múltiplas linguagens dentro de uma única pilha (por exemplo, Java para serviços, C++ para kernels, Rust para segurança de memória). A pesquisa atual falha em fornecer inteligência de código multilíngue robusta, lutando especificamente com:

Generalização cross-paradigma: Adaptar lógica de um paradigma de linguagem para outro (por exemplo, orientado a objetos para funcional).
Preservação semântica: Garantir que o código traduzido ou gerado se comporte de forma idêntica em diferentes linguagens com modelos de memória e sistemas de tipos distintos.
Assimetria de avaliação: A falta de benchmarks padronizados que levem em conta as restrições únicas de compilação, vinculação e tempo de execução de linguagens diversas.

2. Tarefas Centrais Formalizadas

A revisão organiza o campo em torno de dois pilares complementares:

Geração de Código Multilíngue ( $F_{gen}: NL \to \{PL_1, \dots, PL_n\}$ ):
- Objetivo: Sintetizar código-fonte funcional a partir de requisitos em linguagem natural (NL) em uma ou mais linguagens-alvo.
- Desafio: Mapear a intenção humana abstrata para restrições sintáticas e idiomáticas específicas de diversas linguagens simultaneamente.
- Caso de Uso: Prototipagem rápida onde um único algoritmo deve ser implementado em Python (para testes) e Rust/C++ (para produção).
Tradução de Código Multilíngue ( $F_{trans}: PL_{fonte} \to PL_{alvo}$ ):
- Objetivo: Converter código-fonte existente de uma linguagem fonte para uma linguagem alvo, preservando a semântica.
- Desafio: Alcançar equivalência semântica apesar de paradigmas de programação divergentes (por exemplo, gerenciamento manual de memória em C versus propriedade em Rust).
- Caso de Uso: Modernização de código legado (C/C++ para Rust por segurança) ou portabilidade cross-platform (C++ Desktop para Java/Kotlin Android).

3. Paisagem Metodológica

Os autores categorizam as abordagens existentes em quatro paradigmas, argumentando que são complementares e não mutuamente exclusivos:

Engenharia de Prompt:
- Mecanismo: Utiliza LLMs congelados com prompts de zero-shot ou few-shot, aprendizado em contexto e andaimes estruturais.
- Técnicas: Inclui "NL no Meio" (usando linguagem natural como pivô), geração de "Pseudocódigo" para desacoplar lógica de sintaxe e traduções intermediárias transitivas.
- Limitação: Limitado pela distribuição de pré-treinamento do modelo; luta com mudanças semânticas profundas em linguagens de baixo recurso.
Pré-treinamento e Ajuste Fino de Modelos:
- Mecanismo: Internaliza a competência multilíngue modificando parâmetros do modelo via coleta massiva de dados ou geração sintética.
- Técnicas: Utilização de Representações Intermediárias (IR) de compiladores como pontes agnósticas de linguagem (por exemplo, IRCoder) e Instrução Sintética de Código Aberto (OSS-Instruct).
- Limitação: Escassez e qualidade de dados permanecem gargalos para linguagens de baixo recurso; alto custo computacional.
Frameworks Colaborativos Multi-Agente:
- Mecanismo: Decompõe tarefas complexas em ciclos iterativos envolvendo agentes especializados (por exemplo, planejador, codificador, validador).
- Técnicas: Simula fluxos de trabalho de engenharia de software (por exemplo, loops de "validar e reparar") para lidar com dependências entre arquivos e configurações de build (por exemplo, RepoTransAgent, MatchFixAgent).
- Vantagem: Fornece robustez para tarefas em nível de repositório e linguagens de cauda longa, aproveitando loops de feedback.
Geração Aumentada por Recuperação (RAG):
- Mecanismo: Injeta conhecimento externo e específico de linguagem (bibliotecas, APIs, dependências) no contexto de inferência.
- Técnicas: Recuperação de definições de classes, dependências ou pares de código paralelos de corpora para fundamentar o modelo.
- Vantagem: Mitiga alucinações em linguagens especializadas ou emergentes, fornecendo contexto consciente do projeto.

4. Práticas de Avaliação e Benchmarks

O artigo destaca que a avaliação multilíngue é fundamentalmente mais difícil que a avaliação monolíngue devido à relatividade semântica (o comportamento pode diferir ligeiramente entre linguagens) e assimetria ambiental (as cadeias de ferramentas variam).

Métricas:
- Baseadas em Execução: Pass@k (probabilidade de passar em testes unitários) e Precisão Computacional (CA) (correspondência exata de entrada-saída). Estas são o padrão-ouro para correção funcional.
- Semânticas/Textuais: CodeBLEU e LLM-como-Juiz. Este último está ganhando tração para avaliar legibilidade, manutenibilidade e adesão a instruções complexas onde métricas estáticas falham.
Benchmarks Chave:
- Geração: mHumanEval (200+ linguagens), HumanEval-XL, PSEUDOEVAL.
- Tradução: RepoTransBench (nível de repositório), XLCoST, CodeTransOcean (45 linguagens), G-TransEval.
- Tendência: Os benchmarks estão evoluindo de snippets isolados para complexidade em nível de repositório, exigindo raciocínio sobre dependências entre arquivos e sistemas de build.

5. Contribuições Principais

Taxonomia de Métodos: Uma classificação estruturada de abordagens de inteligência de código multilíngue (Prompting, Ajuste Fino, Multi-Agente, RAG) com uma análise comparativa de seus pontos fortes e modos de falha.
Formalização de Tarefas: Definições matemáticas claras que distinguem entre Geração (intenção-para-código) e Tradução (código-para-código), enfatizando os desafios únicos da preservação semântica.
Revisão Abrangente de Benchmarks: Uma revisão crítica de mais de 15 conjuntos de dados, analisando sua evolução desde a correspondência lexical até a verificação baseada em execução e complexidade em nível de repositório.
Identificação de Lacunas: Destaca o problema da "cauda longa" onde benchmarks acadêmicos falham em capturar a complexidade de bibliotecas específicas de domínio e sistemas legados encontrados na indústria.

6. Resultados e Descobertas

Disparidade de Desempenho: Existem lacunas significativas entre linguagens de alto recurso (Python) e de baixo recurso (Rust, OCaml), mesmo em modelos de ponta.
Assimetria Direcional: A tradução é frequentemente mais difícil ao mover para sistemas de tipos mais estritos (por exemplo, C para Rust) do que para sistemas flexíveis (por exemplo, Rust para Python).
Necessidade Híbrida: Nenhum paradigma único resolve o problema. As abordagens mais eficazes combinam competência em nível de parâmetro (ajuste fino) com raciocínio estruturado (multi-agente) e fundamentação externa (RAG).
Gargalo de Implementação: Para linguagens de baixo recurso, a barreira primária não é mais apenas a compreensão semântica, mas o domínio de detalhes de implementação precisos, de baixo nível e idiossincrasias.

7. Significado

Esta revisão fornece um roteiro fundamental para a próxima geração de sistemas de codificação poliglota confiáveis. Desloca o foco de meramente gerar código em linguagens populares para habilitar generalização cross-linguagem robusta, o que é essencial para:

Modernização de Software: Migrar com segurança sistemas legados para linguagens seguras em relação à memória.
Desenvolvimento Cross-Platform: Habilitar fluxos de trabalho "escreva uma vez, gere em todo lugar".
Confiabilidade Industrial: Reduzir o risco de erros semânticos em infraestrutura crítica que depende de pilhas de linguagens mistas.

Os autores concluem que alcançar verdadeira inteligência de código multilíngue requer uma abordagem holística que aborde o desequilíbrio de dados, melhore o rigor da avaliação e aproveite arquiteturas de IA colaborativas para lidar com a complexidade da engenharia de software do mundo real.