Pug (bis 2016 Jade) ist eine einrückungsbasierte Template-Engine, die 2010 von TJ Holowaychuk für Node.js entwickelt wurde. Statt schließender Tags bestimmt die Einrückung die HTML-Verschachtelung — Templates werden dadurch deutlich kompakter und lesbarer.

Syntax

doctype html
html
  head
    title= seite.titel
  body
    h1 Hallo #{name}
    ul
      each item in liste
        li= item

Mixins und Vererbung

Mixins sind wiederverwendbare Template-Bausteine:

mixin button(text)
  button.btn= text
+button('Klick mich')

Mit extends layout und block inhalt lassen sich Seiten von einem Grundlayout erben, include partial bindet Fragmente ein. Interpolation funktioniert mit #{variable}, Ausgabe mit Gleichheitszeichen (li= item) oder != für unescaptes HTML.

Pug läuft in Node.js und ist fester Bestandteil des Express-Frameworks. Verwandt: Handlebars-Befehle, Mustache-Befehle und HTML/CSS-Befehle.

Gradle ist ein modernes Build-Automatisierungswerkzeug, das Hans Dockter 2007 entwickelte und das heute vor allem im Java-, Kotlin- und Android-Umfeld Standard ist. Anders als bei Maven ist das Build-Skript ausführbarer Code: Die Projekte werden ursprünglich über eine Groovy-DSL beschrieben, seit Gradle 5 ist alternativ die Kotlin-DSL mit der Datei build.gradle.kts verfügbar.

Tasks statt Lebenszyklus-Phasen

Ein Gradle-Build ist ein gerichteter azyklischer Graph (DAG) von Tasks. Jede Task hat Eingaben, Ausgaben und Abhängigkeiten — Gradle führt nur die Tasks aus, deren Eingaben sich geändert haben, und parallelisiert unabhängige Zweige automatisch. Das Build-Skript heißt build.gradle (Groovy) oder build.gradle.kts (Kotlin) und deklariert Plugins, Repositories, Abhängigkeiten und eigene Tasks.

Die wichtigsten gradle-Aufrufe

gradle tasks         # verfügbare Tasks auflisten
gradle build         # kompilieren, testen und paketieren
gradle assemble      # Ausgaben bauen ohne Tests
gradle check         # alle Verifikations-Tasks (z. B. Tests)
gradle test          # Tests ausführen
gradle clean         # build/-Verzeichnis löschen
./gradlew build      # über den Gradle Wrapper bauen

Der Gradle Wrapper (gradlew) ist eine kleine Skript- und JAR-Kombination im Projekt, die die exakt konfigurierte Gradle-Version lädt — dadurch baut jedes Projekt mit derselben Version, ohne dass Gradle global installiert sein muss.

Gradle verbindet die deklarative Projektbeschreibung von Maven-Befehlen mit der Flexibilität von Make-Befehlen: einen festen Lebenszyklus, aber vollständig programmierbare Build-Logik.

Make ist das älteste und am weitesten verbreitete Build-Werkzeug der Unix-Welt. Stuart Feldman schrieb es 1976 bei den Bell Labs über ein Wochenende, weil ein Kollege einen Fehler ausgeliefert hatte, der durch eine vergessene Neuübersetzung entstanden war. Make baut nur das neu, was sich seit dem letzten Lauf geändert hat — Dateizeitstempel entscheiden, welche Regeln erneut laufen müssen.

Makefile: Regeln aus Target, Abhängigkeiten und Rezept

Eine Makefile-Datei beschreibt Regeln nach dem Muster target: abhängigkeiten gefolgt von einer eingerückten Rezeptzeile. Das Target ist meist eine Zieldatei wie programm, die Abhängigkeiten sind die Quelldateien, und das Rezept ist der Befehl, der daraus das Ziel erzeugt:

programm: main.o utils.o
	cc -o programm main.o utils.o
main.o: main.c
	cc -c main.c
utils.o: utils.c
	cc -c utils.c

Wichtige Grundbefehle sind make (erstes Target bauen), make -j4 (vier Jobs parallel), make clean (Zwischenprodukte löschen) und make install (Programm im System installieren). Mit make -n zeigt Make nur an, was es tun würde, ohne es auszuführen.

Phony-Targets und Variablen

Targets wie clean oder test entsprechen keiner Datei. Solche Phony-Targets werden über .PHONY: clean test markiert, damit Make sie immer ausführt und nicht mit einer gleichnamigen Datei verwechselt. Variablen wie CC=gcc oder CFLAGS=-O2 machen die Regeln wiederverwendbar und erlauben spätere Anpassung von der Kommandozeile.

Moderne Build-Systeme bauen auf Make auf oder lösen es ab: CMake-Befehle erzeugen Makefiles für große C/C++-Projekte, während Maven-Befehle und Gradle-Befehle den deklarativen Build im Java-Ökosystem geprägt haben.

Apache Maven ist ein deklaratives Build- und Projektmanagement-Werkzeug für Java, das Jason van Zyl 2002 als Unterprojekt von Apache Turbine entwickelte. Seit 2003 ist Maven ein Top-Level-Projekt der Apache Software Foundation. Statt Build-Logik zu programmieren, beschreibt das Projekt sich selbst in der Datei pom.xml — Maven leitet daraus den kompletten Build ab.

pom.xml und der Standard-Lebenszyklus

Die pom.xml (Project Object Model) definiert Gruppen-ID, Artefakt-ID, Version, Verpackungsart, Abhängigkeiten und Plugins. Maven führt dann den fest vorgegebenen Default-Lebenszyklus aus, dessen Phasen in dieser Reihenfolge laufen: validate, compile, test, package, verify, install, deploy. Der Aufruf einer späteren Phase führt automatisch alle vorherigen mit aus — mvn package kompiliert also auch, testet und erzeugt die JAR/WAR-Datei.

Die wichtigsten mvn-Aufrufe

mvn clean        # build/-Verzeichnis löschen
mvn compile      # Quellcode übersetzen
mvn test         # Tests ausführen
mvn package      # JAR/WAR erzeugen
mvn install      # Artefakt ins lokale Repository kopieren
mvn deploy       # Artefakt auf einen entfernten Server veröffentlichen

Mit mvn clean install startet man den klassischen Komplett-Build, mit mvn -DskipTests=true install lassen sich Tests überspringen. Abhängigkeiten lädt Maven automatisch aus zentralen Repositories, standardmäßig aus Maven Central.

Maven etablierte das Konvention-über-Konfiguration-Prinzip, das jüngere Werkzeuge übernommen haben: Gradle-Befehle setzen denselben Lebenszyklus-Gedanken mit programmierbaren Skripten um, während Make-Befehle den klassischen, regelbasierten Ansatz aus der Unix-Welt zeigen.