Basic Next: uma linguagem para voltar para casa
Meu nome é Carlos Alvaro Quintella. Sou formado em Tecnologia em Proceessamentode de Dados pela PUC-Rio, com MBA em Administração de Empresas também pela PUC-Rio e mestrado em Informática pela UNIRIO, com pesquisa em aprendizado de máquina aplicado. além disso sou professor na Universidade Veiga de Almeida e Sou o criador da linguagem de programação Basic Next. Este texto não é uma especificação técnica nem um paper de revisão de literatura — é uma apresentação da linguagem e um convite ao diálogo sobre ela, no espírito de quem quer que outras pessoas conheçam o problema que a motivou, as decisões que a formaram, e o estado real, sem retoques, de onde ela está hoje.
1. O problema
Eu gosto de TypeScript. Gosto o suficiente para tê-lo como minha linguagem de trabalho por anos, para confiar nele em sistemas de produção, para recomendá-lo sem hesitar. Mas há um atrito que o TypeScript nunca resolveu para mim: ele carrega, por baixo da sintaxe moderna, os problemas de herança do JavaScript que o formam. E há um segundo atrito, ortogonal a esse: quando o que eu quero é escrever um programa que vai ser compilado — não transpilado, não interpretado num runtime de navegador, mas compilado para rodar como um binário — o TypeScript simplesmente não é a ferramenta certa.
A resposta óbvia da indústria para "eu quero escrever programas compilados de forma produtiva" tem um nome: Python. E aqui está o incômodo que motivou este projeto inteiro. Eu não gosto de Python. Meu primeiro contato com a linguagem foi há mais de dez anos, e a impressão que ficou — de uma linguagem cansativa de ler e de escrever — nunca foi revisada. Pode ser uma impressão injusta com o Python de hoje; eu assumo essa possibilidade abertamente. Mas o fato é que hoje, na era em que a inteligência artificial gera a esmagadora maioria do código do mundo em Python, eu decidi ir na direção contrária. Não por espírito de contradição, mas porque a linguagem que eu queria usar para pensar não existia ainda.
Há também Java, e há a burocracia que ele compartilha com o Python de outra forma: ambientes virtuais, cerimônia de configuração, uma distância entre a ideia e a primeira linha de código rodando. Eu queria menos disso. Queria abrir um editor de texto, escrever uma função, e rodar.
2. A saudade como ponto de partida
A resposta que eu fui buscar não veio de uma análise fria de linguagens concorrentes. Veio de uma lembrança afetiva: o BASIC, e mais especificamente o Visual Basic, dos meus primeiros anos escrevendo código. Poucos comandos, e ainda assim poder suficiente para fazer coisas reais. Não estou romantizando as limitações históricas do BASIC — GOTOs descontrolados, ausência de tipos fortes, os problemas que a própria história da ciência da computação já documentou à exaustão. Estou falando de uma sensação específica: a de que a distância entre pensar "eu quero que o programa faça X" e escrever o código que faz X era curta. Curta o suficiente para não atrapalhar o raciocínio.
Basic Next nasce dessa saudade, tratada não como nostalgia estéril, mas como hipótese de design: e se fosse possível recuperar essa proximidade entre pensamento e sintaxe, mas com tipagem explícita, orientação a objetos, e capacidade de gerar código nativo de verdade?
O nome do projeto é literal nessa intenção. Não é um revival do BASIC. É o próximo passo a partir dele.
3. Para quem é isso
O público que eu tenho em mente não é uniforme, e acho importante ser honesto sobre isso em vez de forçar uma persona única de usuário. De um lado, iniciantes — pessoas para quem a primeira linguagem de programação deveria ensinar lógica, não lidar com gerenciamento de memória ou sistemas de módulos complexos. Do outro lado, alguém com mais experiência que está fazendo vibe coding — escrevendo scripts e programas em colaboração estreita com um modelo de linguagem, onde o que importa não é a expressividade máxima da sintaxe, mas a previsibilidade dela. Um humano revisando código gerado por IA, ou uma IA gerando código para um humano revisar, se beneficia da mesma propriedade: a sintaxe precisa acertar o palpite de primeira tentativa.
Isso não é um detalhe estético. É o critério central de design do Basic Next: reduzir a necessidade de decorar regras, e fazer com que o primeiro palpite de quem escreve — humano ou modelo — tenda a estar certo. Essa é a ideia que estrutura o documento de filosofia do projeto, disponível no repositório, e vale a leitura para quem quiser a versão longa do argumento.
4. Genealogia da sintaxe
Toda linguagem nova é, de algum jeito, uma colagem de influências anteriores, e prefiro nomear as minhas em vez de fingir originalidade absoluta. O BASIC e o Visual Basic emprestam a estrutura de blocos legíveis (FUNCTION / END FUNCTION, WHILE / END WHILE) e a cadência quase falada da linguagem. O TypeScript empresta o sistema de tipos — a ideia de anotar tipos de forma explícita e visível, sem forçar a burocracia de linguagens como Java. C, C++ e Objective-C entram na conversa em outro nível, mais próximo do runtime e da forma como memória, despacho e concorrência deveriam se comportar por baixo do açúcar sintático.
Um exemplo concreto de como isso emergiu na prática, e não por planejamento a priori: a palavra-chave AS. Ela nasceu como sintaxe de typecast — uma forma de dizer "trate este valor como este tipo". No processo de desenvolvimento, ela cresceu além disso, até se tornar o conectivo geral entre um identificador e seu tipo em toda a linguagem, seja em uma declaração de variável (LET value AS INTEGER = 10), no parâmetro de uma função (value AS INTEGER) ou no seu retorno (AS INTEGER). Não foi um projeto de sintaxe unificada desenhado no papel antes de existir código. Foi uma palavra-chave que, usada repetidamente, revelou que deveria ser generalizada. Acho esse tipo de emergência mais honesto do que fingir que toda decisão veio de um blueprint fechado desde o início.
Quando penso em linguagens comparáveis — o lugar que o Basic Next deveria ocupar na prateleira — penso em Swift, e talvez Ruby, embora eu conheça Ruby superficialmente. E, inevitavelmente, penso em Python, contra cuja ergonomia este projeto se define por oposição.
5. Debaixo do capô: da árvore sintática ao código nativo
O Basic Next hoje funciona como intérprete, mas essa é apenas a primeira etapa visível de um pipeline maior. O código-fonte é primeiro convertido em uma árvore sintática abstrata (AST), que por sua vez é reduzida a uma representação intermediária (IR) própria da linguagem. Essa camada de IR é o que permite duas coisas: a execução interpretada, que é o que funciona hoje, e a compilação para LLVM, que deve gerar código nativo para arquiteturas específicas de máquina no futuro.
É importante ser preciso aqui em vez de vender um estágio que ainda não existe: na versão 0.4, o Basic Next ainda não executa código compilado. A execução interpretada é o caminho maduro. O salto para geração de código nativo via LLVM é o horizonte declarado, não uma feature entregue.
O toolchain inteiro — o interpretador, o parser, a geração de IR — é escrito em Rust. Essa escolha teve um critério explícito, que talvez seja incomum de se ver documentado em um projeto de linguagem: Rust ocupa um meio-termo entre a liberdade (e o risco) do C++ e a rigidez mais primitiva do C, e esse meio-termo é exatamente o que eu queria tanto para meu próprio uso quanto para IAs gerando código para o compilador. Um toolchain implementado em uma linguagem que estrutura mais e permite menos classes inteiras de erro tende a produzir menos bugs quando parte substancial do código é gerada por um modelo de linguagem em vez de escrita à mão, linha a linha.
6. Duas peças novas: BNWeb e BNDispatch
A versão 0.4 introduziu dois módulos que merecem ser contados como histórias próprias, porque cada um nasceu de uma frustração específica, não de um plano de roadmap genérico.
BNWeb é o módulo que permite a um programa Basic Next servir páginas web diretamente:
IMPORT BNWeb AS Web
FUNCTION Hello(req AS Web.Request, res AS Web.Response) AS VOID
res.Write("<h1>Hello World</h1>")
END FUNCTION
FUNCTION Start() AS VOID
LET server AS Web.Server = Web.Server.New()
server.Route("GET", "/", Hello)
server.Start("127.0.0.1:8080")
END FUNCTIONEssa é a resposta a uma lacuna que senti pela primeira vez há muitos anos, ao aprender Lua: a sensação de que faltava algo parecido com um micro-framework tipo Express embutido na própria linguagem, em vez de depender inteiramente de bibliotecas externas para a tarefa mais básica de expor um servidor HTTP.
BNDispatch é o módulo de paralelismo:
IMPORT BNDispatch AS Dispatch
FUNCTION Count1to10() AS VOID
LET n AS INTEGER = 1
WHILE n <= 10
PRINT n
n += 1
END WHILE
END FUNCTION
FUNCTION Count11to20() AS VOID
LET n AS INTEGER = 11
WHILE n <= 20
PRINT n
n += 1
END WHILE
END FUNCTION
FUNCTION Start() AS VOID
LET queue AS Dispatch.Queue = Dispatch.Queue.Concurrent(10)
queue.Async(Count1to10)
queue.Async(Count11to20)
queue.Join(5000)
queue.Close(1000)
END FUNCTIONAqui a genealogia é mais interessante do que o resultado final sugere à primeira vista. Meu ponto de partida mental era algo no espírito do OpenMP — diretivas de paralelismo relativamente diretas sobre loops e blocos. Mas ao longo do desenvolvimento, o modelo que se mostrou mais interessante e mais rápido de implementar veio de outro lugar: o Objective-C, e sua tradição de filas de despacho (dispatch queues) como unidade central de concorrência. Dispatch.Queue.Concurrent(n) é herdeiro direto dessa tradição, não do OpenMP que inspirou a busca inicial.
7. Como isso foi construído, porque o processo é parte da história
Seria desonesto escrever este artigo como se eu tivesse programado o Basic Next linha a linha, sozinho, num editor de texto. Não foi assim. O desenvolvimento aconteceu em colaboração direta com múltiplas inteligências artificiais — Codex, Grok, o assistente do VS Code, Gemini e ChatGPT passaram pelo processo, cada um contribuindo de forma diferente. Grok e ChatGPT foram os que mais se destacaram ao longo do trabalho.
Eu escrevi muito pouco do código-fonte diretamente. O que eu fiz, constantemente, foi ajustar: revisar decisões, redirecionar rumo, inspecionar arquivos-chave do projeto para garantir coerência, e aplicar disciplina de processo e teste sobre o que as IAs produziam. Isso não reduz minha autoria sobre a linguagem — decisões de design como o comportamento do AS, a escolha de Rust, a direção do BNDispatch em vez do OpenMP, todas vieram de mim — mas muda o que significa "escrever uma linguagem de programação" em 2026. O ritmo de lançamento das primeiras versões (0.1 em 26 de agosto, 0.2 em 30 de agosto, 0.3 em 1º de setembro, 0.4 em 2 de setembro) é sintoma direto desse modelo de trabalho: ciclos guiados por vibe coding e inspeção pontual de arquivos críticos, não por um processo formal de gestão de release tradicional.
Há uma ironia que não escapa a mim, e que acho que vale nomear explicitamente em vez de esconder: uma linguagem criada em reação à hegemonia do Python como língua franca da geração de código por IA foi ela mesma construída majoritariamente por IAs. Não vejo isso como contradição a ser resolvida, mas como o tipo de tensão produtiva que caracteriza este momento específico da história da programação.
8. Onde as coisas realmente estão
A versão 0.4 está no ar, com BNWeb, BNDispatch, o interpretador, e os comandos bn check e bn run funcionando sobre Linux, macOS e Windows. Dito isso, é preciso declarar as limitações com a mesma clareza com que descrevi as ambições.
Primeiro: o que existe hoje em termos de código real são pequenos trechos de demonstração, não programas completos que sirvam como estudo de caso de uso em produção. Segundo: tratamento de erros e a suíte de testes da linguagem ainda estão em estágio muito inicial — isso é uma prioridade declarada, não um detalhe esquecido. Terceiro: a compilação para código nativo via LLVM ainda não está disponível; tudo que roda hoje, roda interpretado. A expectativa é que a versão 0.4.3 traga um salto relevante de confiabilidade, especialmente no que toca a essas duas frentes.
Não houve, até o momento, nenhum teste formal com outras pessoas — alunos, outros desenvolvedores — escrevendo código em Basic Next pela primeira vez. O projeto está na fase de se tornar utilizável antes de se tornar validável.
9. O convite
Basic Next é código aberto, sob licença MPL 2.0, e está disponível em github.com/cquintella/BasicNext. Existe um plugin em fase alfa para VS Code. Se a leitura até aqui ressoou — se você também sente que a distância entre pensar um programa e escrevê-lo cresceu demais nas últimas décadas, ou se você trabalha lado a lado com um modelo de linguagem e quer uma sintaxe que ele erre menos — experimente. A versão atual é uma degustação do que está por vir: um estado anterior ao alpha, uma versão zero. Não é para sustentar processos de negócio ainda. É para ser lida, testada, e discutida.
Se a sensação de "voltar para casa" que motivou este projeto fizer sentido para você também, o repositório está aberto para isso.