# Introducción a Clojure

Clojure es un lenguaje de programación **funcional, dinámico e inmutable** que corre sobre la **JVM**, por lo que puede aprovechar todo el ecosistema de Java. Fue diseñado para facilitar la creación de software **simple, concurrente y escalable**, utilizando funciones, estructuras de datos inmutables y un entorno interactivo basado en REPL. Su sintaxis es muy diferente a Java porque utiliza expresiones con muchos paréntesis, y aunque tiene una comunidad más pequeña, es especialmente valorado en sistemas backend, procesamiento de datos y aplicaciones donde la **concurrencia y la programación funcional** son importantes.

**Clojure fue creado por Rich Hickey** y lanzado públicamente en **2007**. Hickey diseñó el lenguaje con el objetivo de simplificar el desarrollo de software concurrente y aprovechar la robustez de la plataforma Java, combinando las ideas de los lenguajes Lisp con conceptos modernos de programación funcional e inmutabilidad. Actualmente, Rich Hickey es una figura muy influyente en la comunidad de arquitectura de software y programación funcional.

# **Cómo instalar Clojure y empezar con ejemplos prácticos**

Si estás comenzando con Clojure, el mejor camino es instalar la CLI oficial, abrir un REPL y practicar con funciones pequeñas que te ayuden a entender el estilo de programación funcional de esta herramienta.

Este primer post reúne la instalación paso a paso y varios ejemplos que ya hemos trabajado en este proyecto para que puedas compartirlo con tu comunidad de forma clara y útil.

Github Repo: [https://github.com/joedayz/clojure-senior-path](https://github.com/joedayz/clojure-senior-path)

## **1) Instalación de Clojure**

### **macOS con Homebrew**

![](http://localhost:63342/markdownPreview/455488292//Users/josediaz/Projects/JoeDayz/ClojureSaveme/articles align="center")

```shell
brew install clojure/tools/clojure
```

### **Linux (script oficial)**

![](http://localhost:63342/markdownPreview/455488292//Users/josediaz/Projects/JoeDayz/ClojureSaveme/articles align="center")

```shell
curl -O https://download.clojure.org/install/linux-install-1.11.1.1403.sh
chmod +x linux-install-1.11.1.1403.sh
sudo ./linux-install-1.11.1.1403.sh
```

### **Windows**

1.  Instala Java 21 o superior.
    
2.  Instala la Clojure CLI con `winget`:
    

![](http://localhost:63342/markdownPreview/455488292//Users/josediaz/Projects/JoeDayz/ClojureSaveme/articles align="center")

```shell
winget install clojure
```

## **2) Verificación de la instalación**

Ejecuta estas instrucciones para confirmar que todo quedó bien instalado:

![](http://localhost:63342/markdownPreview/455488292//Users/josediaz/Projects/JoeDayz/ClojureSaveme/articles align="center")

```shell
java -version
clojure -Sdescribe
```

Si quieres ejecutar pruebas del proyecto:

![](http://localhost:63342/markdownPreview/455488292//Users/josediaz/Projects/JoeDayz/ClojureSaveme/articles align="center")

```shell
clojure -M:test -m cognitect.test-runner
```

> Si `clj` falla por un problema con `rlwrap`, usa `clojure` directamente. En muchos entornos, `clojure` es la opción más confiable.

## **3) Primer contacto con el REPL**

El REPL es una de las mejores partes de Clojure. Te permite evaluar expresiones inmediatas y probar ideas en tiempo real.

```java
(+ 2 3)
(* 5 6)
(str "Hola" " Clojure")
```

También puedes probar operaciones con colecciones:

```java
(def numbers [12345])
(map #(* 2 %) numbers)
(reduce + 0 numbers)
(filter even? numbers)
```

![](http://localhost:63342/markdownPreview/455488292//Users/josediaz/Projects/JoeDayz/ClojureSaveme/articles align="center")

## **4) Ejemplos básicos que ya hemos practicado**

### **a) Duplicar cada número**

```java
(defn double-all  
  [numbers]
  (map #(* 2 %) numbers))
```

![](http://localhost:63342/markdownPreview/455488292//Users/josediaz/Projects/JoeDayz/ClojureSaveme/articles align="center")

Uso:

```java
(double-all [1 2 3 4])
;; => (2 4 6 8)
```

![](http://localhost:63342/markdownPreview/455488292//Users/josediaz/Projects/JoeDayz/ClojureSaveme/articles align="center")

### **b) Sumar todos los elementos**

```java
(defn sum-numbers  
  [numbers]
  (reduce + 0 numbers))
```

Uso:

```java
(sum-numbers [1 2 3 4])
;; => 10
```

![](http://localhost:63342/markdownPreview/455488292//Users/josediaz/Projects/JoeDayz/ClojureSaveme/articles align="center")

### **c) Filtrar solo números pares**

```java
(defn even-only  [numbers]
  (filter even? numbers))
```

Uso:

```java
(even-only [1 2 3 4 5 6])
;; => (2 4 6)
```

![](http://localhost:63342/markdownPreview/455488292//Users/josediaz/Projects/JoeDayz/ClojureSaveme/articles align="center")

### **d) Contar vocales en un texto**

```java
(defn count-vowels  
  [text]
  (let [lower (clojure.string/lower-case text)
        vowels #{\a\e\i\o\u}]
    (count (filter vowels lower))))
```

![](http://localhost:63342/markdownPreview/455488292//Users/josediaz/Projects/JoeDayz/ClojureSaveme/articles align="center")

Uso:

```plaintext
(count-vowels "Hola Mundo")
;; => 4
```

![](http://localhost:63342/markdownPreview/455488292//Users/josediaz/Projects/JoeDayz/ClojureSaveme/articles align="center")

### **e) Factorial con** `loop/recur`

```java
(defn factorial  
  [n]
  (loop [current n acc 1]
    (if (<=current 1)
      acc      
      (recur (dec current) (* acc current)))))
```

![](http://localhost:63342/markdownPreview/455488292//Users/josediaz/Projects/JoeDayz/ClojureSaveme/articles align="center")

Uso:

```java
(factorial 5)
;; => 120
```

![](http://localhost:63342/markdownPreview/455488292//Users/josediaz/Projects/JoeDayz/ClojureSaveme/articles align="center")

Este ejemplo es útil para entender cómo Clojure maneja la recursión sin caer en problemas de stack overflow cuando se usa `loop/recur`.

### **f) Promedio de una colección**

```java
(defn average  
  [numbers]
  (if (empty? numbers)
    0    
    (/ (reduce + 0 numbers)
       (count numbers))))
```

![](http://localhost:63342/markdownPreview/455488292//Users/josediaz/Projects/JoeDayz/ClojureSaveme/articles align="center")

Uso:

```java
(average [10 20 30])
;; => 20
```

![](http://localhost:63342/markdownPreview/455488292//Users/josediaz/Projects/JoeDayz/ClojureSaveme/articles align="center")

## **5) Trabajar con maps y datos estructurados**

Clojure es muy cómodo para trabajar con mapas, y esto se vuelve muy útil cuando construimos datos de negocio o modelos simples.

### **Crear un usuario normalizado**

```java
(defn build-user  
  [{:keys [id name email]}]
  {:id id
   :name name
   :email email
   :active true})
```

![](http://localhost:63342/markdownPreview/455488292//Users/josediaz/Projects/JoeDayz/ClojureSaveme/articles align="center")

Uso:

```java
(build-user {:id 1 :name "Ana" :email "ana@example.com"})
;; => {:id 1, :name "Ana", :email "ana@example.com", :active true}
```

![](http://localhost:63342/markdownPreview/455488292//Users/josediaz/Projects/JoeDayz/ClojureSaveme/articles align="center")

### **Resumen de producto**

```java
(defn product-summary  
  [{:keys [name price stock]}]
  {:name name
   :price price
   :stock stock
   :in-stock? (pos? stock)})
```

![](http://localhost:63342/markdownPreview/455488292//Users/josediaz/Projects/JoeDayz/ClojureSaveme/articles align="center")

Uso:

```java
(product-summary {:name "Laptop" :price 999 :stock 12})
;; => {:name "Laptop", :price 999, :stock 12, :in-stock? true}
```

![](http://localhost:63342/markdownPreview/455488292//Users/josediaz/Projects/JoeDayz/ClojureSaveme/articles align="center")

## **6) Por qué Clojure valora este enfoque**

Los ejemplos anteriores muestran algunas ideas clave de Clojure:

*   Las funciones son primero-class citizens.
    
*   Los datos son expresivos y fáciles de manipular.
    
*   Las colecciones se procesan con funciones como `map`, `filter` y `reduce`.
    
*   La recursión se maneja de forma clara con `loop/recur`.
    
*   Los maps permiten modelar información de una manera muy directa.
    

## **7) Siguiente paso recomendado**

Para seguir avanzando, te recomiendo practicar en este orden:

1.  Instalar la Clojure CLI.
    
2.  Abrir el REPL y probar cada ejemplo manualmente.
    
3.  Reescribir las funciones sin mirar el código.
    
4.  Agregar nuevas pruebas con `clojure.test`.
    
5.  Comenzar a crear pequeños ejercicios con maps y colecciones.
    

## **8) Cierre**

Clojure puede verse desafiante al principio, pero cuando entiendes el flujo de datos y la sintaxis básica, se vuelve muy elegante y poderosa. El primer objetivo no es dominar todo desde el inicio, sino construir confianza con ejemplos pequeños y repetibles.

Si quieres, en el siguiente post podemos continuar con una introducción a:

*   `let`, `if`, `cond` y `fn`
    
*   listas, vectores y mapas
    
*   `reduce`, `map` y `filter` en profundidad
    
*   cómo estructurar un proyecto con namespaces y tests
    

Y así seguir compartiendo contenido útil para la comunidad de Clojure.

Enjoy!

Joe