Clojure: un lenguaje que te obliga a pensar de otra manera

Clojure, creado por Rich Hickey, es un lenguaje funcional moderno que corre sobre la JVM que no solo ofrece una sintaxis distinta, sino una nueva manera de concebir el software. Para los que vienen de Java, Clojure te invita a abandonar la obsesión por los objetos y abrazar la inmutabilidad, la composición y la simplicidad.

Clojure combina la elegancia de Lisp con la potencia del ecosistema Java. Su diseño parte de una idea radical: los datos deben ser inmutables y las funciones, puras.

Esto significa que cada operación genera un nuevo valor en lugar de modificar el existente, lo que elimina una gran fuente de errores en sistemas concurrentes.

Principios clave de su filosofía:

• Inmutabilidad por defecto: evita efectos colaterales y facilita la concurrencia. 
• Funciones como unidades de pensamiento: el código se construye por composición, no por herencia. 
• Interoperabilidad total con Java: puedes usar cualquier librería Java directamente desde Clojure. 
• REPL-driven development: el entorno interactivo te permite experimentar y refinar ideas en tiempo real.

En Java, solemos pensar en clases y estados; en Clojure, pensamos en transformaciones de datos. Por ejemplo, en lugar de iterar con bucles, usamos funciones como map, filter y reduce para expresar la intención del código de forma declarativa.

Veamos este ejemplo de incremento de elementos de un arreglo.

En Java:

List<Integer> nums = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> result = nums.stream()
                           .map(n -> n + 1)
                           .collect(Collectors.toList());
System.out.println(result); // [2, 3, 4, 5, 6]

Aplicando la filosofía de Clojure ("menos ruido, más claridad"):

(map inc [1 2 3 4])
;; => (2 3 4 5)

Este sencillo ejemplo resume la filosofía de Clojure: menos control explícito, más significado.

Ahora a seleccionar elementos según una condición en Java:

List<Integer> nums = Arrays.asList(1, 2, 3, 4, 5, 6);
List<Integer> evens = nums.stream()
                          .filter(n -> n % 2 == 0)
                          .collect(Collectors.toList());
System.out.println(evens); // [2, 4, 6]

En Clojure:

(filter even? [1 2 3 4 5 6])
;; => (2 4 6)

En Clojure, even? es una función pura; en Java, usamos una lambda que expresa la misma lógica.

Ahora a combinar elementos en un solo valor en Java:

List<Integer> nums = Arrays.asList(1, 2, 3, 4, 5);
int sum = nums.stream()
              .reduce(0, Integer::sum);
System.out.println(sum); // 15

En Clojure:

(reduce + [1 2 3 4 5])
;; => 15

En Clojure, reduce usa una función y una colección; en Java, el método reduce del Stream requiere un valor inicial y una operación acumuladora.

Ahora un programa que sume los primeros 1000 múltiplos de 3 y 5 en Java:

import java.util.stream.IntStream;

public class SumMultiples {
    public static void main(String[] args) {
        int sum = IntStream.rangeClosed(1, 1000)   // números del 1 al 1000
                           .filter(n -> n % 3 == 0 && n % 5 == 0) // múltiplos de 3 y 5
                           .sum(); // acumula la suma

        System.out.println("Suma: " + sum);
    }
}

En Clojure:

;; Crear un vector con los números del 1 al 1000
(def vect (range 1 1001))

;; Calcular la suma de los múltiplos de 3 y 5
(def sum
  (reduce +
    (filter #(and (zero? (mod % 3))
                  (zero? (mod % 5)))
            vect)))

;; Mostrar el resultado
(println "Suma:" sum)

¿En qué se usa Clojure?

En sistemas distribuidos, análisis de datos, servicios web y aplicaciones concurrentes. Empresas como Nubank, Funding Circle y Metabase lo emplean para construir plataformas escalables y confiables.

Aprender Clojure no es solo dominar otro lenguaje: es reaprender a pensar. Te obliga a cuestionar hábitos, a valorar la simplicidad y a escribir código que describe ideas, no instrucciones. Como diría Rich Hickey:

"Los buenos sistemas nacen de buenas ideas, no de buenas clases".

Continuaremos en próximas entregas.

Enlaces:

https://blog.koalite.com/2013/01/primeros-pasos-con-clojure/
https://alquimistadecodigo.blogspot.com/2014/08/clojure-interoperabilidad-con-java.html