Cuando pensamos en lenguajes para la JVM, solemos meter en la misma bolsa a Java, Scala, Kotlin y Clojure. Después de todo, todos terminan ejecutándose sobre la misma máquina virtual.
Pero hay una diferencia fundamental en cómo están construidos.
Scala y Kotlin generan bytecode JVM de manera bastante directa. Clojure, en cambio, adopta una filosofía distinta: es un hosted language, es decir, un lenguaje "hospedado" sobre la plataforma Java.
¿Y qué significa eso? ¿Tiene ventajas? ¿Tiene costos?
Lenguajes como Java, Scala o Kotlin siguen aproximadamente este esquema:
Código fuente
↓
Compilador
↓
Bytecode JVM (.class)
↓
JVM
Muchas características del lenguaje se traducen directamente en clases, métodos y bytecode especializado.
Por ejemplo, una case class de Scala:
case class Person(name: String)
genera automáticamente métodos como:
- equals()
- hashCode()
- copy()
- toString()
Todo esto queda representado directamente en bytecode.
Clojure también produce bytecode JVM, pero gran parte del comportamiento del lenguaje vive en su runtime:
Código Clojure
↓
Compilador
↓
Bytecode + Runtime de Clojure
↓
JVM
Por eso Rich Hickey describe a Clojure como un hosted language.
La plataforma Java no es solamente un destino de compilación: es el ecosistema sobre el cual está construido el lenguaje.
Ventaja: Aprovecha toda la plataforma Java
Desde Clojure podemos usar directamente cualquier clase Java:
(import java.time.LocalDate)
(LocalDate/now)
No hay puentes especiales ni adaptadores.
Clojure reutiliza:
- la JVM;
- el recolector de basura;
- las bibliotecas Java;
- los hilos;
- las excepciones;
- las herramientas de profiling;
- todo el ecosistema existente.
En vez de reinventar la rueda, se apoya en ella.
Ventaja: Un compilador relativamente pequeño
Muchas características importantes de Clojure viven en bibliotecas y no en el compilador:
- secuencias perezosas;
- colecciones persistentes;
- STM;
- transducers.
Esto hace que el compilador sea considerablemente más sencillo que los de Scala o Kotlin.
Ventaja: Desarrollo interactivo y REPL
Una de las mayores fortalezas de Clojure es su modelo de desarrollo interactivo.
Podemos definir una función:
(defn cuadrado [x]
(* x x))
y cargarla inmediatamente en la REPL, sin recompilar todo el proyecto.
Este enfoque favorece:
- feedback rápido;
- hot reloading;
- experimentación;
- desarrollo incremental.
Ventaja: Evolución mediante librerías
Muchas características avanzadas de Clojure se agregaron sin modificar demasiado el lenguaje:
- transducers;
- core.async;
- spec;
- STM.
Al depender más del runtime y menos del compilador, la evolución del ecosistema suele ser más flexible.
Las desventajas
Menos optimizaciones
Scala y Kotlin generan bytecode más especializado.
En Clojure, muchas operaciones pasan por componentes del runtime como:
- IFn;
- PersistentVector;
- PersistentMap;
- RT.
Esto introduce niveles adicionales de indirección y, en ciertos casos, puede afectar el rendimiento.
Más reflexión
Si escribimos:
(defn largo [s]
(.length s))
el compilador puede recurrir a reflexión.
Podemos ayudarlo con type hints:
(defn largo [^String s]
(.length s))
pero esto requiere intervención del programador.
Menos comprobaciones en tiempo de compilación
Scala y Kotlin verifican muchas cosas antes de ejecutar:
- tipos;
- nulabilidad;
- exhaustividad del pattern matching;
- restricciones genéricas.
Clojure, al ser dinámico, detecta muchos errores recién en tiempo de ejecución.
Interoperabilidad asimétrica
Desde Clojure usar Java es muy fácil.
Pero desde Java consumir código Clojure no es tan natural:
IFn plus = Clojure.var("myns", "plus");
Mientras que una clase escrita en Scala o Kotlin suele verse como una clase Java convencional.
Dos filosofías distintas
No es que una aproximación sea mejor que la otra.
Scala y Kotlin intentan enriquecer la JVM mediante compiladores sofisticados y bytecode especializado.
Clojure adopta otra filosofía: construir un lenguaje pequeño y dinámico que reutilice al máximo la plataforma existente.
Al final, la diferencia más interesante no es a qué compilan, porque todos terminan ejecutándose en la JVM.
La verdadera diferencia es: ¿Cuánto del lenguaje vive en el compilador y cuánto vive en el runtime?
Y en esa decisión de diseño está gran parte de la personalidad de Clojure.
No hay comentarios.:
Publicar un comentario