La Iniciativa Joss: ¿Por qué decidí crear mi propio lenguaje de programación?

Hoy quiero compartir con la comunidad una de las mayores aventuras técnicas en las que me he embarcado. Durante años, quienes nos dedicamos al desarrollo de software hemos normalizado una realidad bastante frustrante: para crear una simple API o levantar una aplicación web robusta, terminamos armando un laberinto de librerías externas, transpiladores, linters, configuraciones interminables y herramientas que a menudo chocan entre sí.

Llega un punto en la vida de todo programador donde te detienes y te preguntas: ¿Realmente esta es la mejor forma de construir software? ¿Por qué tenemos que conformarnos con lenguajes que delegan sus responsabilidades más críticas en ecosistemas fragmentados? De esa inconformidad, y de años de análisis sobre arquitectura y sistemas, nace Joss.

La Fatiga del "Tooling Hell" y la Web Moderna

Quienes aprendimos a programar con stacks como LAMP (Linux, Apache, MySQL, PHP) o trabajando en lenguajes como Go, C#, Kotlin y Flutter, entendemos el valor de las bases sólidas. En aquellos tiempos, la programación orientada a objetos (POO) y el diseño de software se pensaban con rigor: sabías qué hacía el compilador, entendías cómo viajaba una petición HTTP y sabías exactamente dónde vivía cada byte en memoria.

Sin embargo, el ecosistema web actual ha caído en una trampa de complejidad artificial:

Tipados que son una ilusión: Tecnologías que inventan sistemas de tipos sobre motores puramente dinámicos mediante capas de transpilación. En el editor tu código se ve impecable y sin errores; pero en producción, un valor null inesperado o una coerción oculta tumba el servidor.
Seguridad por casualidad: Si el programador olvida sanitizar un parámetro, hay inyección SQL. Si olvida configurar una cabecera, hay vulnerabilidad CSRF o clickjacking. La seguridad se ha tratado históricamente como un accesorio reactivo, no como una garantía del lenguaje.
Dependencias monstruosas: Proyectos con carpetas de dependencias que pesan cientos de megabytes antes de escribir una sola línea de lógica de negocio. Si una librería descontinúa su soporte o rompe compatibilidad entre versiones menores, todo tu sistema tambalea.

Pasamos más tiempo manteniendo archivos de configuración (tsconfig.json, .eslintrc, webpack, prettier, ORMs) que resolviendo los verdaderos problemas de arquitectura de nuestras aplicaciones.

¿Qué es la Iniciativa Joss?

Joss no nació como un capricho sintáctico ni como un intento de reinventar la rueda por diversión. Joss es una propuesta de lenguaje de programación integral para el desarrollo moderno.

La premisa fundamental de mi proyecto es directa: el lenguaje de programación, el sistema de tipos, el servidor HTTP, el motor de base de datos y las herramientas de análisis deben formar una sola entidad armónica.

Cuando el compilador y el runtime conocen de forma nativa qué es una ruta web, cómo se conecta una base de datos y cómo se audita la seguridad en tiempo de diseño, la carga mental del programador disminuye radicalmente y el rendimiento se dispara.

Los Pilares Fundamentales del Lenguaje

Para construir Joss, analicé lo mejor de diversos paradigmas de la computación contemporánea y sinteticé las soluciones a los dolores más frecuentes de la industria:

1. Tipado Estático Fuerte con Inferencia Natural

En Joss no tienes que escribir tipos redundantes en cada línea si el compilador puede deducirlos con certeza matemática. La primera asignación fija el tipo estático de la variable, impidiendo mutaciones de tipo accidentales, pero ofreciendo herramientas claras cuando se necesita flexibilidad explícita:

// Inferencia estricta: $contador se declara e infiere como int
$contador = 0

// Tipado canónico explícito
string $nombre = "JosSecurity"

// Uniones y Nullables seguros
string|null $avatar = null
User? $usuario = null

// Dinamismo consciente solo cuando realmente se requiere
mixed $payload = Request::json()

Todo parámetro de función o método exige un tipo explícito. Se acabaron las funciones con firmas a ciegas donde nadie sabe qué entra ni qué sale.

2. Precisión sin Concesiones: El Tipo Canónico Decimal

Cualquier programador con experiencia sabe que en casi todos los lenguajes tradicionales sumar 0.1 + 0.2 da como resultado 0.30000000000000004. Esto se debe al estándar binario IEEE 754 de los números de coma flotante (float/double). En aplicaciones financieras, pasarelas de pago o tiendas digitales, esos centavos fantasma provocan desastres contables.

En Joss implementé el tipo decimal como primitivo nativo de primera clase. Las operaciones de suma, resta, multiplicación y división son de punto fijo y exactitud absoluta:

decimal $precio = 19.99m
decimal $iva = 0.16m
decimal $total = $precio * (1.0m + $iva)

print("Total exacto sin redondeos extraños: " . $total) // 23.1884m

3. Encapsulamiento Obligatorio y Referencias Efímeras

Inspirado en la disciplina de la POO estricta, en Joss toda función y método requiere obligatoriamente visibilidad explícita (public, private o protected). No existen accesos implícitos accidentales.

Además, incorporé soporte para parámetros por referencia mutable temporal (ref T $variable), permitiendo algoritmos in-place eficientes sin duplicar memoria y bajo garantías estrictas de alcance para evitar fugas de punteros:

public class BufferUtils {
    public static func limpiar(ref string $texto): void {
        $texto = Str::trim($texto)
    }
}

$dato = "   entrada con espacios   "
BufferUtils::limpiar(ref $dato)
// $dato queda limpio en su misma posición de memoria

4. GranDB: Seguridad por Defecto en Bases de Datos

El motor de base de datos nativo de Joss, GranDB, no requiere instalar ORMs pesados de terceros. Viene integrado en el núcleo y compila todas las consultas mediante binding de parámetros de forma inviolable. Las inyecciones SQL quedan descartadas estructuralmente:

$usuarios = GranDB::table("users")
    ->where("status", "active")
    ->whereLike("email", "@empresa.com")
    ->orderByDesc("created_at")
    ->limit(10)
    ->get()

Además, las peticiones HTTP a través de la clase nativa Request procesan encabezados de manera normalizada e insensible a mayúsculas/minúsculas, cumpliendo el estándar RFC y blindando la aplicación contra manipulaciones de cabeceras.

Una Suite de Herramientas Canónica: Cero Configuración

Uno de los mayores retos al crear un lenguaje es el tooling. No quería que Joss fuera solo una especificación teórica, sino un entorno de trabajo con el que pudieras ser productivo desde el minuto uno. Por eso diseñé una suite oficial integrada directamente en el ejecutable:

joss format: Formateador oficial canónico. Formatea archivos en disco y también en memoria a través de la entrada estándar (stdin), vinculándose instantáneamente con Shift + Alt + F y Format on Save en el editor.
joss lint & fix: Analizador semántico que audita tu código, previene variables huérfanas, detecta secretos o contraseñas hardcodeadas y corrige problemas automáticamente con un comando.
joss test: Motor de pruebas unitarias y de integración integrado en el propio runtime, para evaluar aserciones sin paquetes externos.
Extensión Oficial de VS Code: Autocompletado inteligente, diagnósticos de tipos en tiempo real, navegación con Ctrl + Click directo desde controladores a plantillas de vista (View::render, @extends) y 13 comandos en la paleta interactiva.

El Patrón MVC en Acción con Joss

Para demostrar el potencial del lenguaje, desarrollé proyectos completos en producción con él, incluyendo esta misma plataforma web y nuestro constructor visual. Mira lo limpio y legible que resulta un controlador MVC en Joss:

public class ProductController {

    public func list() {
        SEO::title("Catálogo de Productos - Joss")
        
        $productos = GranDB::table("shop_products")
            ->where("status", "approved")
            ->orderBy("price", "ASC")
            ->get()

        return view("shop.index", {
            "products": $productos,
            "total": count($productos)
        })
    }

    public func purchase(mixed $id) {
        (!Auth::check()) ? {
            return redirect("/login")
        } : {}

        $product = GranDB::table("shop_products")->where("id", $id)->first()
        (!$product) ? {
            return response("Producto no encontrado", 404)
        } : {}

        // Concurrencia nativa asíncrona sin bloquear la respuesta al usuario
        async {
            Notification::send("Nueva compra registrada: " . $product["title"])
        }

        return redirect("/checkout/success")
    }
}

Reflexión Final: Una Invitación Abierta a los Desarrolladores

Crear un lenguaje de programación desde sus fundamentos teóricos, pasando por el análisis léxico, el parser de precedencia Pratt, la inferencia de tipos y el motor de ejecución, es probablemente el reto de ingeniería más demandante que he enfrentado. Pero también ha sido el más enriquecedor.

Joss es una declaración de principios: demuestra que no tenemos que aceptar la fragilidad y la sobrecomplejidad como el estándar inevitable de la informática. Se puede tener un desarrollo ágil y moderno sin sacrificar los fundamentos de la ingeniería, la seguridad estricta y el control sobre lo que estamos construyendo.

El proyecto es abierto y está en constante evolución. Los invito a todos a probar el lenguaje, clonar el repositorio, explorar el código fuente, ejecutar el CLI y poner a prueba nuestras herramientas. La verdadera ingeniería se demuestra con código funcionando.

¡Bienvenidos a la iniciativa Joss!

Explorar Documentación Oficial de Joss | Ver Módulos y Ecosistema

La Iniciativa Joss: Rediseñando el Desarrollo Backend hacia un Lenguaje Integral