A Vercel criou uma linguagem de programação

PortuguêsالعربيةDeutschEnglishEspañolFrançaisहिन्दीBahasa Indonesia日本語한국어Русский中文
BBetter Stack
컴퓨터/소프트웨어AI/미래기술

Transcript

00:00:00A Vassal acabou de lançar uma nova linguagem de programação chamada Xero, e supostamente o que a
00:00:03torna diferente é que ela foi construída do zero para que humanos e agentes de IA
00:00:07possam criar pequenos programas nativos juntos. Mas não é isso que todos nós já estamos fazendo de qualquer forma?
00:00:12Então, o que torna esta melhor, e será que é realmente uma boa ideia, ou é apenas mais um projeto paralelo
00:00:16do qual ninguém vai falar daqui a alguns meses? Vamos descobrir.
00:00:25O Xero é uma linguagem de sistemas como Rust ou Zig, então talvez algo com que o BUN possa ser reescrito um dia.
00:00:30E, pelo que percebi, a ideia principal é que as linguagens atuais foram feitas para humanos.
00:00:34Nós lemos as mensagens de erro, os avisos e os traces, mas a IA funciona muito melhor quando tem
00:00:38dados estruturados. Por isso, com o Xero, todo o toolchain foi construído com isso em mente,
00:00:43o que significa que tudo o que o compilador produz pode ser gerado como JSON.
00:00:46Agora, baseando-me apenas nesses pontos e nas frases obviamente escritas por IA neste site,
00:00:51ainda estou bastante cético sobre o porquê de isto existir e o quão bem vai funcionar,
00:00:56mas vou guardar as minhas opiniões para o fim. Primeiro, vamos explorar a linguagem em si,
00:00:59porque, convenhamos, ainda é bem legal. Vamos começar com o clássico projeto de
00:01:03"estou aprendendo uma nova linguagem", exibindo uma string bem simples. A maior parte é bem fácil de entender.
00:01:08Temos uma função principal pública como ponto de entrada do programa. Esta função vai retornar
00:01:12void, e aqui dentro estamos exibindo uma string. Mas é a forma como essa string é
00:01:16exibida que destaca as nossas primeiras funcionalidades. Estamos usando a capability "world".
00:01:21Você precisa dela para qualquer operação de E/S, como operações de arquivo, exibição de texto, chamadas de rede,
00:01:26qualquer efeito colateral de E/S, e tudo faz parte do princípio explícito desta linguagem.
00:01:31Se uma função tem esta capability "world", é um sinal imediato de que ela faz operações de E/S,
00:01:37e se não tiver, significa que estará livre de efeitos colaterais de E/S.
00:01:40A capability "world" também permite ao compilador rejeitar capabilities indisponíveis com base no
00:01:45alvo em tempo de compilação em vez de execução, então se você tentar acessar o sistema de arquivos
00:01:50dentro desta função e depois tentar compilar para WebAssembly, o compilador vai dar erro antes,
00:01:54para você não ser surpreendido por um erro em tempo de execução mais tarde.
00:01:57Depois da capability "world", neste programa também temos algumas palavras-chave.
00:02:00Temos o "check" aqui, que é como você trata erros. Se uma função puder falhar,
00:02:05você a marca com "raises", e então o "check" é usado para propagar esse erro. É bem parecido
00:02:09com o operador de interrogação do Rust, mas apenas como uma palavra-chave. Então isso é tudo o que precisamos saber
00:02:13para o nosso primeiro programa em Xero, e podemos rodá-lo agora digitando "xero run hello.xero".
00:02:19Note que esta é a extensão de arquivo para a linguagem Xero. Se eu der enter agora,
00:02:23vocês podem ver que diz "hello, subscribe to Betastack". Algo que você definitivamente deveria fazer.
00:02:26Avançando além do nosso programa "hello", já que claramente somos todos especialistas em Xero agora,
00:02:30a linguagem tem mais algumas primitivas para dar conta das suas aplicações básicas.
00:02:34Criei um novo aqui que é apenas um app aleatório que vai classificar se a entrada é texto,
00:02:39numérica ou mista, e dá para ver que ele usa alguns recursos como bibliotecas padrão,
00:02:43temos enums aqui, temos "shapes", que são bem parecidos com structs, e depois temos as
00:02:47funcionalidades habituais que você esperaria, como condicionais "if", temos um bloco "while" aqui embaixo, você também
00:02:52pode usar loops "for", e também temos o "match" aqui embaixo, que é basicamente o seu comando "switch".
00:02:56Portanto, nada de muito inesperado ou novo. Quando se trata de conceitos mais avançados como memória, novamente com o Xero
00:03:00tudo deve ser explícito. Temos "mutable spans" para as nossas views de escrita e também há "spans"
00:03:05para as views de leitura, e aqui embaixo temos um tipo "owned". Isso basicamente diz que este valor é
00:03:10propriedade daqui e, quando sair do escopo, execute a função "drop". Nós mesmos definimos a função "drop"
00:03:14no "shape" aqui, então é onde colocaríamos a nossa lógica de limpeza. Outra forma de
00:03:18fazer isso é usando a palavra-chave "defer" e depois colocando uma função ali. Basicamente o que isso
00:03:22significa é: quando esta função terminar e sair do escopo, execute esta outra função depois. Então ela
00:03:26basicamente tem tudo o que você precisa para uma aplicação bem básica hoje, e há mais alguns recursos,
00:03:31mas eu não quero que isto seja um tutorial de programação, mas sinta-se à vontade para colocar que você tem
00:03:35três minutos de experiência em Xero no seu currículo. Com tudo isso esclarecido, vamos focar no que
00:03:39eu acho que é a verdadeira proposta do Xero, que é o seu toolchain e o fato de ter sido feito para agentes de IA.
00:03:44Imagine que um agente de IA escreve um código em Xero e introduz alguns bugs. Bem, eles afirmam que,
00:03:49na maioria das linguagens, você só receberia de volta uma parede de texto, e essas mensagens de erro são feitas
00:03:54para humanos lerem. No Xero, você pode receber a versão legível por humanos e ela vai se parecer
00:03:58com algo assim, mas você pode ver que isso não é uma saída estruturada. Por isso, eles garantiram que,
00:04:02em cada parte do toolchain, haja uma opção JSON. Se rodarmos essa mesma função de novo, mas
00:04:07desta vez usando a opção JSON e também direcionando isso para o JQ só para ficar um pouco mais bonito,
00:04:12vocês podem ver que recebemos uma mensagem de erro com uma saída estruturada bem legal. Temos diagnósticos aqui como a
00:04:16severidade, o código e a mensagem. Temos onde o erro está ocorrendo, seu valor esperado e seu
00:04:21valor real. Depois temos alguma ajuda para o próprio LLM, bem como um campo de segurança de correção que
00:04:26diz que isso vai exigir revisão humana e algumas informações sobre como isso pode ser reparado. Então
00:04:31ele está apenas tentando dar contexto suficiente ao LLM para que ele possa corrigir por si mesmo. Outro comando que mostra
00:04:35muito bem isso é o "xero fix". Este eu estou usando com o modo plan, bem como JSON, e também
00:04:40direcionando para o JQ só para ficar bonito no nosso terminal. Quando eu dou enter,
00:04:44ele basicamente faz um diagnóstico no arquivo corrompido que eu passei e diz essencialmente o que
00:04:49eu preciso fazer para realmente corrigir este arquivo. Vocês podem ver que recebemos uma saída estruturada com campos que
00:04:53praticamente só um LLM precisa saber, como níveis de segurança, o modo, aplicações, edições. Temos coisas aqui embaixo
00:04:58como política de reparo self-host. Depois temos a seção de diagnóstico que é basicamente a mesma
00:05:03coisa que vimos no comando "xero check" e aqui embaixo também temos a correção para aquele código de erro
00:05:07em si. Então, como isso é normalmente corrigido? Basicamente, parte da ideia parece ser: e se a linguagem
00:05:12fornecesse a sua própria documentação quando fosse necessária? Se apontássemos um LLM para esta nova linguagem,
00:05:17ele não precisaria realmente procurar nenhuma documentação ou usar conhecimentos prévios, ele seria capaz de obter
00:05:21informações suficientes a partir do toolchain quando fosse realmente necessário. Para colocar isso à prova, coloquei
00:05:25o nosso arquivo corrompido em um diretório totalmente novo que não tem nenhuma informação sobre o que é a linguagem Xero e agora
00:05:30eu simplesmente peço ao Claude para corrigir aquele arquivo corrompido e também dou a ele o comando que ele precisa para aqueles
00:05:34diagnósticos, porque ele precisa de alguma informação sobre como realmente usar o toolchain. Com isso,
00:05:38podemos prosseguir e ver se o Claude consegue realmente corrigir este arquivo. Bem, aí está, depois de 31 segundos ele
00:05:43conseguiu corrigir todos os erros no arquivo, e eu tinha introduzido três deles, e ele encontrou
00:05:47todos os três e os corrigiu, e podemos rolar para cima e ver como ele fez isso. Ele está simplesmente executando aquele
00:05:51comando "xero fix" que eu dei a ele. Desta vez recebemos de volta "ok: true", então é assim que ele sabe que não
00:05:56restam erros e, se rolarmos para cima, podemos ver que ele fez algumas alterações de código e fez isso porque,
00:06:00na etapa anterior, ele rodou o "xero fix" e obteve algumas informações sobre como exatamente corrigir aquele problema e
00:06:05fez isso com todos os três problemas que tínhamos. Portanto, este modelo não tinha nenhuma informação prévia sobre o que é a
00:06:10linguagem Xero, não usou nenhuma pesquisa na web ou algo do tipo para buscar a documentação, ele
00:06:14simplesmente usou as informações que o toolchain forneceu como saídas estruturadas. Estou até
00:06:18um pouco impressionado com isso, esta é uma linguagem novinha em folha que um LLM ainda consegue depurar graças a
00:06:22como a linguagem foi construída, mas há uma coisa que me deixa pensando: isso é realmente novo? Quero dizer,
00:06:28eu entendo todo o argumento de venda de erros e tudo no toolchain ter saídas
00:06:31estruturadas, mas isso não é realmente um conceito novo, nós temos mensagens de erro estruturadas há décadas. Quero dizer,
00:06:37olhem para isto, eu tenho praticamente o mesmo programa de classificação construído em Rust e ele tem erros semelhantes
00:06:41e eu posso simplesmente pedir para a saída ser em JSON. Não tenho muita certeza de que precisávamos de uma linguagem inteira
00:06:46sendo construída em torno desta ideia, e talvez vocês pudessem apenas ter melhorado as já existentes se achavam que
00:06:51havia uma lacuna na informação. Também tenho quase certeza de que se eu pegasse aquele código Rust corrompido e pedisse
00:06:55ao Claude para corrigi-lo, ele seria capaz de fazê-lo com facilidade, e isso seria mesmo que não estivesse usando saídas
00:07:00estruturadas. Sinto que os LLMs fazem um trabalho perfeitamente aceitável com mensagens normais, ou talvez eu apenas não tenha
00:07:05passado por esse problema. Além disso, temos o fato de que os LLMs foram treinados com toneladas de linguagens de
00:07:10programação existentes como Rust, por isso vão ser muito bons em depurar isso e têm muitos
00:07:14exemplos em seus dados de treinamento, mas com o Xero não há absolutamente nenhum. Agora, isso não significa que você nunca
00:07:19deva tentar adicionar uma nova linguagem, apenas significa que se você estiver construindo um app complexo, você não escolheria
00:07:24o Xero, mas para ser sincero com você, eles nem sequer o estão comercializando assim de qualquer forma. No geral,
00:07:28acho que isto é apenas um experimento interessante e, se serve de algo, mostra que você ainda pode construir uma nova linguagem
00:07:32e dar aos LLMs o contexto necessário sem que eles tenham sido treinados nessa linguagem, mas eu só não tenho muita
00:07:37certeza se isso era necessário. Nada disso quer dizer que a linguagem em si não seja legal. Como eu disse, ela
00:07:42na verdade não é tão ruim de usar e compila para um tamanho bem bom. Eu só duvido que vá
00:07:47usar esta linguagem em vez de outras já estabelecidas como Rust, Zig ou Go. Tenho certeza de que vai haver muitas
00:07:51opiniões sobre esta, então me diga o que você acha nos comentários aqui embaixo ou clique em se inscrever
00:07:55e, como sempre, nos vemos no próximo.

Key Takeaway

A linguagem Xero demonstra que é possível capacitar LLMs a depurarem códigos sem treinamento prévio por meio de um toolchain que fornece diagnósticos estruturados em JSON, embora ferramentas tradicionais como o Rust já ofereçam saídas semelhantes.

Highlights

  • A Vercel lançou a Xero, uma linguagem de programação de sistemas criada do zero para permitir que humanos e agentes de IA desenvolvam pequenos programas nativos em conjunto.

  • Todo o toolchain da linguagem Xero possui uma opção de saída em formato JSON estruturado para fornecer diagnósticos detalhados diretamente para modelos de linguagem (LLMs).

  • A linguagem Xero utiliza o princípio de capacidades explícitas, exigindo a declaração “world” para qualquer operação de entrada e saída (E/S) de arquivos, texto ou rede.

  • O compilador da Xero valida capacidades em tempo de compilação, rejeitando operações de sistema de arquivos antes de gerar binários para WebAssembly para evitar erros em tempo de execução.

  • Em um teste prático sem dados prévios de treinamento, o modelo Claude corrigiu três erros intencionais em um arquivo corrompido em 31 segundos utilizando apenas o comando “xero fix”.

Timeline

A proposta da linguagem de programação Xero

  • A Xero funciona como uma linguagem de sistemas de baixo nível semelhante a Rust ou Zig.
  • As linguagens de programação tradicionais atendem à leitura humana de erros, enquanto a Xero prioriza dados estruturados para o consumo de agentes de IA.

O compilador e todo o ecossistema da linguagem Xero geram saídas estruturadas em JSON de forma nativa. O objetivo central é otimizar o fluxo de trabalho de desenvolvimento conjunto entre programadores humanos e assistentes artificiais. Existe ceticismo sobre a real necessidade de criar uma nova linguagem apenas para essa finalidade.

Sintaxe básica e gerenciamento explícito de efeitos colaterais

  • A execução de operações de E/S na linguagem Xero exige obrigatoriamente a declaração da capability “world”.
  • O erro de compilação ocorre antes da geração do binário caso o código tente acessar recursos indisponíveis no alvo de compilação, como o sistema de arquivos no WebAssembly.
  • O tratamento de falhas propaga erros através da palavra-chave “check” combinada com a marcação “raises” na função.

O ponto de entrada padrão de um programa na Xero é uma função principal pública que retorna void. O comando “xero run” seguido pelo nome do arquivo com a extensão “.xero” executa o código diretamente no terminal. Essa estrutura visa dar previsibilidade total ao compilador e aos agentes de IA sobre os efeitos colaterais do código.

Estruturas de dados e controle de memória

  • A linguagem implementa enums, condicionais “if”, blocos de repetição “while” e “for”, além do comando de correspondência “match”.
  • O gerenciamento de memória utiliza “shapes” semelhantes a structs, com distinção entre “mutable spans” para escrita e “spans” para leitura.
  • A palavra-chave “defer” e o tipo “owned” controlam o ciclo de vida de variáveis e a execução de funções de limpeza ao sair do escopo.

Um aplicativo de teste para classificar entradas textuais, numéricas ou mistas serve para ilustrar as primitivas da linguagem. O controle de memória é totalmente explícito, exigindo a definição manual da função “drop” no “shape” para liberar recursos. O comportamento assemelha-se aos recursos básicos encontrados em linguagens modernas de sistemas.

Diagnósticos em JSON e automação com LLMs

  • O comando “xero check” com a opção JSON gera dados sobre severidade, código, mensagem, valores esperados e política de reparo do erro.
  • O comando “xero fix” no modo plan gera um roteiro estruturado contendo os níveis de segurança e as edições necessárias para corrigir o arquivo.

A saída em formato legível por humanos pode ser alternada para um formato JSON estruturado e tratada com utilitários como o JQ para facilitar a visualização. Os metadados gerados servem como documentação contextualizada sob demanda para o próprio modelo de linguagem. Isso reduz a dependência de um conhecimento prévio massivo armazenado nos pesos do modelo.

Validação prática com Claude e comparação com Rust

  • O modelo Claude corrigiu um arquivo Xero corrompido de forma autônoma sem acesso à internet ou documentação externa.
  • Linguagens consolidadas como o Rust já fornecem mensagens de erro estruturadas em JSON através de suas ferramentas nativas.

O teste isolou o arquivo Xero em um diretório sem contexto prévio, fornecendo apenas o comando de diagnóstico para a IA. O assistente utilizou os dados do comando “xero fix” para resolver os três problemas inseridos intencionalmente. Apesar do sucesso do experimento, os LLMs atuais demonstram alta capacidade de corrigir falhas em código Rust mesmo com saídas de texto convencionais, o que levanta dúvidas sobre a necessidade de adoção da Xero frente a ecossistemas maduros como Rust, Zig ou Go.

Community Posts

No posts yet. Be the first to write about this video!

Write about this video