Un evaluador parcial puede convertir un intérprete en un compilador sin que nadie escriba un compilador, y en el caso de la validación de esquemas el propio autor reporta un boost de rendimiento de hasta 5x. Suena a truco académico, pero es una de esas ideas que cambian cómo piensas la arquitectura de tu producto: en lugar de mantener dos implementaciones de la misma lógica, dejas que una se derive de la otra.
El post publicado en jimmyhmiller.com explica el concepto desde cero y anuncia la liberación de un evaluador parcial para JavaScript escrito en Rust. Vale la pena entenderlo aunque nunca vayas a escribir un compilador en tu vida.
¿Qué es la evaluación parcial y por qué importa?
Un evaluador parcial ejecuta por adelantado todo lo que un programa ya puede resolver en tiempo de compilación y deja intacto solo lo que depende de datos que llegan en tiempo de ejecución. No es una optimización cosmética: es una reescritura del programa en su forma más especializada posible.
¿Y esto cómo se aplica en tu negocio?
Dueños de negocio de Latinoamérica y España usan un agente de IA para ganar más y recuperar su tiempo. El Kit «tu mano derecha con IA» te muestra cómo en un video de 11 minutos, con una ficha para armar el tuyo. CAR está cerrada por ahora; al anotarte, te avisamos cuando abra.
👥 Quiero el Kit →El ejemplo que usa el artículo es directo. Con factorial(5) todo es estático, así que el evaluador expande la llamada hasta 5 * (4 * (3 * (2 * 1))) y el resultado queda resuelto antes de que el programa arranque. Con power(process.argv[2], 5) hay una parte que no se puede conocer, pero el evaluador igual reduce el código a process.argv[2] * (process.argv[2] * (process.argv[2] * (process.argv[2] * (process.argv[2] * 1)))): la recursión desaparece y solo queda la estructura dinámica.
Esa es toda la idea. Y de ahí salen consecuencias bastante grandes.
¿Qué son las proyecciones de Futamura?
Son tres resultados que muestran cómo un evaluador parcial puede generar automáticamente un compilador. El post las presenta en pseudocódigo:
- Primera proyección:
partial_eval(interpreter, prog) -> compiled_prog. Le das un intérprete y un programa, y obtienes ese programa ya compilado. - Segunda proyección:
partial_eval(partial_eval, interpreter) -> compiler. Especializas el propio evaluador sobre un intérprete y obtienes un compilador para ese lenguaje. - Tercera proyección:
partial_eval(partial_eval, partial_eval) -> compiler_generator. Un generador de compiladores: le entregas cualquier intérprete y te devuelve su compilador.
El ejemplo concreto del artículo es un intérprete de brainfuck. Al evaluarlo parcialmente junto con un programa, el intérprete desaparece del resultado y queda código equivalente al programa compilado. Con un programa que pide input, la salida es una función que lee process.argv[2], le aplica la aritmética del programa original y devuelve el carácter correspondiente. Nadie escribió un compilador de brainfuck: salió del intérprete.
Por qué esto es más que una curiosidad: escribir un intérprete es mucho más fácil que escribir un compilador, instrumentarlo es más fácil y agregarle features también. Y hay un montón de cosas que se comportan como intérpretes y para las que jamás escribirías un compilador a mano.
El caso que sí toca el bolsillo: validación de esquemas
El ejemplo más aterrizado del post es un validador genérico de esquemas: una función que recibe un esquema y un valor y verifica tipos, longitudes mínimas, arrays y objetos anidados. Es código que cualquier equipo tiene escrito en algún lado.
Aplicada a ese validador, la evaluación parcial genera funciones especializadas para un esquema particular. Según el autor, eso puede dar un boost de rendimiento de 5x cuando los objetos empiezan a complicarse.
La objeción obvia es: entonces escribo esas funciones a mano. El problema aparece cuando los esquemas solo existen en runtime. Ahí te quedan dos caminos malos: compilar en caliente, o mantener en paralelo un compilador y un intérprete de lo mismo. La evaluación parcial baja ese costo de mantenimiento de forma notable, porque el intérprete sigue siendo la única fuente de verdad.
Prepack: la idea que Meta dejó y que alguien revivió
El detonante del artículo fue el anuncio de James Long de que revivió prepack, el evaluador parcial para JavaScript que había desarrollado Meta. El autor cuenta que en su momento tuvo expectativas altas con prepack y terminó decepcionado, porque el proyecto estaba diseñado para la practicidad y no para explorar la belleza del concepto.
Esa decepción es el origen de su propia implementación: un evaluador parcial para JavaScript escrito en Rust, todavía limitado, con versiones parciales de la segunda y tercera proyección funcionando. El autor es explícito en que no busca que se use masivamente, sino que sirva para experimentar con la técnica.
¿Qué significa esto para tu startup?
No necesitas un evaluador parcial para tomar mejores decisiones de arquitectura. La lección transferible es que cada vez que escribes dos versiones de la misma lógica, estás pagando un costo de mantenimiento que se puede evitar.
- Audita dónde tienes intérpretes genéricos. Validadores de esquemas, motores de reglas de negocio, parsers de configuración y DSLs internas son los candidatos típicos. Si el mismo código recorre una estructura genérica en cada request, ahí hay especialización disponible.
- Antes de escribir un compilador propio, pregúntate si puedes derivarlo del intérprete que ya tienes. Una sola base de código significa menos bugs duplicados y menos superficie de testing. El compilador pasa a ser un artefacto generado, no un segundo producto a mantener.
- Si tus reglas o esquemas solo existen en runtime, la especialización en caliente evita mantener dos implementaciones. Es el argumento más fuerte para equipos chicos: no puedes costear dos caminos de código que deben comportarse idéntico.
- Cuidado con la tentación de generar el código especializado con un LLM. La evaluación parcial tiene una ventaja que un modelo no ofrece: la equivalencia semántica con el programa original viene por construcción, no por confianza en la salida. En código que corre en producción, esa garantía vale más que la velocidad de generación.
Conclusión
La evaluación parcial es una de esas ideas que se disfrutan por sí mismas, pero que además dejan una lección práctica: el intérprete es el activo, y las versiones especializadas deberían ser un derivado automático. El anuncio de James Long sobre prepack y la implementación en Rust que acompaña este post muestran que la técnica sigue viva y que hay espacio para experimentar.
Para un founder, la traducción es simple: cada vez que tu equipo escribe la misma lógica dos veces, una genérica y una optimizada, está financiando deuda técnica que una herramienta podría generar sola. Vale la pena mirar dónde están esos duplicados antes de la próxima ronda de optimización de performance.
Las búsquedas realizadas para esta nota no arrojaron datos adicionales verificables sobre el proyecto ni sobre prepack, por lo que el contenido se apoya exclusivamente en la fuente original.
Fuentes
- The Magic of Partial Evaluation (fuente original)
¿Y esto cómo se aplica en tu negocio?
Dueños de negocio de Latinoamérica y España usan un agente de IA para ganar más y recuperar su tiempo. El Kit «tu mano derecha con IA» te muestra cómo en un video de 11 minutos, con una ficha para armar el tuyo. CAR está cerrada por ahora; al anotarte, te avisamos cuando abra.
👥 Quiero el Kit →













