Hoja de ruta
Lo que viene después
Las versiones a las que apunta el proyecto, desde 0.1.5 en adelante, y para qué es cada una. Esto es un plan — la forma del trabajo que el proyecto se ha impuesto, no un calendario.
Sin fechas, y nada de lo que hay aquí se puede descargar. Cada línea de abajo es una dirección que el proyecto ha elegido; ninguna es un compromiso con un momento, y ninguna es una función que se pueda usar hoy. Lo que se puede instalar es la última versión, y lo que contiene está en el historial de versiones.
El hito más cercano: 0.1.5 Alpha 1
Lo siguiente en la lista no es una función. Su objetivo se enuncia como silencio cero: cada afirmación que hace el lenguaje recibe un veredicto o una prueba que podría demostrarla falsa — nada se describe sin algo que pueda falsar la descripción.
La entrada es un sondeo de lo que otros lenguajes hacen bien — tomado de C, Rust, Java y Python — y el objetivo es que cada línea de ese sondeo acabe decidida. Hay tres veredictos admisibles: copiar el mecanismo; copiar la intención pero no la forma; o rechazarlo sin más, y decir con qué conflicto chocó y qué lado se eligió. Tres frases se tratan como estados de fallo: "sin decidir", "por discutir" y "según las circunstancias" — una línea que acaba en una de ellas no se ha decidido, se ha aplazado, y la regla es que aplazar cuenta como fallar.
Algunas de esas afirmaciones no pueden coexistir, y la parte útil del ejercicio es verse obligado a decir a cuál se renuncia y por qué. Tres de los conflictos merecen nombrarse, porque son aquellos sobre los que este lenguaje se asienta de hecho:
Qué grosor tiene la máquina abstracta
C es lo bastante fino para permitir comportamiento indefinido, y esa finura es lo que compra su velocidad y su portabilidad — el lenguaje no da nada por supuesto. Rust es lo bastante grueso para decidir los préstamos en tiempo de compilación, y ese grosor es lo que compra sus demostraciones — el lenguaje da por supuesto muchísimo. No se pueden maximizar los dos a la vez.
Dónde vive la inteligencia
Java la pone en el runtime, y con ello compra un rendimiento máximo y unas operaciones más simples. La razón de ser de Loment es un programa sin runtime y con un comportamiento predecible. Poner el recolector en el núcleo es renunciar a aquello para lo que existe este lenguaje — por eso la recuperación es una elección por niveles y no una política.
Cuándo se resuelve un nombre
Python resuelve en tiempo de ejecución: sin ceremonias, y se escribe rápido. Java resuelve en tiempo de compilación: herramientas y refactorización fiables. La misma importación no puede comprobarse en tiempo de compilación y no serlo a la vez.
Ninguno de esos tres se resuelve encontrando un término medio ingenioso. Cada uno se resuelve eligiendo un lado y anotando qué costó el otro lado.
Lo que viene después
0.1.5 — la recuperación pasa a ser algo con lo que se puede contar
La escala de recuperación es aquello para lo que sirve 0.1.5: el punto en el que deja de ser un diseño y pasa a ser una propiedad con la que un programa puede contar. La mayor parte de la escala ya está construida — los cuatro peldaños tienen implementación y criterio, el recolector adaptativo y la mitad generacional ya han aterrizado, y las dos implementaciones del lenguaje coinciden en ellos byte a byte. Lo que 0.1.5 añade es la parte que no es una función: darla por zanjada, y poder decir qué garantiza y qué no. La escala en sí se describe en su propia página, que mantiene su propia línea de estado.
0.1.5.x — el runtime queda terminado
El ajuste runtime ya existe, con un valor por defecto, y es
obligatorio en vez de orientativo: pedir el nivel de recuperación que
necesita un recolector mientras se declara que no hay runtime es un error de
compilación, porque los dos se contradicen por definición. Lo que el runtime contiene hoy
es exactamente la parte que ese nivel necesita. Esta línea añade el resto.
0.1.6 — el intérprete llega al paquete
Una segunda forma de ejecutar un programa, en el peldaño más bajo de su escala. Los
peldaños ya están construidos — T0 a T3 viven en el repositorio, cada uno con su
criterio — pero ninguno está todavía en una distribución, y choose vm sigue
sin cambiar lo que emite el compilador. 0.1.6 cierra esa brecha: el intérprete se envía, y
esa página mantiene su propia línea de estado.
0.1.7 — se completa el sistema de objetos
Hoy el lenguaje tiene structs, enums cuyas variantes llevan una sola carga útil, traits despachados de forma estática y genéricos resueltos en tiempo de compilación. Esta línea rellena lo que falta en lugar de añadir algo que nadie ha pedido.
0.1.8 — se completa el sistema de gestión de memoria
Que se apoya en los niveles y la escala anteriores: la recuperación pasa a ser un sistema y no un conjunto de mecanismos.
Más allá de 0.1.8 los epígrafes aún están en fase de planificación, y esta página no va a inventárselos. Una cosa ajena a esta lista se ha anunciado por separado: la próxima versión del propio gestor de paquetes, que se anuncia en su propio repositorio.
Cómo se puede saber si algo de esto ha ocurrido
Una hoja de ruta solo merece leerse si hay una forma de comprobarla más tarde, así que lo honesto es decir dónde tiene lugar esa comprobación. El proyecto no lleva sus planes en un gestor público de incidencias. Los registra como documentos de diseño numerados en el repositorio, y esos documentos están escritos en chino — cosa que conviene saber antes de ir a buscarlos, porque la hoja de ruta no está donde se cabría esperar.
La llegada de cada versión es entonces cuestión de registro y no de anuncio: el historial de versiones dice qué se publicó y cuándo, y cada una de las páginas de abajo lleva su propia línea de estado en lugar de describirse como terminada.