Revendo código com GPT-4o, novo LLM ‘Omni’ da OpenAI

Esta semana a OpenAI nos deu acesso ao GPT-4o (“o” para “omni”), que visa competir melhor em reconhecimento de fala e conversação. É quase certamente um LLM mais forte também. Mas ele pode fazer uma revisão de código? Fiz alguns testes para descobrir.

Para começar, verifiquei se era possível fazer multiplicações longas:

Isso está correto, como você pode confirmar em qualquer calculadora online. Observe que ele não tenta “trabalhar” o resultado para você – apenas o passa para uma calculadora. O ícone “visualizar análise” no final basicamente confirma isso. Finalmente! Isso não funcionou em modelos anteriores.

Não tenho interesse pessoal em revisões formais de código. Sim, às vezes um desenvolvedor júnior pode realmente exigir um, mas testes de unidade e sessões de emparelhamento geralmente serão suficientes para eliminar práticas inadequadas de código. Mas alguns comentários murmurados podem ajudar a indicar um leve desconforto com o código, sem parecer que estão impondo algum tipo de ordem autoritária sobre trechos facilmente reescrevíveis. Resumindo, uma revisão de código é mais uma interação social do que qualquer outra coisa. Concentre-se em questões de engenharia, não no detalhamento semântico do código.

No entanto, as revisões de código são um bom caso de uso de LLM para desenvolvedores. Aqui examinarei três partes diferentes de código, cada uma delas simplesmente desenhando uma caixa com uma linha diagonal. Adicionarei problemas e verei como o GPT-4o (via ChatGPT) os analisa.

Aqui começamos com nossa rotina simples de linha diagonal em C#:

using System; 

public class Program 
{ 
  public static void Main() 
  { 
    BoxWithDiagonalLine(5); 
    BoxWithDiagonalLine(6,1); 
    BoxWithDiagonalLine(6,-1); 
    BoxWithDiagonalLine(2); 
    BoxWithDiagonalLine(-1); 
  } 

  // Example 1
  public static void BoxWithDiagonalLine(int boxsize, int linepos = 0) 
  { 
    for(int i=0; i < boxsize; i++) 
    { 
      for (int j = 0; j < boxsize; j++) 
      { 
        if (j == linepos) Console.Write("x "); 
        else Console.Write("o "); 
      } 
      linepos++; 
      Console.Write("n"); 
    } 
    Console.Write("n"); 
  } 
}

Você pode colocar isso em https://dotnetfiddle.net/ (definir o compilador para .NET 6, pelo menos) e ver as respostas:

Isso é bastante simples e relativamente autoexplicativo. Um loop externo controla as linhas, um loop interno coloca o “x” no lugar certo. A nomenclatura da variável é mínima, mas o código é curto. Existe um valor padrão para o método fornecer uma linha diagonal completa do canto superior esquerdo ao canto inferior direito. Embora possamos mover a posição da linha inicial para a esquerda ou para a direita, não faz muito sentido ter um tamanho de caixa negativo. Portanto, poderíamos melhorá-lo transformando o parâmetro do método em um unsigned int. Isso impediria imediatamente a compilação do último exemplo. Linhas muito grandes não serão visíveis, mas não são perigosas.

Até agora, há pouco o que comentar.

No segundo exemplo, substituirei o for laços com while rotações:

// Example 2 
public static void BoxWithDiagonalLine(int boxsize, int linepos = 0) 
{ 
  int i = 0; 
  while(i++ < boxsize) 
  { 
    int j = 0; 
    while (j++ < boxsize) 
    { 
      if (j == linepos + 1) Console.Write("x "); 
        else Console.Write("o "); 
    } linepos++; 
    Console.Write("n"); 
  } 
  Console.Write("n"); 
}

Agora isso funciona, mas merece um leve levantamento de sobrancelha. Ao pós-incrementar as variáveis ​​do loop (o ++ depois de eu e j significa que os valores são lidos primeiro antes de serem aumentados em um) economizamos algum espaço, mas precisamos disso desajeitadamente linepos + 1 expressão. A whilenão expressa o estado inicial e final tão bem quanto um for loop sim – mas não estamos caindo em nenhuma loucura.

Fizemos uma última mudança. Agora temos uma variação que faz a coisa errada. Ele tenta usar e-mailspara controlar o loop externo:

//Example 3 
public static void BoxWithDiagonalLine(int boxsize, int linepos = 0) 
{ 
  while(linepos < boxsize) 
  { 
    int j = 0; 
    while (j++ < boxsize) 
    { 
      if (j == linepos + 1) Console.Write("x "); 
        else Console.Write("o "); 
    } 
    linepos++; 
    Console.Write("n"); 
  } 
  Console.Write("n"); 
}

Em uma tentativa desnecessária de remover uma variável de loop, a caixa em si não estará mais completa — embora funcione com o valor padrão. Na verdade, isso resolve um problema diferente, sempre finalizando de forma confiável com uma cruz no canto inferior.

Este código pobre provavelmente poderia ter surgido porque o desenvolvedor continuou a usar um while inapropriadamente.

Então, vamos resumir a maneira como podemos analisar as diferentes versões:

• O primeiro exemplo está bom, mas poderíamos forçar o parâmetro a ser positivo. Embora não esteja claro o que o código faz sem comentários.
• O segundo usa um while loop, que não tem exatamente a certeza de um for laço. Também é uma expressão feia levar em conta o pós-incremento.
• O terceiro exemplo está totalmente errado, embora obtenha o resultado correto no caso padrão

O que esperamos de um Revisão de código de IA? Em primeiro lugar, não fiz comentários, então funcionará o que o código faz? Apenas o nome do método revela isso.

Aqui está a resposta do GPT-4o:

“Seu código é funcional e gera efetivamente uma caixa com linhas diagonais com base nos parâmetros fornecidos. No entanto, existem algumas melhorias e casos extremos a serem considerados:

1. Validação de entrada: Certifique-se de que o tamanho da caixa seja positivo e maior que 1, pois uma caixa com tamanho menor que 2 não faz muito sentido.
2. Manuseio linepos: Melhore o manuseio das posições diagonais para garantir que as diagonais sejam desenhadas corretamente quando linepos é negativo ou maior que o tamanho da caixa.
3. Legibilidade do código: adicione comentários e melhore a nomenclatura de variáveis ​​para melhor legibilidade e manutenção.”

Então ele entendeu o que o código fazia – mesmo que pensasse que o programa desenhava “linhas” e não uma “linha”. Isso ainda é muito bom.

O código sugerido foi o seguinte:

// ChatGPT4o suggested code 
public static void BoxWithDiagonalLine(int boxSize, int linePos = 0) 
{ 
  if (boxSize < 2) 
  { 
    Console.WriteLine("Box size must be greater than 1."); 
    return; 
  } 

  // Adjust linePos if it's out of the box boundaries 
  if (linePos < 0) linePos = 0; 
  if (linePos >= boxSize) linePos = boxSize - 1; 
  for (int i = 0; i < boxSize; i++) 
  { 
    for (int j = 0; j < boxSize; j++) 
    { 
      if (j == linePos) Console.Write("x "); 
        else Console.Write("o "); 
    } 
    linePos++; 

    // Reset linePos if it goes out of the box boundaries 
    if (linePos >= boxSize) linePos = 0; 
    Console.Write("n"); 
 } 
 Console.Write("n"); 
}

Aqui estão os resultados de colocar isso em dotnetfiddle.net:

Acho que a maioria das pessoas ficaria feliz com o tamanho menor que dois guardas. Ele também encaixou bem os parâmetros, pois isso é adequado para C#. Infelizmente, perdeu a ideia de mudar a posição para permitir que a linha começasse mais abaixo. E ao redefinir o e-mailsobtemos aquele erro infeliz na parte inferior do segundo exemplo.

No entanto, como uma revisão de código, atingiu a nota certa.

Mais exemplos

Vamos alimentá-lo com o segundo exemplo e ver como funciona. Deixe-me escolher os comentários interessantes:

“O uso de while loops é funcional, mas pode ser menos intuitivo em comparação com for loops para tais iterações.”

Excelente. Esta é exatamente a nota certa.

“A condição j == linepos + 1 é usado para determinar onde colocar “x”. Isso funciona, mas pode ser mais intuitivo alinhando-se com o índice i.”

Novamente, isso é bom. Ele entende a diferença entre funcionalidade e legibilidade.

O código produzido limitou o valor de e-mails, e estranhamente usou a função módulo para alterar o valor. Mas acabou com o mesmo resultado. Ele voltou a for loops, o que é excelente.

Finalmente, vamos entregar o Exemplo 3 ruim e ver como ele funciona. Estranhamente, não detectou o bug, mas sugeriu o seguinte:

“Casos extremos:

– Quando linepos é negativo, funciona, mas pode não ser pretendido.”

Isso é uma indicação de que ele não entendeu bem o código — embora, novamente, eu nunca tenha declarado explicitamente o que estava fazendo. Então, talvez uma linha de embrulho tenha sido um palpite razoável?

Conclusão

No geral, fiquei bastante impressionado com a natureza e a entrega da revisão. O código produzido pelo GPT-4o foi menos promissor, mas funcionou bem. Não houve “grandes passos de nerdismo” nas críticas ao código; em vez disso, gentilmente empurrou o leitor em uma direção melhor.

Talvez não fosse aqui que eu esperava chegar – com uma boa atitude, mas com um código um pouco impreciso. No entanto, eu ficaria feliz em permitir que esta revisão fosse vista por um novato nervoso; nesse aspecto, ele faz um trabalho um pouco melhor do que alguns humanos.

A postagem Revisando código com GPT-4o, o novo LLM ‘Omni’ da OpenAI apareceu pela primeira vez em The New Stack.