Quien estudia ciencias de la computación, en un pasado infantil, probablemente ya soñó con construir máquinas increíbles con recursos limitados — igual que Batman o Iron Man, escapando de aprietos por la fuerza del ingenio.
En mi caso, fue exactamente así. Siempre busqué domar la naturaleza con ciencia. Un ejemplo del que me enorgullezco: en la escuela primaria, creé una pequeña línea de producción semiautomática de trabajos escolares — y con los ingresos generados, contribuía a los gastos del hogar. Era un sistema simple, pero funcional.
Ese recuerdo regresó con fuerza cuando fui admitido en la UFMS para el Tecnólogo en Inteligencia Artificial. Ya cursaba Sistemas de Información en el IFMA, pero decidí cambiar de rumbo — y de estado. Rendí el Enem con ese objetivo.
Al recibir la admisión, volvió el recuerdo de la infancia: mi abuela decía que todo lo que yo hacía desde los 5 años era “robot”. Ella no estaba equivocada. Lo que cambia hoy es que los robots se volvieron más grandes — y más interesantes.
La base computacional como proyecto personal
Con esa transición de vida, decidí que era hora de construir mi propia base computacional. Vivimos en un tiempo en que el paradigma hombre-máquina permite que, mediante la simbiosis con la IA, podamos construir cosas mucho más sofisticadas que antes. ¿Por qué no usar eso a favor de un proyecto ambicioso?
El primer paso fue sumergirme en Crafting Interpreters, de Robert Nystrom — una obra completa sobre cómo construir un lenguaje de programación desde cero, desde el lexer hasta una máquina virtual. Es uno de esos libros raros que no te enseña solo el cómo, te enseña el porqué. Cada capítulo me hacía parar a codear.
Luego fui a explorar lo que la comunidad de entusiastas ya había producido: lenguajes experimentales, DSLs, proyectos académicos. Y un detalle curioso me marcó: muchos conceptos usados hoy en lenguajes de programación tienen raíces en la propia IA. Eso cambió mi forma de ver el problema.
Fue en esa investigación donde la idea tomó forma. Decidí crear Kaa.
¿Qué es Kaa?
La idea central es simple: ser un lenguaje para mi uso cotidiano. Pero como desde niño proyectaba máquinas de estado — sistemas donde cada estado define un comportamiento y las transiciones determinan lo que sucede a continuación —, quise que Kaa reflejara esa forma de pensar.
El lenguaje no tiene sistema de clases. Opera con funciones y un sistema de compartirlas por closures como sistemas vivos separados que trabajan en conjunto. La orientación a objetos de Kaa gira en torno al concepto de S-bots: agentes autónomos que pueden ser compuestos y encadenados. Cada script puede ser alojado dentro de otro, formando un árbol de ejecución.
De ahí el nombre: Kaa significa “selva, bosque, floresta” en Nheengatu, lengua indígena brasileña — y un bosque es, al fin y al cabo, una estructura de árboles interconectados.
| Campo | Valor |
|---|---|
| Nombre | Kaa |
| Origen del nombre | Nheengatu (bosque) |
| Paradigma | Funcional + S-bots |
| Estructura | Árbol de scripts |
| Extensión | .kaa |
| Base | Python |
Kaa v2.0 — sistema de tipos ligero
La versión 2.0 representó el primer salto importante. Kaa evolucionó de un lenguaje puramente dinámico a un modelo con tipado ligero y validación en tiempo de ejecución.
Declaración de variables con tipo:
| Flag | Tipo |
|---|---|
-i |
entero |
-f |
float |
-s |
string |
-T |
true |
-F |
false |
-obj |
objeto |
var -i x = 10;
var -f precio = 4.99;
var -s nombre = "Saulo";
var -i edad;
input "Ingresa tu edad: " >> edad;
print "Nombre: ", nombre, " Edad: ", edad;
Uno de los puntos más interesantes: el lenguaje intenta convertir valores automáticamente, pero falla de forma explícita cuando no es posible — seguridad sin perder flexibilidad.
La coerción de tipos ocurre en tres momentos: declaración, asignación y entrada vía input.
Pipeline de ejecución:
código .kaa → scanner → tokens → parser → AST → intérprete
Los S-bots en la práctica — OOP sin clases
La inspiración vino directamente de aquellos micro-bots de la escuela primaria. La gran dificultad siempre fue la interconexión entre ellos. Con Kaa, eso se convirtió en un sistema formal: dos archivos .kaa separados se comunican mediante el comando add y la directiva expor.
// Archivo enemigo.kaa — define el S-bot
fun enemigo(nombre, vida, especie) {
var -obj self = {
"nombre": nombre,
"vida": vida,
"vivo": -T,
"especie": especie,
};
fun pierde_vida(dano) {
self.vida = self.vida - dano;
}
fun muerto(muerto) {
if(muerto == -F) {
print "EL OGRO ", self.nombre, " ESTA VIVO!!";
} else {
print "EL OGRO ", self.nombre, " MURIO!!";
}
}
self.pierde_vida = pierde_vida;
self.muerto = muerto;
return self;
}
expor all;
// Archivo ogro.kaa — usa el S-bot importado
add "./enemigo.kaa" all;
var -T control;
var -obj ogro1 = enemigo("jose", 110, "ogro");
var -obj ogro2 = enemigo("joao", 100, "ogro");
while(control == -T) {
ogro1.pierde_vida(10);
if(ogro1.vida == 0) {
ogro1.muerto(-T);
destroy_arena(ogro1);
}
}
El patrón expor all / add "./archivo.kaa" all es el equivalente a un import modular — pero pensado como semillas de un bosque: cada S-bot es independiente, pero puede crecer dentro de otro.
Cambiando el intérprete — la decisión radical
Después de estructurar los S-bots como módulos vivos, el siguiente paso fue una decisión radical: descartar el intérprete de árbol (tree-walk).
La versión inicial funcionaba como la mayoría de los intérpretes didácticos: recorría directamente el AST nodo a nodo en cada ejecución. Es elegante de entender, pero tiene un costo alto — cada operación redescubre el camino. Es como leer un libro entero para encontrar una página cada vez que la necesitas.
La solución fue construir una Máquina Virtual de Bytecode propia. En lugar de recorrer el árbol, el compilador interno de Kaa ahora traduce el código fuente en instrucciones simples y secuenciales — similar a lo que la JVM hace con Java o CPython hace con .pyc. La VM lee esas instrucciones en línea recta, mucho más rápido.
El motor JIT — cuando Kaa dejó de pedir permiso
Todo lenguaje interpretado carga un peso original: necesita un intermediario. Kaa corría sobre Python, que ya es él mismo interpretado. Era como contratar a un traductor que necesita de otro traductor.
La respuesta fue el JIT por Peephole Optimization. La idea no es reescribir todo en C — es más quirúrgica que eso. El optimizador observa el bytecode generado e identifica patrones: secuencias de instrucciones que aparecen repetidas dentro de bucles, incrementos de contadores, comparaciones binarias predecibles.
Cuando reconoce uno de esos patrones, fusiona ese bloque entero en una única superinstrucción — una operación atómica ejecutada a nivel más bajo. Es el concepto de Macro-Op Fusion, el mismo principio que los procesadores modernos usan internamente para fusionar pares de instrucciones de ensamblado en pipeline. Kaa trajo eso al nivel de la VM.
Conclusión — un sueño que compila
Kaa no nació de una necesidad de mercado. No surgió de una demanda corporativa. Nació de lo mismo que me hizo montar aquella línea de producción de trabajos escolares en la primaria: la voluntad irresistible de construir una máquina que piensa como yo pienso.
Todo lenguaje de programación es, en el fondo, una filosofía materializada en código. C cree que el programador debe controlar todo. Python cree que la legibilidad es ley. Rust cree que la seguridad de memoria no puede ser opcional. Kaa cree que un sistema debe funcionar como un bosque: troncos rígidos, tipados, confiables — y ramas que se adaptan, se componen, crecen y mueren sin derribar el árbol entero.
Este proyecto es una mezcla honesta de todo lo que fui acumulando: la obsesión con el tipado que aprendí en C, la ligereza de scripts que Python me enseñó, la modularidad que JavaScript me obligó a entender. Y la filosofía de que un objeto no necesita una clase para tener identidad — que vino de mi propia cabeza, validada por los S-bots que antes vivían en planillas y archivos .bat en una tarde de escuela.
Leer Crafting Interpreters fue como encontrar el manual técnico de una máquina que yo ya había construido a oscuras. Y ahora, por primera vez, tengo el mapa formal de todo eso.
El bosque todavía está creciendo.
.
