🚀 Criando minha própria linguagem de programação: evolução real da Kaa (Alpha 2.1)

Recentemente, compartilhei aqui na DIO o início de um projeto pessoal: a criação da minha própria linguagem de programação, a Kaa.

Naquele momento, era mais uma ideia em execução — um experimento para entender melhor como linguagens funcionam por baixo dos panos.

Hoje, a história é outra.

A Kaa evoluiu.

De curiosidade para arquitetura

Criar uma linguagem de programação não é só escrever sintaxe bonita.

Na prática, você está lidando com um conjunto de decisões fundamentais:

Como o código será interpretado?
Como os dados serão representados?
Como o fluxo de execução será controlado?
E principalmente: qual problema essa linguagem resolve?

Esse processo envolve conceitos clássicos da computação, como análise léxica, parsing e execução — etapas essenciais na construção de compiladores e interpretadores.Foi exatamente nesse ponto que a Kaa deixou de ser um experimento e começou a se tornar um sistema.

Estrutura interna da Kaa

Na versão Alpha 2.1, o projeto já está organizado como uma linguagem de verdade:

Scanner (análise léxica) → transforma código em tokens
Parser (análise sintática) → organiza os tokens em estrutura lógica
AST (Árvore Sintática Abstrata) → representa o programa
Interpretador → executa o código
Ambiente (escopos) → controla variáveis e contexto
Funções e closures → permitem reutilização e encapsulamento

Esse fluxo — do texto até a execução — é exatamente o pipeline clássico de linguagens modernas.

O que já é possível fazer com Kaa

A Kaa já permite escrever programas completos.

Alguns exemplos de recursos atuais:

Tipagem leve e explícita

var -i x = 10;
var -f y = 3.14;
var -s nome = "Kaa";
var -i a;
var -f b;

var -T controle1; // Bool: true já incluso
var -F controle2; // Bool: false

Tuplas, dicionários e listas

var -l a; // lista
var -d b; // dicionario
var -t c; // tupla

a = [1,2,3,4] // depois de declaradas, podem ser abastecidas chamando
b = {1:a,2:b,3:c}
c = (1,2,3)

Estruturas de controle

if (x > 5) {
  print "Maior que 5";
}

while (cond) {
  // execução contínua
}

Funções e reutilização

fun soma(a, b) {
  return a + b;
}

Um diferencial interessante: módulos e closures

Um dos pontos mais interessantes da Kaa é o sistema de importação e exportação:

add "./bot.kaa" -> obter;
add "./boot.kaa" all;

expor fun1, fun2; // exporta apenas funções e as selecionadas
expor all; // exporta somente todas as funcoes

Aqui, funções são exportadas e podem carregar seu próprio estado através de closures.

Isso significa que variáveis não são exportadas diretamente — elas viajam encapsuladas dentro das funções.

Esse modelo força um design mais limpo e previsível.

Biblioteca padrão já funcional

A linguagem já conta com bibliotecas próprias, sem depender diretamente do Python:

math.kaa

MDC, MMC, fatorial
Fibonacci, logaritmos
Funções trigonométricas
Operações com listas

time.kaa

Contagem (conte)
Pausa (pare)

Isso mostra que a linguagem já consegue sustentar funcionalidades reais — não é apenas um interpretador mínimo.

Integração com Python (estratégica)

Mesmo com bibliotecas próprias, a Kaa também permite integração com Python:

add -py "import math as m";

Essa decisão não é só técnica — é estratégica.

Ela permite:

Expandir rapidamente o ecossistema
Validar a linguagem com casos reais
Evitar reinventar tudo no início

Filosofia da linguagem

Toda linguagem precisa de um “norte”.

No caso da Kaa, algumas decisões já estão claras:

Sintaxe simples, mas explícita
Tipagem leve, porém controlada
Separação clara entre atribuição (=) e comparação (==)
Modularização com foco em funções
Erros explícitos e didáticos

Isso segue um princípio comum no design de linguagens: definir objetivos claros antes de expandir funcionalidades.

O que mudou da versão anterior?

A maior evolução não foi só em features.

Foi em maturidade.

Antes:

Um interpretador funcional

Agora:

Uma linguagem estruturada
Com arquitetura definida
Com sistema de módulos
Com biblioteca padrão
E com caminho claro de evolução

Próximos passos

A Kaa ainda está em Alpha, mas com base sólida.

Os próximos focos são:

Melhorar o interpretador
Refinar mensagens de erro
Expandir a biblioteca padrão
Evoluir o sistema de parsing
Criar mais casos reais de uso

Conclusão

Criar uma linguagem de programação muda completamente a forma como você enxerga código.

Você deixa de ser apenas usuário de abstrações — e passa a entender como elas são construídas.

E no fim, essa é a maior entrega do projeto até agora:

Não só uma linguagem… Mas uma nova forma de pensar software.