Filosofía

Piola: tranquilo, hábil, sin hacer ruido, de panini.

No es un chiste (bueno, un poco sí)

La identidad chilena de Piola no es marketing. No es poner palabras en español para que quede gracioso en Twitter. Es un intento genuino de construir algo que se sienta natural para alguien que creció hablando chileno.

El español tiene estructura propia. Tiene ritmo propio. Y resulta que ese ritmo cabe perfectamente en un lenguaje de programación, si uno se toma el tiempo de diseñarlo bien en vez de traducir mecánicamente.

wea x = 10
pega sumar(a, b) {
  a + b
}
altiro(sumar(x, 5))  // → 15

¿Ves? Se lee. No necesitas saber programar para entender que altiro hace algo al tiro, que pega es un trabajo, y que wea es… bueno, una wea.

Por qué cada keyword es la que es

Cada palabra clave fue elegida con criterio. No son traducciones del inglés ni palabras random. Son palabras que un chileno ya usa, y cuyo significado se mapea bien al concepto técnico.

wea = variable

Una variable es un contenedor para cualquier cosa. En chileno, wea cumple exactamente ese rol: puede ser un objeto, una situación, un concepto, lo que sea. Es la palabra más polivalente del idioma. Perfecta.

pega = función

Una función es un bloque de trabajo que le encargas a la máquina. Pega en Chile es trabajo, labor, lo que haces cuando te contratan. Defines una pega, y después la mandas a hacer.

duro = constante

Algo duro no se dobla. No cambia. La constante de pi no negocia su valor. Sin más explicación necesaria.

cachai = condicional

Es una pregunta implícita: ¿captas que esto es verdad? Si sí, ejecuta. La interrogación está en el nombre. Ningún otro keyword captura mejor la idea de “evalúa antes de continuar”.

altiro = print

Significa “al tiro” — de inmediato. Imprimir es la acción más inmediata que tiene un programa para hablarle al mundo exterior. El nombre es literal.

ojo / cago = try / catch

Ojo es advertencia, cuidado. Metes en ojo el código que puede fallar. Si falla, cago es exactamente lo que pasó. Nadie lo dice mejor.

Lo que se evitó fue la traducción mecánica: si para if, entonces para then, mientras_que para while. Eso resulta en código que suena como manual de instrucciones pasado por Google Translate. Piola prefiere palabras que un chileno diría de verdad.

Créanme que de verdad intente evitar usar IA para esto. No es que le dije “dame palabras clave en español chileno” y me las escupió. Fue un proceso iterativo de probar palabras, leerlas en voz alta, imaginar cómo sonarían en código real, y elegir las que mejor encajaban, puesto que si le preguntas a una IA este se pone weon y se pone a inventar palabras que no existen o a usar palabras que suenan formales pero que nadie diría en la vida real.

De dónde viene y qué rechaza

Piola no nació del vacío. Tomó cosas prestadas, pero también rechazó cosas de forma explícita.

Lo que tomó:

De Lua — que un lenguaje liviano puede ser completo sin ser complicado. No necesitas un runtime enorme para tener algo funcional.
De Python — la preferencia por retorno implícito y la idea de que el código debe leerse casi como prosa.
De Ruby — el tono. Ruby tiene personalidad. Los errores de Piola son herederos directos de esa filosofía.
De Rust — la obsesión con errores informativos que apuntan exactamente al problema. (aun en desarrollo)

Lo que rechazó:

El silencio de JavaScript. Los que me conocen saben que detesto a JavaScript. JS convierte tipos silenciosamente, falla sin avisar, y tiene reglas de coerción que nadie recuerda completas. [] + {} no debería ser "[object Object]". Piola prefiere insultarte antes que ejecutar algo incorrecto sin avisarte.

La verbosidad del Java Antiguo public static void main. Getters y setters para todo. Piola es conciso porque el objetivo es que el código diga lo que hace, no que demuestre que siguió el procedimiento correcto.

La magia implícita. Código que hace cosas “por ti” sin que entiendas qué pasa. En Piola, lo que lees es lo que hay. Sin sorpresas.

Sobre el humor en los errores

El humor en los errores de Piola es una decisión técnica disfrazada de personalidad.

Un error tiene que ser memorable. Si es genérico y frío, lo lees y lo cierras. Si tiene carácter, lo lees, te ríes, y lo recuerdas. Recordar el error es parte de no repetirlo.

Error: No podi sumar un 'numero' con un 'texto' pedazo de saco wea.
Error: La wea 'x' no existe papito.
Error: Te fuiste al chancho, el índice 10 no existe en la lista (largo: 2).

Cada uno de esos errores tiene tres partes: qué falló, qué estaba involucrado, y el tono. Quita la tercera parte y el error sigue siendo útil. Quita las primeras dos y es solo un insulto sin contexto.

Los cinco principios

Cuando dos ideas entran en conflicto, estos principios son el desempate.

1. Lo que lees es lo que hay

Sin magia. Sin comportamiento oculto. El código hace exactamente lo que dice que hace.

wea contador = 0
mientras (contador < 5) {
  contador = contador + 1  // modifica la wea del bloque padre, obvio
}

2. Los errores son parte del lenguaje

Un error no es una falla del sistema, es información. Cada mensaje debe decir qué salió mal, dónde (con el span exacto apuntando al código), y por qué cuando el contexto lo justifica. Y si puede hacerlo con humor sin perder precisión, mejor todavía.

3. Simple primero, poderoso después

Piola prioriza una implementación simple y correcta por sobre tener muchas features. Cada cosa que se agrega debe justificar su complejidad.

Esto no significa que Piola sea pobre. Significa que cada feature existe porque resuelve un problema real, no porque “los otros lenguajes la tienen”.

4. Dinámico por elección, no por descuido

Piola es de tipado dinámico. No solo porque sea más fácil de implementar (aunque lo es), sino porque permite entender primero cómo funciona la evaluación de expresiones, el scoping, y el manejo de errores, sin el peso adicional de un sistema de tipos estático.

wea x = 42
x = "ahora soy texto"  // válido, la wea puede cambiar de tipo

Los errores de tipo ocurren en tiempo de ejecución. El lenguaje confía en que sabes lo que haces, y cuando no es así, te lo dice sin rodeos.

5. El pipeline es el aprendizaje

La arquitectura de Piola refleja las fases clásicas de un compilador:

Fuente → Lexer → Parser → AST → Intérprete → (Bytecode → VM)

Cada fase es un módulo separado con una interfaz clara. El objetivo es que leer el código fuente de Piola sea, en sí mismo, un recorrido por cómo funcionan los lenguajes por dentro.