Translate

Mostrando las entradas con la etiqueta Java. Mostrar todas las entradas
Mostrando las entradas con la etiqueta Java. Mostrar todas las entradas

sábado, 14 de noviembre de 2026

Records en Java: qué podemos hacer y cuáles son sus limitaciones


Los record llegaron en Java 16 para simplificar la creación de clases cuyo objetivo principal es representar datos. Evitan tener que escribir constructores, getters, equals(), hashCode() y toString() manualmente.


Pero ¿son simplemente clases más cortas? No exactamente. Tienen algunas restricciones importantes, especialmente cuando hablamos de herencia.

Supongamos que queremos representar un usuario:


public record Usuario(String nombre, int edad) {

}


Java genera automáticamente:

  • Un constructor con los componentes declarados.
  • Los métodos de acceso nombre() y edad().
  • Las implementaciones de equals(), hashCode() y toString().


Podemos utilizarlo así:


Usuario usuario = new Usuario("Ana", 30);

System.out.println(usuario.nombre());

System.out.println(usuario.edad());

System.out.println(usuario);


Observá que los métodos de acceso no siguen la convención tradicional de JavaBeans: se llaman nombre() y edad(), no getNombre() y getEdad().

Además, los componentes de un record son implícitamente final: no podemos reasignar sus valores después de construir la instancia.

¿Un record puede heredar de otra clase? No. Un record no puede extender una clase definida por nosotros.

En Java, los records heredan implícitamente de java.lang.Record. Por eso, esta declaración no es válida:


class Persona {

    String nombre;

}


record Usuario(String nombre, int edad)

        extends Persona { // Error de compilación

}


Tampoco podemos declarar explícitamente extends Record, porque esa herencia ya está definida por el lenguaje.

Esta restricción permite que los records tengan una estructura de datos bien definida y evita que se introduzca una jerarquía de clases que contradiga su modelo.

Por lo tanto, si necesitamos herencia de implementación entre clases, un record probablemente no sea la herramienta adecuada.

¿Un record puede implementar una interfaz? Sí. Un record puede implementar una o varias interfaces, igual que una clase convencional.


Por ejemplo:


interface Identificable {

    Long id();

}


public record Usuario(Long id, String nombre)

        implements Identificable {

}


El método id() exigido por la interfaz ya existe porque es un accesor generado automáticamente para el componente id.


También podemos implementar interfaces que requieran comportamiento:


interface Saludable {

    boolean estaActivo();

}


public record Usuario(String nombre, boolean activo)

        implements Saludable {


    @Override

    public boolean estaActivo() {

        return activo;

    }

}


Esto resulta especialmente útil cuando queremos aprovechar el polimorfismo sin necesitar herencia de clases.


¿Podemos agregar métodos a un record? Sí. Un record no se limita a almacenar datos: también puede contener lógica de negocio.


public record Rectangulo(double ancho, double alto) {


    public double area() {

        return ancho * alto;

    }

}

Podemos utilizarlo así:


Rectangulo rectangulo = new Rectangulo(5, 3);


System.out.println(rectangulo.area()); // 15.0


También podemos declarar métodos estáticos, constructores adicionales y constructores compactos para validar los datos.


Por ejemplo:


public record Usuario(String nombre, int edad) {


    public Usuario {

        if (nombre == null || nombre.isBlank()) {

            throw new IllegalArgumentException(

                "El nombre es obligatorio"

            );

        }


        if (edad < 0) {

            throw new IllegalArgumentException(

                "La edad no puede ser negativa"

            );

        }

    }

}


El constructor compacto permite validar los componentes sin tener que escribir las asignaciones correspondientes: Java las realiza automáticamente después de ejecutar su cuerpo.


¿Podemos modificar los componentes de un record?

No podemos reasignar directamente sus componentes una vez construida la instancia:


Usuario usuario = new Usuario("Ana", 30);

usuario.nombre = "María"; // Error


Sin embargo, hay una distinción importante: que los componentes sean final no significa que todos los objetos referenciados sean inmutables.


public record Grupo(List<String> integrantes) {

}


En este caso no podemos reasignar integrantes, pero sí podríamos modificar la lista si es mutable:


Grupo grupo = new Grupo(new ArrayList<>());

grupo.integrantes().add("Ana");


Si queremos proteger la colección, podemos realizar una copia defensiva:


public record Grupo(List<String> integrantes) {


    public Grupo {

        integrantes = List.copyOf(integrantes);

    }

}


Así evitamos que modificaciones posteriores sobre la lista original o sobre la lista devuelta alteren el contenido del grupo.


¿Podemos redefinir equals() y otros métodos?

Sí, aunque generalmente no es necesario. Java genera automáticamente equals(), hashCode() y toString() utilizando los componentes del record.

Podemos redefinir estos métodos si tenemos un motivo concreto. También podemos declarar constructores adicionales, siempre que respeten las reglas del lenguaje.

Lo que no podemos hacer es declarar instancias adicionales de campos de estado arbitrarios: los campos de instancia de un record corresponden a sus componentes. Sí podemos declarar campos estáticos.


¿Cuándo conviene usar records? 

Los records son una buena opción para:

  • DTOs utilizados en APIs REST.
  • Valores que se pasan entre capas de una aplicación.
  • Resultados de consultas.
  • Representar coordenadas, importes u otros valores.
  • Modelar datos que deben tener una estructura explícita y estable.


En cambio, una clase convencional puede ser más apropiada cuando necesitamos herencia de implementación, estado mutable o un ciclo de vida complejo.


Los records no son simplemente una forma abreviada de escribir clases. Son una característica del lenguaje diseñada para representar datos con una estructura explícita.

Podemos agregarles comportamiento e implementar interfaces, pero no podemos extender otras clases ni modificar la referencia de sus componentes.

miércoles, 14 de octubre de 2026

Arrow Code: cuando demasiados if hacen que el código apunte en la dirección equivocada


Durante mucho tiempo se enseñó que una función debía tener un único `return`. La idea era sencilla: si una función tiene varios puntos de salida, resulta más difícil seguir su ejecución y entender qué sucede en cada caso.


Pero aplicar esta regla de manera estricta puede llevarnos a otro problema: anidar demasiados condicionales para evitar múltiples retornos.

Esta práctica tiene nombre: Arrow Code.

Imaginemos que tenemos que ejecutar una operación si un usuario existe, está activo, tiene permisos y el recurso está disponible.


Una primera implementación podría ser la siguiente:


public void ejecutar(Usuario usuario, Recurso recurso) {

    if (usuario != null) {

        if (usuario.estaActivo()) {

            if (usuario.tienePermiso()) {

                if (recurso.estaDisponible()) {

                    ejecutarOperacion();

                }

            }

        }

    }

}


El código funciona, pero a medida que agregamos condiciones, la indentación crece y la lógica se vuelve más difícil de seguir.


En el peor de los casos, terminamos con una estructura que visualmente se parece a una flecha:


if

 └── if

      └── if

           └── if

                └── if

                     └── ...


Este estilo se conoce como Arrow Code. No es simplemente una cuestión estética: las condiciones anidadas dificultan identificar qué requisitos deben cumplirse y qué sucede cuando alguno falla.

Podemos reescribir el método utilizando Guard Clauses (cláusulas de guarda).

La idea es evaluar primero las condiciones que impiden continuar y salir inmediatamente cuando alguna no se cumple.


public void ejecutar(Usuario usuario, Recurso recurso) {

    if (usuario == null) return;

    if (!usuario.estaActivo()) return;

    if (!usuario.tienePermiso()) return;

    if (!recurso.estaDisponible()) return;


    ejecutarOperacion();

}


Ahora el código expresa las condiciones de manera secuencial. Una vez superadas todas las validaciones, llegamos directamente a la operación principal.

En lugar de preguntar repetidamente si podemos continuar, comprobamos primero por qué no deberíamos hacerlo.

¿Pero no era malo tener muchos return? La recomendación de utilizar un único punto de salida no surgió de la nada. En determinados lenguajes y contextos históricos, tener múltiples puntos de salida podía complicar el razonamiento sobre el flujo de ejecución y la liberación de recursos.

Sin embargo, eso no significa que varios return sean siempre una mala práctica.

En los lenguajes modernos, con mecanismos como RAII en C++, try-with-resources en Java y otras herramientas de gestión de recursos, es posible utilizar retornos tempranos sin abandonar recursos en estados inconsistentes, siempre que se respeten las garantías del lenguaje y de las abstracciones utilizadas.

Además, una función con varios retornos tempranos puede ser mucho más sencilla de entender que otra que concentra toda su lógica en un único punto de salida.

La cuestión no es cuántos return tiene una función, sino cuánto esfuerzo requiere comprenderla.

¿Significa que siempre debemos evitar los if anidados? No. El anidamiento es natural cuando representa una relación real entre operaciones.

Por ejemplo, si primero debemos comprobar que existe una conexión para luego consultar su estado, puede tener sentido agrupar ambas operaciones. También hay algoritmos cuya estructura depende naturalmente de decisiones anidadas.

El problema aparece cuando acumulamos niveles de indentación únicamente para respetar una regla formal, o cuando mezclamos demasiadas validaciones con la lógica principal del método.

Tampoco conviene reemplazar cualquier condicional por un return sin pensar en las responsabilidades del método, sus efectos secundarios o las reglas de negocio.


sábado, 19 de septiembre de 2026

Java 27: hacia dónde está evolucionando Java

 


Java cambió hace tiempo su ritmo de evolución.

Ya no tenemos que esperar varios años para ver cambios importantes en el lenguaje. Desde Java 10, el JDK recibe una nueva versión cada seis meses.

Y esto produjo algo interesante: las grandes funcionalidades dejaron de aparecer todas juntas y comenzaron a evolucionar durante varias versiones.


Un buen ejemplo son los patrones, la concurrencia estructurada, los valores lazy o las mejoras de rendimiento de la JVM.

Java 25, Java 26 y Java 27 muestran bastante bien hacia dónde está avanzando el lenguaje.


Java 25: un nuevo LTS

Java 25 llegó en septiembre de 2025 y es una versión LTS.

Entre sus novedades hay cambios tanto en el lenguaje como en la JVM y las bibliotecas.


Archivos fuente más simples: Java 25 incorporó los Compact Source Files and Instance Main Methods.

Ahora un programa pequeño puede escribirse de una manera mucho más sencilla:


void main() {

    System.out.println("Hello Java!");

}


Ya no es necesario comenzar con:


public class Main {

    public static void main(String[] args) {

        System.out.println("Hello Java!");

    }

}


La idea no es crear un nuevo lenguaje para principiantes, sino permitir que Java pueda comenzar siendo pequeño y crecer posteriormente hacia el modelo tradicional.


Module Import Declarations


También apareció:

import module java.base;


En lugar de importar individualmente paquetes como:


import java.util.*;

import java.io.*;

import java.nio.*;


se puede importar todo lo exportado por un módulo.


Es especialmente interesante para programas pequeños y ejemplos, donde el ruido de los imports puede ser considerable.


Flexible Constructor Bodies


Java también flexibilizó los constructores.


Antes:

class Person extends Entity {


    Person(String name) {

        super(name);

    }

}


El constructor tenía que comenzar con super(...) o this(...).


Java 25 permite realizar ciertas operaciones antes de esa invocación explícita:


class Person extends Entity {


    Person(String name) {

        name = name.trim();


        super(name);

    }

}



Esto permite validar o preparar datos antes de construir la parte correspondiente a la superclase.


Scoped Values


Otra característica importante de Java 25 fue Scoped Values.

Son una alternativa a ThreadLocal para compartir datos inmutables dentro de un contexto de ejecución.

Esto resulta especialmente interesante cuando se combinan con Virtual Threads y Structured Concurrency.

Es decir, Java empieza a construir un modelo de concurrencia más coherente alrededor de estas nuevas abstracciones.


Y la JVM también sigue cambiando


Java 25 no fue solamente lenguaje.

Por ejemplo, incorporó Compact Object Headers, que permiten reducir el tamaño de las cabeceras de los objetos en arquitecturas de 64 bits.

También continuó el trabajo de Project Leyden, orientado a mejorar startup y warmup mediante mecanismos AOT.


Java 26: menos sintaxis, más JVM

Java 26 llegó en marzo de 2026.

A diferencia de Java 25, no es una versión LTS, pero continuó varias de las líneas iniciadas en versiones anteriores.

Una de las novedades más interesantes fue HTTP/3 en el HTTP Client API.

El cliente HTTP de Java ahora puede trabajar con HTTP/3 sin necesidad de utilizar una biblioteca externa específica para ese protocolo.


Por ejemplo, seguimos teniendo una API similar a:


HttpClient client = HttpClient.newHttpClient();


HttpRequest request =

    HttpRequest.newBuilder(uri)

        .build();


HttpResponse<String> response =

    client.send(request, BodyHandlers.ofString());


pero el JDK amplía las posibilidades de transporte disponibles.

Esto es especialmente interesante para aplicaciones Java que funcionan como clientes de APIs y microservicios.


Project Leyden sigue avanzando

Java 26 continuó el trabajo de AOT Object Caching.

La JVM puede almacenar objetos previamente inicializados en una caché AOT y reutilizarlos durante el arranque.

La diferencia importante es que Java 26 permite hacerlo independientemente del Garbage Collector utilizado, incluyendo ZGC.


La dirección es clara: Java quiere arrancar más rápido sin abandonar el modelo dinámico de la JVM.


Java 26 también incorporó mejoras al Garbage Collector G1 para reducir sincronización y aumentar el throughput.

Y esto prepara el terreno para Java 27, donde G1 pasa a ser el GC predeterminado en todos los entornos.


Java 26 también comenzó a preparar un cambio importante relacionado con los campos final.

El JDK empezó a emitir advertencias cuando se utiliza reflexión profunda para modificar campos final. La intención es avanzar hacia un Java donde final signifique realmente que el campo no puede modificarse mediante estos mecanismos.

Es otro ejemplo de una tendencia importante de integridad y optimización por defecto.


Y llegamos a Java 27

Java 27 continúa muchas de estas ideas.

No es una revolución sintáctica.

De hecho, es bastante más interesante observar qué problemas está intentando resolver.


Entre las principales novedades de Java 27 encontramos nueve JEPs, incluyendo características definitivas y varias que continúan como preview o incubator.


Compact Object Headers por defecto

Java 25 introdujo los Compact Object Headers como una funcionalidad que había que activar explícitamente.

Java 27 da el siguiente paso:pasan a estar habilitados por defecto.

La cabecera tradicional de un objeto podía ocupar 96 bits en determinadas configuraciones.

Con Compact Object Headers puede reducirse a 64 bits.

Esto significa menos memoria por objeto y potencialmente mejor densidad de datos en el heap.

Y lo interesante es que:no necesitamos modificar nuestro código.

Es una mejora de la JVM.


G1 pasa a ser el Garbage Collector por defecto en todos los entornos

G1 ya era el Garbage Collector predeterminado desde Java 9 en la mayoría de los casos.

Java 27 elimina las excepciones para máquinas pequeñas.

Ahora G1 pasa a ser el GC por defecto independientemente de la cantidad de CPU o memoria disponible.


Esto muestra otra tendencia: La JVM cada vez necesita menos configuración manual para obtener un comportamiento razonable.


Structured Concurrency sigue evolucionando

Structured Concurrency aparece nuevamente en Java 27 como séptimo preview.

La idea es tratar un conjunto de tareas concurrentes como una única unidad de trabajo.

Por ejemplo, imaginemos que para construir una respuesta necesitamos consultar:


              ┌── usuario

              │

Request ┼── pedidos

              │

              └── recomendaciones


Podemos ejecutar las tres operaciones concurrentemente.

Pero queremos que tengan una relación estructurada:

  • si una falla, podemos cancelar las demás;
  • esperamos a que terminen;
  • propagamos correctamente los errores;
  • no dejamos tareas ejecutándose accidentalmente.


Ese es precisamente el tipo de problema que Structured Concurrency intenta resolver.

Y tiene una relación natural con Virtual Threads.

Java no está solamente haciendo que crear threads sea barato.

Está intentando mejorar la forma en que pensamos la concurrencia.


Lazy Constants

Los Stable Values de Java 25 evolucionaron en Java 26 hacia Lazy Constants y continúan evolucionando en Java 27.


La idea es interesante: queremos un valor que sea inmutable después de inicializarse, pero cuya inicialización pueda retrasarse hasta que realmente sea necesario.


Conceptualmente:


LazyConstant<Connection> connection =

    LazyConstant.of(() -> createConnection());


La conexión no se crea necesariamente al construir el objeto.

Se crea cuando realmente se necesita.

Y una vez inicializada, permanece estable.

Es una forma más limpia de resolver ciertos casos que tradicionalmente terminábamos implementando con inicialización lazy, sincronización o double-checked locking.


Primitive Types + Pattern Matching


El pattern matching continúa su evolución.

Java 27 vuelve a presentar como preview la posibilidad de trabajar con tipos primitivos dentro de instanceof, switch y patrones.

Es la continuación de una evolución que comenzó varias versiones atrás.

La dirección es bastante clara:


switch (value) {

    case int i -> ...

    case long l -> ...

}


La intención es que el sistema de pattern matching sea cada vez más uniforme y no tenga una separación artificial entre tipos referencia y tipos primitivos.


Criptografía preparada para el mundo post-cuántico

Java 27 también incorpora soporte para Post-Quantum Hybrid Key Exchange en TLS 1.3.

La idea es combinar algoritmos tradicionales con algoritmos resistentes a ataques cuánticos.

Esto apunta a un problema que hoy parece lejano, pero que en seguridad ya se considera relevante: harvest now, decrypt later.


Un atacante puede almacenar tráfico cifrado hoy y tratar de descifrarlo en el futuro cuando disponga de tecnología suficiente.

Java empieza a preparar la infraestructura criptográfica para ese escenario.


JFR puede ocultar información sensible

Java Flight Recorder también recibe una mejora importante.

Java 27 incorpora JFR In-Process Data Redaction.

La idea es evitar que información sensible presente en argumentos, propiedades o variables de entorno termine accidentalmente en una grabación de JFR.


Por ejemplo:

PASSWORD=...

TOKEN=...

API_KEY=...


El objetivo es mejorar la observabilidad sin convertir los mecanismos de diagnóstico en una nueva fuente de filtraciones.


Entonces, ¿hacia dónde está evolucionando Java?

Si miramos Java 25, 26 y 27 en conjunto, aparece una imagen bastante interesante.

Java no está intentando convertirse en otro lenguaje.

La JVM intenta hacerse más inteligente para que el código Java pueda permanecer relativamente simple.

También consiste en conseguir que el mismo código Java sea más rápido, consuma menos memoria, arranque antes, sea más seguro y sea más fácil de escribir.


Y Java 27 continúa exactamente en esa dirección.


miércoles, 12 de agosto de 2026

¿Qué son los Text Blocks de Java? JEP 378


Durante mucho tiempo, trabajar con texto multilínea en Java significó llenar el código de `\n`, concatenaciones y escapes:


String json = "{\n" +

              "  \"name\": \"Emanuel\",\n" +

              "  \"language\": \"Java\"\n" +

              "}";


A partir de Java 15, esto cambió con JEP 378: Text Blocks.


Ahora podemos escribir:


String json = """

        {

          "name": "Emanuel",

          "language": "Java"

        }

        """;


Mucho más parecido al texto que realmente queremos representar.

Pero no son simplemente strings multilínea


Lo interesante de los Text Blocks está en cómo Java decidió tratar la indentación y los espacios.


Por ejemplo:

String text = """

        Hello

        World

        """;


El resultado es:

Hello

World


La indentación que utilizamos para mantener prolijo nuestro código Java no pasa automáticamente al String.

Java distingue entre el whitespace incidental, necesario para organizar el código fuente, y el whitespace que realmente forma parte del contenido.

Esto permite escribir código legible sin terminar con espacios innecesarios dentro del texto.

¿Y si realmente necesito espacios? Podemos utilizar `\s`.


String text = """

        Hello\s

        World

        """;


Ese \s representa un espacio que queremos conservar explícitamente.

También existe una particularidad interesante con \:


String text = """

        Hello \

        World

        """;


Aquí el \ evita que el salto de línea del código fuente se convierta en un salto de línea del String.


El resultado es:

Hello World


Es decir, los Text Blocks no solamente agregan una nueva sintaxis: agregan herramientas para controlar exactamente cómo se transforma el código fuente en el contenido del String.

Uno de los casos donde más se nota la diferencia es al trabajar con formatos que naturalmente ocupan varias líneas.


String json = """

        {

          "name": "Emanuel",

          "language": "Java",

          "version": 25

        }

        """;


String sql = """

        SELECT id, name

        FROM users

        WHERE active = true

        ORDER BY name

        """;


String html = """

        <html>

          <body>

            <h1>Hello Java</h1>

          </body>

        </html>

        """;


El código se parece mucho más al documento que estamos representando.

Y podemos combinarlos con String.formatted():


String message = """

        Hello %s!


        Welcome to %s.

        """.formatted("Emanuel", "Java");


Esto resulta especialmente cómodo para generar pequeños fragmentos de texto estructurado.

Text Blocks fueron introducidos como preview en Java 13, tuvieron una segunda preview en Java 14 y finalmente se convirtieron en una feature estándar en Java 15, mediante JEP 378.


Y hay algo interesante detrás de esta evolución.

La feature parece pequeña, pero obligó a Java a resolver cuestiones bastante delicadas:

  • ¿Qué espacios forman parte del texto?
  • ¿Qué indentación pertenece al código y cuál al contenido?
  • ¿Cómo representar un salto de línea?
  • ¿Cómo conservar espacios al final?
  • ¿Cómo evitar que escribir un texto multilínea produzca un String lleno de whitespace accidental?


Por eso, los Text Blocks son un buen ejemplo de algo que parece ser simplemente syntax sugar, pero que en realidad requiere bastante diseño del lenguaje.

Los Text Blocks permiten escribir strings multilínea de una manera mucho más natural:


String text = """

        Este es un texto

        de varias líneas

        escrito directamente

        en Java.

        """;


Pero lo importante de JEP 378 no es solamente el """.

Es la decisión de que la representación visual del texto en el código fuente y el contenido real del String no tienen por qué ser exactamente lo mismo.

Y ahí está probablemente la parte más interesante de esta feature: Java agregó una sintaxis para escribir texto como texto, sin abandonar el control preciso sobre whitespace y terminadores de línea.

miércoles, 29 de julio de 2026

Open DI: ¿el futuro de CDI impulsado por Micronaut?



Durante muchos años, CDI (Contexts and Dependency Injection) fue una de las tecnologías que definieron el desarrollo empresarial en Java. Frameworks como Jakarta EE, Quarkus y Helidon la adoptaron como base para construir aplicaciones modernas.

Sin embargo, el ecosistema siempre tuvo una tensión difícil de resolver: la flexibilidad de CDI frente al costo de su modelo de ejecución.

Gran parte de las implementaciones tradicionales dependen de escaneo del classpath, reflexión y generación dinámica de proxies. Ese enfoque ofrece una enorme potencia, pero también incrementa el tiempo de arranque, el consumo de memoria y complica escenarios como GraalVM y las aplicaciones cloud-native.

Con el lanzamiento de Micronaut 5.1, aparece una iniciativa que puede cambiar este panorama: Open DI (ODI).

Open DI es un proyecto de Eclipse EE4J que implementa Jakarta CDI Lite, pero utilizando la infraestructura de inyección de dependencias compile-time desarrollada por Micronaut.

En otras palabras, la API que utiliza el desarrollador es la de CDI, mientras que el motor que genera los beans y los proxies trabaja durante la compilación, aprovechando el sistema de annotation processors de Micronaut.

Esto significa que una aplicación puede escribir código utilizando las anotaciones estándar de CDI como:

@Inject

@Singleton

@ApplicationScoped

@Produces


pero obtener las ventajas de una resolución de dependencias prácticamente libre de reflexión en tiempo de ejecución.

Desde sus primeras versiones, Micronaut apostó por una idea muy clara: Todo lo que pueda resolverse durante la compilación no debería hacerse durante la ejecución.

Ese principio permitió conseguir tiempos de inicio extremadamente bajos y un consumo reducido de memoria, dos características muy valoradas en microservicios y funciones serverless.

Hasta ahora, esa infraestructura era exclusiva del ecosistema Micronaut.

Con Open DI, esa tecnología comienza a exponerse mediante una implementación estándar de CDI Lite.

Lo interesante no es solamente que exista otra implementación de CDI.

Lo realmente novedoso es que el modelo tradicional de CDI comienza a separarse de la idea de un contenedor basado en reflexión.

Open DI demuestra que es posible implementar la especificación utilizando generación de código durante la compilación.

Eso abre la puerta a aplicaciones que conservan la portabilidad del estándar pero con características mucho más atractivas para entornos cloud-native.

¿Y ... CDI Lite y no CDI Full? Sí. Open DI implementa CDI Lite, no la especificación completa.

Eso implica que algunas capacidades avanzadas de CDI Full, como ciertas extensiones portables, decorators o passivation, quedan fuera del alcance del proyecto.

Pero probablemente esa sea una decisión deliberada.

La mayoría de las aplicaciones modernas utilizan solamente una parte relativamente pequeña del enorme conjunto de funcionalidades que ofrece CDI Full. Apostar por CDI Lite permite simplificar la implementación y mantener el foco en el rendimiento.


El anuncio de Micronaut 5.1 prácticamente esconde una de sus novedades más importantes. Micronaut 5.1 hace posible el lanzamiento de Open DI 1.0.

Para lograrlo, el framework incorporó nuevos puntos de integración ("CDI integration hooks") dentro de su infraestructura de inyección de dependencias.

No se trata simplemente de un proyecto externo utilizando Micronaut, sino de una colaboración donde la propia arquitectura del framework evoluciona para permitir una implementación estándar de CDI.


Es demasiado pronto para saber si Open DI tendrá una adopción masiva. Pero conceptualmente resulta muy interesante.

 Durante años parecía que había que elegir entre dos caminos:

  • utilizar un estándar como CDI;
  • o utilizar un framework optimizado para compilación como Micronaut.


Open DI intenta combinar ambos mundos.

Si el proyecto madura y mantiene compatibilidad con la especificación, podríamos comenzar a ver aplicaciones que escriben código estándar de Jakarta CDI mientras aprovechan una infraestructura de ejecución mucho más eficiente.

No sería la primera vez que una innovación nacida en un framework termina influyendo sobre todo el ecosistema Java. Quizás Open DI sea otro ejemplo de ello.


Más allá de si termina convirtiéndose o no en una implementación ampliamente adoptada, Open DI representa algo muy valioso: demuestra que los estándares también pueden evolucionar.

Durante mucho tiempo asociamos CDI con reflexión, escaneo del classpath y contenedores pesados. Open DI desafía esa idea y propone una implementación basada en generación de código en tiempo de compilación.

Si esa visión prospera, el futuro de la inyección de dependencias en Java podría parecerse mucho más a Micronaut de lo que imaginábamos.


Dejo links: 

https://github.com/eclipse-ee4j/odi#open-di

https://micronaut.io/2026/07/27/micronaut-framework-5-1-0-release/


miércoles, 8 de julio de 2026

Construyendo Aplicaciones Inteligentes con LangChain4j y Spring boot


LangChain4j es una poderosa biblioteca para crear aplicaciones que integran grandes modelos de lenguaje (LLMs) de manera estructurada y eficiente. Basado en el éxito de LangChain en el ecosistema de Python, LangChain4j lleva estas capacidades al mundo de Java, facilitando el desarrollo de aplicaciones que usan IA generativa.

Ya hablamos de LangChain4j

Creamos un proyecto básico de Spring Boot con módulos como Web y Configuration y luego agregamos la dependencia con maven:

   <dependency>

       <groupId>io.github.langchain4j</groupId>

       <artifactId>langchain4j</artifactId>

       <version>0.2.0</version>

   </dependency>


Configura tu proveedor de modelo, como OpenAI:


import io.github.langchain4j.model.openai.OpenAiChatModel;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;


@Configuration

public class LangChainConfig {


    @Bean

    public OpenAiChatModel openAiChatModel() {

        return OpenAiChatModel.builder()

                .apiKey("TU_CLAVE_API")

                .temperature(0.7)

                .maxTokens(500)

                .build();

    }

}


Implemente un controlador para manejar las solicitudes de los usuarios.


import io.github.langchain4j.model.openai.OpenAiChatModel;

import org.springframework.web.bind.annotation.*;


@RestController

@RequestMapping("/api/chat")

public class ChatController {


    private final OpenAiChatModel chatModel;


    public ChatController(OpenAiChatModel chatModel) {

        this.chatModel = chatModel;

    }


    @PostMapping

    public String chat(@RequestBody String userInput) {

        return chatModel.chat(userInput).getContent();

    }

}


Ejecuta la aplicación Spring Boot y envía una solicitud POST a `/api/chat`:


curl -X POST http://localhost:8080/api/chat LangChain es un marco diseñado para trabajar con modelos de lenguaje para crear aplicaciones avanzadas de IA.

Para agregar memoria a las conversaciones:


import io.github.langchain4j.memory.ChatMemory;

import io.github.langchain4j.memory.InMemoryChatMemory;

import org.springframework.context.annotation.Bean;


@Configuration

public class LangChainConfig {


    @Bean

    public ChatMemory chatMemory() {

        return new InMemoryChatMemory();

    }

}


En el controlador, utiliza el ChatMemory para mantener el contexto entre solicitudes:


import io.github.langchain4j.memory.ChatMemory;


@RestController

@RequestMapping("/api/chat")

public class ChatController {


    private final OpenAiChatModel chatModel;

    private final ChatMemory chatMemory;


    public ChatController(OpenAiChatModel chatModel, ChatMemory chatMemory) {

        this.chatModel = chatModel;

        this.chatMemory = chatMemory;

    }


    @PostMapping

    public String chat(@RequestBody String userInput) {

        chatMemory.addUserMessage(userInput);

        String response = chatModel.chat(userInput).getContent();

        chatMemory.addAiMessage(response);

        return response;

    }

}


LangChain4j es una herramienta poderosa para desarrollar aplicaciones inteligentes en Java. Combinado con Spring, puedes crear servicios escalables que aprovechen lo mejor de la IA generativa. Desde aplicaciones conversacionales hasta sistemas de soporte, las posibilidades son infinitas.

viernes, 3 de julio de 2026

Diseñando MateScript: un JavaScript de tipado estático para la JVM


Hace tiempo que me interesa el diseño de lenguajes de programación.

No solamente cómo construir compiladores, sino también cómo tomar decisiones sobre la sintaxis, el sistema de tipos y la experiencia de desarrollo.

Por eso decidí comenzar un proyecto experimental: MateScript.


¿Qué es MateScript?

MateScript es un lenguaje inspirado en JavaScript, pero con tipado estático y compilación a bytecode JVM.

JavaScript es uno de los lenguajes más populares del mundo, pero también arrastra varios problemas derivados de sus decisiones históricas.


Por ejemplo:

let age = 42;

age = "hola";


Esto es perfectamente válido.

MateScript buscará detectar estos problemas durante la compilación.


let age = 42;

age = "hola";


Resultado:

Type mismatch: expected Int found String


MateScript intentará mantener las características más atractivas de JavaScript:

  • Sintaxis sencilla
  • Funciones de primera clase
  • Lambdas
  • Inferencia de tipos
  • Programación funcional
  • Objetos


Pero agregando:

  • Tipado estático
  • Null Safety
  • Pattern Matching
  • Compilación a bytecode JVM
  • Interoperabilidad con Java


¿Por qué no usar TypeScript?

TypeScript es una excelente herramienta.

Sin embargo, sigue dependiendo del ecosistema JavaScript.


El objetivo de MateScript es diferente:

  • Compilar directamente a bytecode JVM
  • Ejecutarse sin Node.js
  • Integrarse con bibliotecas Java
  • Aprovechar el rendimiento y madurez de la plataforma JVM


Primeras decisiones de diseño

Variables inmutables por defecto

let name = "Emanuel";


Una variable declarada con let no podrá modificarse.


Para variables mutables utilizaremos:

var counter = 0;


Inferencia de tipos

No será necesario declarar tipos explícitamente.


let age = 42;


El compilador inferirá:

Int


Funciones

La sintaxis será muy similar a JavaScript.


function greet(name: String): String {

    return "Hola " + name;

}


Lambdas

let square = x => x * x;


Null Safety

Los tipos no aceptarán valores nulos por defecto.

let name: String = null;

Error de compilación.


Para permitir nulos:

let name: String?;


Y acá podemos hacer algo bastante elegante, podemos hacer que los tipos tengan alias por lo tanto : 

String? va a ser -> Optional<String> 


Ahora bien, como hago Optinal<T> , acá podemos utilizar el camino que usa Typescript union de tipos : T|Null y podemos hacer que Null sea un object como Scala. Y no vamos a tener nulos en nuestro lenguaje. 


¿Por qué la JVM?

La JVM es una de las plataformas más maduras de la industria.

  • Proporciona:
  • Garbage Collector
  • JIT Compiler
  • Ecosistema enorme
  • Bibliotecas maduras
  • Herramientas de monitoreo


En lugar de construir una máquina virtual propia, MateScript aprovechará toda esa infraestructura.


¿Qué sigue?

En los próximos artículos comenzaremos la implementación de MateScript.

El primer paso será construir una gramática utilizando ANTLR capaz de reconocer programas simples como:


let name = "Emanuel";

print(name);


A partir de allí iremos avanzando gradualmente hacia un compilador completo capaz de generar bytecode JVM.


La meta no es crear el próximo Kotlin. La meta es aprender cómo se construyen realmente los lenguajes de programación.


jueves, 2 de julio de 2026

Nuestro primer parser con ANTLR (Paso a paso)


En el post anterior vimos qué es ANTLR y para qué sirve.

Ahora vamos a construir nuestro primer parser desde cero.

No te preocupes si nunca usaste ANTLR. Vamos paso por paso.


Paso 1: Crear un proyecto Maven


Creamos un proyecto vacío:

mvn archetype:generate \

  -DgroupId=com.assembly \

  -DartifactId=mate \

  -DarchetypeArtifactId=maven-archetype-quickstart \

  -DinteractiveMode=false


La estructura debería quedar así:

mate

│

├── pom.xml

│

└── src

    ├── main

    │   └── java

    └── test


Paso 2: Agregar ANTLR


Abrimos el pom.xml y agregamos:


<dependencies>

    <dependency>

        <groupId>org.antlr</groupId>

        <artifactId>antlr4-runtime</artifactId>

        <version>4.13.2</version>

    </dependency>

</dependencies>


Paso 3: Instalar el plugin de ANTLR


Ahora agregamos:


<build>

    <plugins>


        <plugin>

            <groupId>org.antlr</groupId>

            <artifactId>antlr4-maven-plugin</artifactId>

            <version>4.13.2</version>


            <executions>

                <execution>

                    <goals>

                        <goal>antlr4</goal>

                    </goals>

                </execution>

            </executions>


        </plugin>


    </plugins>

</build>


Este plugin será el encargado de generar código Java a partir de nuestras gramáticas.


Paso 4: Crear la carpeta de gramáticas


Creamos:

src/main/antlr4


Quedando:

src

└── main

    ├── antlr4

    └── java


Paso 5: Crear nuestra primera gramática

Creamos:

src/main/antlr4/Mate.g4


Contenido:

grammar Mate;

program

    : 'hola' EOF

    ;


Nuestro lenguaje, por ahora, solamente acepta una palabra:

hola


Nada más.

Es el lenguaje más inútil de la historia.

Pero funciona.


Paso 6: Generar el parser

Ejecutamos:

mvn generate-sources


Si todo salió bien veremos algo parecido a:

Generating grammar...


Y aparecerá una carpeta nueva:

target/generated-sources/antlr4


Dentro encontraremos:

MateLexer.java

MateParser.java

MateListener.java

MateBaseListener.java


Estas clases fueron generadas automáticamente por ANTLR.

Nosotros no escribimos una sola línea de ellas.


Paso 7: Crear una clase de prueba


Creamos:

package com.mate;


import org.antlr.v4.runtime.*;


public class Main {


    public static void main(String[] args) {

        String source = "hola";

        var lexer =

            new MateLexer(

                CharStreams.fromString(source));

        var tokens =

            new CommonTokenStream(lexer);

        var parser =

            new MateParser(tokens);

        parser.program();

        System.out.println("Programa válido");

    }

}


Paso 8: Ejecutar


Corremos:

mvn compile exec:java


Resultado:

Programa válido


¿Qué pasa si el programa es inválido?


Probemos:


String source = "chau";


Ahora obtenemos:


line 1:0 mismatched input 'chau' expecting 'hola'


ANTLR detectó correctamente que nuestro programa no cumple la gramática.


¿Qué acaba de pasar?

Definimos una regla:

program

    : 'hola' EOF

    ;


ANTLR generó automáticamente:

  • Un lexer
  • Un parser
  • Clases auxiliares


Y nuestro programa pudo validar si un texto respetaba o no esa regla.


jueves, 25 de junio de 2026

@MockitoSpyBean en Spring Framework


Si trabajás con pruebas en Spring Boot, seguramente utilizaste @SpyBean para observar el comportamiento de un bean real y verificar sus interacciones.

Sin embargo, a partir de las versiones más recientes de Spring, @SpyBean fue reemplazado por @MockitoSpyBean, una nueva anotación que forma parte del soporte oficial de Mockito en Spring Framework.

¿Por qué aparece @MockitoSpyBean?

Durante años Spring Boot ofreció:
  • @MockBean
  • @SpyBean

para integrar Mockito con el contexto de Spring.

Con la evolución del framework, estas anotaciones fueron reemplazadas por:
  • @MockitoBean
  • @MockitoSpyBean

que proporcionan una integración más consistente y alineada con Mockito.

Un Spy es una instancia real envuelta por Mockito.

Esto significa que:
  • Los métodos reales se ejecutan normalmente.
  • Podemos verificar invocaciones.
  • Podemos modificar comportamientos específicos cuando sea necesario.

Por eso un Spy resulta ideal cuando queremos observar el comportamiento de un bean sin reemplazarlo completamente.

Supongamos el siguiente servicio:


@Service
public class EmailService {

    public void send(String to, String message) {
        System.out.println("Sending email to " + to);
    }
}


Y un servicio que lo utiliza:

@Service
public class UserService {

    private final EmailService emailService;

    public UserService(EmailService emailService) {
        this.emailService = emailService;
    }

    public void register(String email) {
        emailService.send(email, "Welcome!");
    }
}

Utilizando @MockitoSpyBean


@SpringBootTest
class UserServiceTest {

    @Autowired
    private UserService userService;

    @MockitoSpyBean
    private EmailService emailService;

    @Test
    void shouldSendWelcomeEmail() {

        userService.register("john@example.com");

        verify(emailService)
                .send("john@example.com", "Welcome!");
    }
}

La prueba utiliza el bean real de Spring, pero Mockito registra las interacciones permitiéndonos verificar llamadas y argumentos.

Aunque el Spy ejecuta la implementación real, podemos modificar métodos específicos:

doNothing()
    .when(emailService)
    .send(anyString(), anyString());


De esta manera evitamos ejecutar la lógica real mientras seguimos verificando las invocaciones.

En la mayoría de los proyectos Spring Boot basta con incluir:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>

Si usas gradle:

testImplementation 'org.springframework.boot:spring-boot-starter-test'

Esta dependencia incorpora Mockito y las utilidades de testing de Spring.

@MockitoBean vs @MockitoSpyBean ¿Cuándo conviene usarlo?

@MockitoSpyBean resulta útil cuando:
  • Queremos verificar interacciones sobre un bean real.
  • Necesitamos conservar parte de la lógica original.
  • Queremos evitar crear mocks complejos.
  • Estamos realizando pruebas de integración con Spring.

Los Spies son poderosos, pero también pueden volver las pruebas más sensibles a cambios internos de implementación.

Como regla general:
  • Utilizá @MockitoBean para aislar dependencias.
  • Utilizá @MockitoSpyBean cuando necesites observar el comportamiento real de un bean.

@MockitoSpyBean representa la evolución natural de @SpyBean y es la alternativa recomendada en las versiones actuales de Spring.

Permite combinar la ejecución real de un componente con todas las capacidades de verificación de Mockito, logrando pruebas más expresivas y fáciles de diagnosticar cuando algo falla.

Y si no entienden la imagen es Mr Bean de espía ;) 

lunes, 22 de junio de 2026

ANTLR: El primer paso para construir un lenguaje de programación


Cuando usamos Java, Kotlin o Scala, normalmente escribimos código sin pensar demasiado en lo que ocurre detrás de escena.


int result = 10 + 20;


Sin embargo, antes de que la JVM pueda ejecutar ese programa, alguien tuvo que diseñar un compilador capaz de entender ese texto y transformarlo en bytecode.

En esta serie vamos a construir nuestro propio lenguaje para la JVM. No pretendemos competir con Kotlin o Scala, pero sí recorrer muchos de los mismos conceptos que utilizan estos lenguajes internamente.


Y el primer paso es aprender una herramienta fundamental: ANTLR.


¿Qué es ANTLR?

ANTLR (ANother Tool for Language Recognition) es una herramienta que permite generar analizadores léxicos y sintácticos a partir de una gramática.

En lugar de escribir manualmente todo el código necesario para interpretar un lenguaje, simplemente describimos las reglas del mismo y ANTLR genera automáticamente gran parte de la infraestructura necesaria.


Por ejemplo, podemos definir una regla como:


expression

    : expression '+' expression

    | NUMBER

    ;


A partir de ella ANTLR podrá reconocer expresiones como:

1 + 2 + 3


Un compilador suele dividirse en varias etapas:


Código Fuente

      │

      ▼

 Lexer

      │

      ▼

 Tokens

      │

      ▼

 Parser

      │

      ▼

 AST

      │

      ▼

 Análisis Semántico

      │

      ▼

 Generación de Código


ANTLR participa principalmente en las dos primeras:

  • Lexer
  • Parser


¿Qué hace el Lexer?

El Lexer toma una secuencia de caracteres y la divide en tokens.


Por ejemplo:

let age = 42


se transforma en:

LET

IDENTIFIER(age)

ASSIGN

NUMBER(42)


El Lexer no entiende el significado del programa. Solo identifica patrones.


¿Qué hace el Parser?

El Parser toma los tokens generados por el Lexer y verifica que respeten las reglas definidas por la gramática.


Por ejemplo:

LET IDENTIFIER ASSIGN NUMBER


podría convertirse en:

Assignment

 ├── Variable(age)

 └── Number(42)


Esta estructura representa la forma del programa y servirá como base para las siguientes etapas.


¿Qué es una gramática?

Una gramática define qué construcciones son válidas dentro de un lenguaje.


Por ejemplo:

variableDeclaration

    : 'let' IDENTIFIER '=' expression

    ;


Esta regla indica que una declaración válida debe contener:

  • La palabra reservada let
  • Un identificador
  • El símbolo =
  • Una expresión


¿ANTLR genera compiladores?

No.


ANTLR resuelve principalmente:

  • Análisis léxico
  • Parsing


Todavía debemos implementar:

  • Árboles sintácticos abstractos (AST)
  • Tablas de símbolos
  • Sistema de tipos
  • Generación de bytecode JVM


Por eso ANTLR es una herramienta muy importante, pero representa solo una parte del compilador completo.


viernes, 19 de junio de 2026

Java 26: LazyConstant


Una de las novedades de Java 26 es LazyConstant, una API experimental que permite definir constantes inicializadas bajo demanda (*lazy initialization*) de forma segura y eficiente.


Supongamos que tenemos un objeto costoso de crear:


public class Config {

    private static final ExpensiveObject INSTANCE =

            new ExpensiveObject();

}


El objeto se crea cuando la clase es cargada, aunque nunca llegue a utilizarse.

Una solución clásica es utilizar el patrón Initialization-on-demand holder:


public class Config {


    private static class Holder {

        static final ExpensiveObject INSTANCE =

                new ExpensiveObject();

    }


    public static ExpensiveObject instance() {

        return Holder.INSTANCE;

    }

}


Funciona, pero es un patrón poco evidente y algo verboso.

Con Java 26 podemos declarar un valor que será calculado únicamente la primera vez que se necesite:


private static final LazyConstant<ExpensiveObject> INSTANCE =

        LazyConstant.of(ExpensiveObject::new);


y obtenerlo mediante:


ExpensiveObject obj = INSTANCE.get();


La instancia se crea una sola vez y es segura para múltiples hilos.


Veamos un ejemplo:


class DatabaseConnection {


    private static final LazyConstant<ConnectionPool> POOL =

            LazyConstant.of(ConnectionPool::new);


    static ConnectionPool pool() {

        return POOL.get();

    }

}


La conexión se abrirá únicamente cuando alguien invoque:


DatabaseConnection.pool();


¿Qué ventajas tiene?

  • Inicialización diferida (lazy initialization).
  • Thread-safe.
  • Evita implementar patrones complejos.
  • Más legible que usar synchronized, volatile o double-checked locking.
  • Puede reemplazar muchos usos de AtomicReference.


LazyConstant está pensado para recursos costosos o poco utilizados, donde tiene sentido retrasar su creación.

Durante años, Java obligó a utilizar patrones como el Holder idiom o double-checked locking para conseguir inicialización perezosa segura. Java 26 introduce LazyConstant para convertir ese patrón en una característica del lenguaje y la biblioteca estándar, haciendo el código más simple, legible y menos propenso a errores.


miércoles, 17 de junio de 2026

¿Por qué Clojure compila diferente? Ventajas y desventajas de ser un "Hosted Language" en la JVM


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.


lunes, 15 de junio de 2026

JDBI en Java: acceso a datos simple


Cuando hablamos de acceso a bases de datos en Java, solemos pensar en JDBC puro o en frameworks pesados como Hibernate.

Pero existe una opción intermedia muy interesante: Jdbi.


JDBI busca mantener la simplicidad y el control de SQL, pero eliminando gran parte del código repetitivo de JDBC.


¿Qué es JDBI?

JDBI es una librería que se construye sobre JDBC y agrega:

  • Mapeo automático de objetos
  • Queries más limpias
  • Manejo simplificado de parámetros
  • Integración con transacciones
  • APIs modernas y funcionales


La idea es poder escribir SQL real sin tener que pelear con ResultSet, PreparedStatement y toneladas de try/catch.


Dependencia Maven:

<dependency>

    <groupId>org.jdbi</groupId>

    <artifactId>jdbi3-core</artifactId>

    <version>3.49.6</version>

</dependency>


Si usamos una base de datos específica, agregamos el driver correspondiente.


Por ejemplo para MySQL:

<dependency>

    <groupId>com.mysql</groupId>

    <artifactId>mysql-connector-j</artifactId>

</dependency>


Crear una conexión:

Jdbi jdbi = Jdbi.create(

    "jdbc:mysql://localhost:3306/test",

    "root",

    "password"

);


Ejecutar una consulta


Supongamos esta tabla:

CREATE TABLE users (

    id BIGINT PRIMARY KEY,

    name VARCHAR(100),

    age INT

);


Y esta clase:


public class User {

    private Long id;

    private String name;

    private Integer age;


    // getters y setters

}


Ahora podemos consultar así:


List<User> users = jdbi.withHandle(handle ->

    handle.createQuery("SELECT * FROM users")

          .mapToBean(User.class)

          .list()

);


Fijate que desaparece todo el manejo manual de ResultSet.


Insertar datos:


jdbi.useHandle(handle ->

    handle.createUpdate("""

        INSERT INTO users(id, name, age)

        VALUES(:id, :name, :age)

    """)

    .bind("id", 1L)

    .bind("name", "Emanuel")

    .bind("age", 30)

    .execute()

);


Parámetros nombrados

Una de las mejores cosas de JDBI es evitar los clásicos:


statement.setString(1, ...);

statement.setInt(2, ...);


En su lugar:

.bind("name", "Juan")


Mucho más legible.


JDBI también permite definir interfaces tipo DAO.


public interface UserDao {


    @SqlQuery("SELECT * FROM users WHERE id = :id")

    User findById(@Bind("id") Long id);


    @SqlUpdate("""

        INSERT INTO users(id, name, age)

        VALUES(:id, :name, :age)

    """)

    void insert(

        @Bind("id") Long id,

        @Bind("name") String name,

        @Bind("age") Integer age

    );

}


Y luego:


UserDao dao = jdbi.onDemand(UserDao.class);

User user = dao.findById(1L);


¿Por qué mucha gente lo elige?

Porque queda en un punto muy cómodo. No es tan automático como JPA y permite hacer optimizaciones fácilmente, pero no es tan trabajoso como JDBC. 


JDBI se integra muy bien con Spring Framework.

Dependencia:

<dependency>

    <groupId>org.jdbi</groupId>

    <artifactId>jdbi3-spring5</artifactId>

    <version>3.49.6</version>

</dependency>


Configuración:


@Configuration

public class JdbiConfig {


    @Bean

    public Jdbi jdbi(DataSource dataSource) {

        Jdbi jdbi = Jdbi.create(dataSource);

        jdbi.installPlugin(new SqlObjectPlugin());

        return jdbi;

    }

}


Crear el DAO como Bean


@Configuration

public class DaoConfig {


    @Bean

    public UserDao userDao(Jdbi jdbi) {

        return jdbi.onDemand(UserDao.class);

    }

}


Usarlo desde un Service


@Service

public class UserService {

    private final UserDao userDao;

    public UserService(UserDao userDao) {

        this.userDao = userDao;

    }


    public User getUser(Long id) {

        return userDao.findById(id);

    }

}


¿Cuándo conviene usar JDBI?

JDBI suele ser una muy buena opción cuando:

  • querés escribir SQL manualmente
  • necesitás buena performance
  • no querés la complejidad de Hibernate
  • trabajás con consultas complejas
  • querés algo más moderno que JDBC puro


Especialmente en microservicios o aplicaciones donde el modelo relacional es importante, JDBI puede resultar mucho más simple y transparente que un ORM completo.


Dejo link: https://jdbi.org


domingo, 14 de junio de 2026

Mundial de Lenguajes de Programación



Le pregunte a la IA que onda si hacemos partidos de diferentes tecnologías con diferentes lenguajes, y este fue el resultado : 



Partido 1: Aplicaciones Web

Java vs C#


🇯🇵 Java sale con Spring Boot.

🇺🇸 C# responde con ASP.NET Core.


Ambos tienen experiencia internacional, planteles maduros y una enorme cantidad de títulos.

Resultado: Empate 1-1.


> Si tenés que hacer una API corporativa, cualquiera de los dos te lleva a octavos.


 🏟️ Partido 2: Concurrencia

Elixir vs Go


🇧🇷 Elixir apuesta por la posesión y el juego asociado con actores y supervisores.

🇩🇪 Go juega más directo con goroutines y channels.


Elixir domina el mediocampo cuando aparecen millones de procesos concurrentes.

Resultado: Elixir 2 - Go 1.

La BEAM sigue siendo una de las ligas más difíciles de enfrentar.


 🏟️ Partido 3: Aplicaciones Standalone

C++ vs Rust


🇮🇹 C++ es el veterano con ocho mundiales encima.

🇳🇱 Rust llega con una generación joven y una defensa impecable.


Rust reduce errores, pero C++ todavía tiene una experiencia enorme.

Resultado: C++ 1 - Rust 1.

La leyenda sigue vigente, pero la promesa pide pista.


 🏟️ Partido 4: Cloud

Java vs Node.js


🇦🇷 Java viene con GraalVM y Spring Boot.

🇪🇸 Node.js juega rápido y con poco peso.


En microservicios y aplicaciones cloud modernas, ambos se sienten cómodos.

Resultado: Empate.

El VAR determina que la elección depende más del equipo que del lenguaje.


🏟️ Partido 5: Inteligencia Artificial

Python vs el resto del mundo


🇫🇷 Python entra a la cancha.

Resultado: Python 5 - 0.

Hubo partido durante cinco minutos.


 🏟️ Partido 6: Programación Funcional

Scala vs Haskell

🇺🇾 Scala combina técnica y pragmatismo.

🇭🇷 Haskell juega un fútbol hermoso que pocos entienden.


Resultado: Scala 2 - Haskell 1.

La posesión fue 90% para Haskell, pero Scala convirtió las que tuvo.


🏟️ Partido 7: Frontend

TypeScript vs JavaScript


🇵🇹 JavaScript es el capitán histórico.

🇵🇹 TypeScript es el mismo equipo, pero con preparador físico.

Resultado: TypeScript 3 - JavaScript 1.

 Los errores en tiempo de compilación fueron la figura del partido.


 🏟️ Partido 8: Bases de Datos

PostgreSQL vs MySQL


🇨🇴 PostgreSQL juega con mucha técnica.

🇲🇽 MySQL apuesta por la experiencia.


Resultado: PostgreSQL 2 - MySQL 1.

PostgreSQL ganó por posesión y calidad de juego.


Y listo, no hice mucho, ni dice mucho pero es divertido :P 

FFM API en Java: Accediendo a Memoria Nativa y Código Nativo sin JNI


La FFM API (Foreign Function & Memory API) es una de las incorporaciones más interesantes de Java moderno.


Su objetivo es permitir que una aplicación Java pueda:

  • Llamar funciones escritas en C.
  • Acceder a memoria fuera del heap de la JVM.
  • Reemplazar gran parte del uso de JNI.
  • Interactuar con librerías nativas de forma más segura y eficiente.


La FFM API forma parte del proyecto Project Panama.

Pero demos un paso para atras,  ¿Por qué existía JNI?


Durante años, si una aplicación Java necesitaba:

  • acceder a una librería en C,
  • usar código del sistema operativo,
  • trabajar con drivers,
  • o ejecutar operaciones de bajo nivel,

la única opción era usar JNI (Java Native Interface)


El problema es que JNI:

  • es complejo,
  • verboso,
  • inseguro,
  • difícil de debuggear,
  • y propenso a crashes de la JVM.


Además, obliga a escribir:

  • código Java,
  • código C,
  • headers,
  • compilación nativa,
  • glue code.


Puff si no habre puteado con JNI.


¿Qué propone la FFM API?

La FFM API permite hacer esto:

printf("Hola desde C!\n");


...directamente desde Java.


Y además:

  • manejar memoria nativa,
  • mapear estructuras,
  • trabajar con punteros,
  • invocar funciones dinámicamente.


Todo usando una API moderna.


La FFM API tiene dos pilares:

1. Foreign Function


Permite invocar funciones nativas.


Por ejemplo:

  • printf
  • strlen
  • malloc
  • funciones de librerías C


2. Foreign Memory

Permite manejar memoria fuera del heap de Java.


Esto es importante porque:

  • la JVM normalmente controla toda la memoria,
  • pero muchas librerías nativas usan memoria propia.


La FFM API permite trabajar con esa memoria de manera segura.


Primer ejemplo: llamar a printf


import java.lang.foreign.*;

import java.lang.invoke.MethodHandle;

import static java.lang.foreign.ValueLayout.*;


public class Main {


    public static void main(String[] args) throws Throwable {

        Linker linker = Linker.nativeLinker();

        SymbolLookup stdlib = linker.defaultLookup();


        MemorySegment printfAddress =

                stdlib.find("printf")

                      .orElseThrow();


        FunctionDescriptor printfSignature =

                FunctionDescriptor.of(JAVA_INT, ADDRESS);


        MethodHandle printf = linker.downcallHandle(

                printfAddress,

                printfSignature

        );


        try (Arena arena = Arena.ofConfined()) {

            MemorySegment text =

                    arena.allocateFrom("Hola desde C!\n");


            printf.invoke(text);

        }

    }

}


¿Qué está pasando acá?


Linker linker = Linker.nativeLinker();

Obtiene un linker capaz de interactuar con funciones nativas.


SymbolLookup stdlib = linker.defaultLookup();

Busca símbolos exportados por librerías nativas.


stdlib.find("printf")

Obtiene la dirección de memoria de la función.

Muy parecido a: void* ptr = dlsym(...)


FunctionDescriptor.of(JAVA_INT, ADDRESS)

Describe la firma de la función.

En este caso: int printf(char*)


linker.downcallHandle(...)

Crea un MethodHandle que permite invocar la función nativa.


Manejo de memoria con Arena

Uno de los conceptos más importantes es:

Un Arena administra memoria nativa.


try (Arena arena = Arena.ofConfined()) {


}


Cuando el bloque termina:

  • la memoria se libera automáticamente.
  • Esto evita muchísimos memory leaks.


La memoria nativa se representa con: MemorySegment


Es básicamente:

  • un bloque de memoria,
  • con límites,
  • seguro,
  • y controlado.


Y para reservar memoria hacemos: 

MemorySegment segment = arena.allocate(4);

Por ejemplo escribir y leer un entero: 

segment.set(JAVA_INT, 0, 42);

int value = segment.get(JAVA_INT, 0);


Supongamos esta estructura:

struct Point {

    int x;

    int y;

};


Podemos modelarla en Java.

StructLayout POINT = MemoryLayout.structLayout(

        JAVA_INT.withName("x"),

        JAVA_INT.withName("y")

);


Y para reservar memoria hacemos:

MemorySegment point = arena.allocate(POINT);


Escribir los campos:


point.set(JAVA_INT, 0, 10);

point.set(JAVA_INT, 4, 20);


¿Qué ventajas tiene?

Menos complejidad


No hace falta:

  • generar headers,
  • compilar JNI,
  • usar glue code.


¿Puede FFM API reemplaza completamente JNI?

Todavía no en todos los casos.

Hay escenarios avanzados donde JNI sigue siendo necesario.


Pero para muchísimos casos:

  • bindings simples,
  • acceso a librerías,
  • llamadas nativas,
  • estructuras,


la FFM API es mucho mejor.