DevOps, SRE & Co.
Clojure

Clojure

Clojure ist ein modernes Lisp, das auf der Java Virtual Machine (JVM) läuft. Unter Fedora Silverblue, einem immutablen Betriebssystem, empfiehlt sich die Nutzung einer Toolbox, um Entwicklungsumgebungen isoliert und flexibel zu gestalten.

Dieses Tutorial zeigt dir, wie du Clojure samt Leiningen komfortabel in einer Toolbox unter Fedora Silverblue installierst und nutzt.

Voraussetzungen

  • Fedora Silverblue (getestet mit Version 40)
  • Eingeschaltete Toolbox-Unterstützung
  • Internetzugang

Zunächst legen wir eine Toolbox für Clojure an:

1

toolbox create --container clojure

Dann starten wir sie:

1

toolbox enter --container clojure

Systempakete installieren

In Fedora 40 kannst du z. B. java-21-openjdk und rlwrap verwenden:

1

sudo dnf install java-21-openjdk curl rlwrap git

Hinweis: rlwrap ist erforderlich für eine komfortable REPL-Nutzung mit History und Editierfunktionen. Ohne dieses Paket funktioniert clj ggf. nicht richtig.

Clojure CLI installieren (offiziell empfohlen) 

1
2
3

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

Teste mit:

1

clj

Beende die REPL mit Ctrl+D oder (exit).

Leiningen installieren

Leiningen ist das klassische Build- und Projektwerkzeug im Clojure-Ökosystem. Es erlaubt das einfache Anlegen, Verwalten und Ausführen von Projekten, das Einbinden von Abhängigkeiten sowie den Start einer REPL im Kontext des aktuellen Projekts. Für viele Tutorials und Beispielprojekte ist Leiningen nach wie vor der Standard.

1
2
3
4

curl -O https://raw.githubusercontent.com/technomancy/leiningen/stable/bin/lein
chmod +x lein
sudo mv lein /usr/local/bin/
lein

Beim ersten Start lädt Leiningen seine eigenen Dateien (~/.lein).

Testlauf 

1
2

clj          # REPL der Clojure CLI
lein repl    # REPL aus einem Projektkontext

Wenn du eine angenehmere Eingabe möchtest, kannst du rlwrap nutzen:

1

rlwrap clj

Optionales Alias:

1

echo 'alias clj="rlwrap clj"' >> ~/.bashrc

Erstes Projekt mit Leiningen 

1
2

lein new app hello-world
cd hello-world

Der Code befindet sich in src/hello_world/core.clj. Um das Projekt auszuführen:

1

lein run

Das sollte Hello, World! ausgeben.

REPL starten und Funktion testen 

1

lein repl

Dann im REPL:

1
2
3

(defn greet [] (println "Hello, world"))
#'hello-world.core/greet
(greet)

Erwartete Ausgabe:

Hello, world

Der Einstieg ist geschafft!

Tests mit clojure.test

Leiningen legt beim Projektstart automatisch ein Testverzeichnis an: test/hello_world/core_test.clj.

In dieser Datei ist ein erstes Testgerüst enthalten. Du kannst es wie folgt anpassen:

1
2
3
4
5
6

(ns hello-world.core-test
  (:require [clojure.test :refer :all]
            [hello-world.core :refer :all]))

(deftest test-greet
  (is (= nil (greet))))

Hinweis: Da greet nur auf println basiert, gibt die Funktion nil zurück. Deshalb wird genau das getestet.

Starte die Tests mit:

1

lein test

Erwartete Ausgabe:

Ran 1 tests containing 1 assertions.
0 failures, 0 errors.

Damit hast du den vollständigen Entwicklungszyklus mit Sourcecode, REPL und Tests durchlaufen.

Wenn du mit VS Code arbeitest, empfehlen wir das Plugin Calva.

VS Code + Calva

  1. Starte VS Code.
  2. Öffne den Erweiterungs-Manager (Ctrl+Shift+X).
  3. Suche nach Calva und installiere es.

Oder per CLI:

1

code --install-extension betterthantomorrow.calva

Features von Calva

  • Intelligente REPL-Integration (auch mit Leiningen oder deps.edn)
  • Inline-Auswertung und Anzeige von Resultaten im Editor
  • Auto-Completion, Linting und Syntax-Highlighting
  • Strukturierte Editierfunktionen (Parinfer, Paredit)
  • NREPL-Verbindung zu laufenden Prozessen

Nach der Installation:

  1. Öffne ein Leiningen-Projekt.
  2. Öffne die Command Palette (Ctrl+Shift+P) → Calva: Start a Project REPL and Connect.
  3. Wähle Leiningen als Startmethode.

Du kannst jetzt Clojure-Code direkt im Editor auswerten (Ctrl+Enter) und die Resultate im Inline-Ausgabepuffer oder Terminal sehen.

Übungen

Um in Clojure richtig einzusteigen, habe ich einige Übungen vorbereitet:

🔄 Zurücksetzen

Exkurs: Für LISP-Veteranen

Wenn du bereits in den 1980er Jahren mit LISP gearbeitet hast, wirst du dich an Funktionen wie car, cdr, cons und null? erinnern. Clojure basiert zwar konzeptionell auf LISP, verwendet aber modernere, aussagekräftigere Namen:

LISPClojureBeschreibung
carfirstErstes Element einer Liste
cdrrestRestliste ohne das erste Element
consconsElement vorne an Liste anhängen
listlistNeue Liste erzeugen
null?empty?Prüft, ob eine Sequenz leer ist

Beispiel 

1
2
3
4
5
6

(def xs '(1 2 3))

(first xs)  ;; => 1
(rest xs)   ;; => (2 3)
(cons 0 xs) ;; => (0 1 2 3)
(empty? xs) ;; => false

Clojure bevorzugt lesbare Funktionsnamen, die auch für Neueinsteiger verständlich sind. Die Funktionalität ist gleich geblieben – aber die Bezeichner sind sprechender:

  • first statt car
  • rest statt cdr

Das macht Code leichter lesbar, ohne an Ausdrucksstärke zu verlieren. Clojure arbeitet primär mit Sequences (abstrakte, lazy Datenstrukturen), nicht mit klassisch verketteten Listen. Die Konzepte sind aber übertragbar und du kannst weiterhin idiomatisch Listen verarbeiten – nur auf moderner Art.

Weitere Ressourcen und Tutorials

Hier sind einige empfohlene Tutorials, Bücher und Online-Ressourcen für deinen Clojure-Einstieg: