Executando verificação de segurança...
9

Pesquisador da Anthropic cria compilador de C com 16 instâncias paralelas do Claude Opus 4.6

Um pesquisador da Anthropic colocou 16 instâncias do modelo Claude Opus 4.6 para trabalhar em paralelo e, ao longo de duas semanas, elas desenvolveram do zero um compilador de C escrito em Rust, com cerca de 100 mil linhas de código. O experimento envolveu quase 2 mil sessões do Claude Code e teve um custo aproximado de 20 mil dólares em taxas de API.

O compilador foi capaz de compilar um kernel Linux 6.9 inicializável e funciona em arquiteturas x86, ARM e RISC-V. Ele também conseguiu compilar projetos de grande porte como PostgreSQL, SQLite, Redis, FFmpeg e QEMU, além de compilar e executar o jogo Doom.

Apesar dos resultados, o compilador ainda gera código menos eficiente que o GCC, o principal compilador de C. A qualidade do código é distante do nível que um programador especialista produziria, e novas correções frequentemente acabavam quebrando funcionalidades já existentes.

Além disso, o projeto dependeu fortemente da intervenção humana. O pesquisador precisou criar uma infraestrutura complexa de testes, integração contínua, validação e ciclos de feedback para evitar que os agentes resolvessem problemas incorretos ou se perdessem no contexto do desenvolvimento.

Carregando publicação patrocinada...
9

A notícia é impressionante, mas a maioria das pessoas está tirando a conclusão errada. O "milagre" não foram as 100 mil linhas de Rust geradas.

O milagre foi a "jaula" que o pesquisador construiu.

O que aconteceu foi uma mudança de paradigma no que significa ser Engenheiro de Software:

  1. O Código virou Commodity

Escrever um compilador de C sempre foi o rito de passagem de programador para "bruxo". O experimento provou que isso agora é trivial. Se os requisitos são claros, a IA cospe o código.

  1. O Engenheiro como Arquiteto de Feedback

O ponto crucial que muitos ignoram: o projeto dependeu de uma infraestrutura massiva de testes, CI/CD e ciclos de validação. O pesquisador não escreveu código; ele escreveu as regras do jogo.

Sem a "jaula" de validação, a IA teria se perdido.

O trabalho humano foi garantir que, se a IA errasse, o sistema gritasse imediatamente!

2

Escrever um compilador de C sempre foi o rito de passagem de programador para "bruxo"

sinceramente eu discordo.

C é uma linguagem extremamente simples, deve usar só umas 30 palavras na linguagem inteira.

Conheço uma pessoa que já escreveu um compilador em C e não passou para uma vaga de pleno

10

Cara, concordo plenamente que C é "simples": só 32 palavras reservadas, umas 6 regras de precedência claras e uma gramática que cabia num livrinho de 200 páginas em 1978. Agora, implementar isso corretamente é outra historia.

Caiu na armadilha clássica: confundir "linguagem pequena" com "linguagem fácil de parsear". C é context-sensitive, sua gramática formal nem é LR(1) de verdade. T * x; pode ser multiplicação ou declaração de ponteiro dependendo se T é typedef ou variável naquele escopo específico. Você precisa de symbol table funcionando durante o parsing pra decidir qual ramo da gramática seguir.

Isso é bruxaria? Não, é só engenharia de parser que 90% dos cursos de compiladores fingem que não existe.

E as declarações? C tem uma gramática de declarações que é quase Turing-complete. Consegue parsear isso aqui de primeira?

static int (*(*foo[])(int (*)(int, int)))(int, int);

Pois é, isso é um array estático de ponteiros para funções que recebem ponteiro para função que recebe dois ints e retorna int, e retornam ponteiro para função que recebe dois ints e retorna int. Você começa no foo e sai espiralando no sentido horário [] pra direita (array), * pra esquerda (ponteiro), () pra direita (função), * pra esquerda (ponteiro), () pra direita (função), int pra esquerda Nenhum gerador de parser tipo yacc ou antlr consegue lidar com isso. Então vai lá implementar isso: contexto sendo resolvido no meio do parsing, e tabelas de símbolos atualizando entre um lookahead e outro. Mas calma nem chegamos na parte mais difícil...

E o static aí? Ah, meu caro, ele decide storage duration. Mas se eu mover esse static pra fora:

static int foo(void) { static int x = 0; return ++x; }

Agora o primeiro static muda o linkage para internal (símbolo não exportado), e o segundo muda storage duration para static initialization. Mas espera, tem mais: static em parâmetro de array em C99?

void bar(int arr[static 10]);

Agora é uma promise de otimização pro compilador que o array tem pelo menos 10 elementos, permitindo vetorização agressiva. Mesma palavra, três universos semânticos completamente diferentes dependendo da posição.

E é por isso que quando Rust, Zig, Swift ou até Python precisam fazer FFI com C, ninguém escreve um parser de C do zero. Usam o parser do LLVM. Porque parsear C de verdade, o C que compila o kernel Linux, é uma das coisas mais dificeis que existem na computação.

Escrever um compilador que aceita int main(){printf("oi");} é projeto de fim de semana. Escrever um que engole mm/memory.c do kernel é bruxaria.

O amigo que "escreveu um compilador em C" provavelmente implementou uma recursive descent pra subset C89 e chamou de compilador de C. E sim, isso explica porque ele não pegou a vaga de pleno.

1

O amigo que "escreveu um compilador em C" provavelmente implementou uma recursive descent pra subset C89 e chamou de compilador de C.

Pode até ser, não cheguei a testar a fundo pra validar a ideia.

E sim, isso explica porque ele não pegou a vaga de pleno.

Ele só não tinha os requisitos para a vaga, fazer um compilador não é um diferencial.

1
1

Ler isso me brilha os olhos, nessa era de muito achismo e pouco pragmatismo e conhecimento real e implementado com exemplos.

Agradeço demais seu comentário!! S2

0
2

Esse experimento da Anthropic deixa claro é que esta cada vez mais barato escrever código. O custo pra escrever 100k linhas caiu muito, mas o custo da confiança continua altíssimo.

Os 20 mil dólares gastos não foram para 'escrever Rust', foram para 'tentar validar o que foi escrito'. Claramente o intuito aqui não foi construir um compilador em si, mas o uso desse processo como um imenso dataset de falhas. A Anthropic está minerando onde o agente 'trava' pra ensinar as próximas versões a saírem do loop de erro sozinhas. Enquanto a IA não dominar a autoavaliação, vamos continuar sendo um 'curador de feedback' pros modelos.

1
1
0
0