Add German (de) translation

html-generators/locales.properties

@@ -1,4 +1,5 @@
 # format: locale=Display name  (first entry is the default/primary locale)
 en=English
+de=Deutsch
 es=Español
 pt-BR=Português (Brasil)

translations/content/de/collections/collectors-teeing.yaml

@@ -0,0 +1,19 @@
+title: "Collectors.teeing()"
+oldApproach: Zwei Durchläufe
+modernApproach: "teeing()"
+summary: Zwei Aggregationen in einem einzigen Stream-Durchlauf berechnen.
+explanation: "Collectors.teeing() sendet jedes Element an zwei nachgelagerte Collectors\
+  \ und fasst die Ergebnisse zusammen. Dadurch wird vermieden, die Daten zweimal\
+  \ zu durchlaufen oder einen veränderbaren Akkumulator zu verwenden."
+whyModernWins:
+- icon: "⚡"
+  title: Einzelner Durchlauf
+  desc: Den Stream einmal statt zweimal verarbeiten.
+- icon: "🧩"
+  title: Kombinierbar
+  desc: Zwei beliebige Collectors mit einer Zusammenführungsfunktion verbinden.
+- icon: "🔒"
+  title: Unveränderliches Ergebnis
+  desc: Direkt in einen Record oder Value-Object zusammenführen.
+support:
+  description: Weitgehend verfügbar seit JDK 12 (März 2019)

translations/content/de/collections/copying-collections-immutably.yaml

@@ -0,0 +1,19 @@
+title: Kollektionen unveränderlich kopieren
+oldApproach: Manuelle Kopie + Wrapper
+modernApproach: "List.copyOf()"
+summary: Eine unveränderliche Kopie einer beliebigen Kollektion mit einem einzigen Aufruf erstellen.
+explanation: "List.copyOf(), Set.copyOf() und Map.copyOf() erstellen unveränderliche\
+  \ Momentaufnahmen bestehender Kollektionen. Wenn die Quelle bereits eine unveränderliche\
+  \ Kollektion ist, wird keine Kopie erstellt."
+whyModernWins:
+- icon: "⚡"
+  title: Intelligente Kopie
+  desc: Die Kopie wird übersprungen, wenn die Quelle bereits unveränderlich ist.
+- icon: "📏"
+  title: Ein einziger Aufruf
+  desc: Kein manuelles ArrayList-Erstellen und Verpacken.
+- icon: "🛡️"
+  title: Defensive Kopie
+  desc: Änderungen am Original wirken sich nicht auf die Kopie aus.
+support:
+  description: Weitgehend verfügbar seit JDK 10 (März 2018)

translations/content/de/collections/immutable-list-creation.yaml

@@ -0,0 +1,19 @@
+title: Unveränderliche Listen erstellen
+oldApproach: Ausführliches Verpacken
+modernApproach: "List.of()"
+summary: Unveränderliche Listen in einem einzigen, sauberen Ausdruck erstellen.
+explanation: "List.of() erstellt eine wirklich unveränderliche Liste — kein Verpacken,\
+  \ keine defensive Kopie. Sie ist null-feindlich (lehnt null-Elemente ab) und strukturell\
+  \ unveränderlich. Die alte Methode erforderte drei verschachtelte Aufrufe."
+whyModernWins:
+- icon: "📏"
+  title: Ein einziger Aufruf
+  desc: Drei verschachtelte Aufrufe durch eine einzige Factory-Methode ersetzen.
+- icon: "🔒"
+  title: Wirklich unveränderlich
+  desc: Kein bloßer Wrapper — die Liste selbst ist unveränderlich.
+- icon: "🛡️"
+  title: Null-sicher
+  desc: Lehnt null-Elemente bei der Erstellung ab und schlägt sofort fehl.
+support:
+  description: Weitgehend verfügbar seit JDK 9 (Sept. 2017)

translations/content/de/collections/immutable-map-creation.yaml

@@ -0,0 +1,18 @@
+title: Unveränderliche Maps erstellen
+oldApproach: Map-Builder-Muster
+modernApproach: "Map.of()"
+summary: Unveränderliche Maps inline ohne Builder erstellen.
+explanation: "Map.of() akzeptiert Schlüssel-Wert-Paare inline und gibt eine unveränderliche\
+  \ Map zurück. Für mehr als 10 Einträge Map.ofEntries() mit Map.entry()-Paaren verwenden."
+whyModernWins:
+- icon: "📏"
+  title: Inline-Erstellung
+  desc: Kein temporäres veränderliches Map erforderlich.
+- icon: "🔒"
+  title: Unveränderliches Ergebnis
+  desc: Die Map kann nach der Erstellung nicht mehr geändert werden.
+- icon: "🚫"
+  title: Keine null-Schlüssel/-Werte
+  desc: Null-Einträge werden sofort abgelehnt.
+support:
+  description: Weitgehend verfügbar seit JDK 9 (Sept. 2017)

translations/content/de/collections/immutable-set-creation.yaml

@@ -0,0 +1,18 @@
+title: Unveränderliche Sets erstellen
+oldApproach: Ausführliches Verpacken
+modernApproach: "Set.of()"
+summary: Unveränderliche Sets mit einem einzigen Factory-Aufruf erstellen.
+explanation: "Set.of() erstellt ein wirklich unveränderliches Set, das null-Elemente\
+  \ und Duplikate bei der Erstellung ablehnt. Kein Verpacken von veränderbaren Sets mehr."
+whyModernWins:
+- icon: "📏"
+  title: Prägnant
+  desc: Eine Zeile statt drei verschachtelter Aufrufe.
+- icon: "🚫"
+  title: Erkennt Duplikate
+  desc: Wirft eine Ausnahme, wenn versehentlich doppelte Elemente übergeben werden.
+- icon: "🔒"
+  title: Unveränderlich
+  desc: Kein Hinzufügen oder Entfernen nach der Erstellung möglich.
+support:
+  description: Weitgehend verfügbar seit JDK 9 (Sept. 2017)

translations/content/de/collections/map-entry-factory.yaml

@@ -0,0 +1,19 @@
+title: "Map.entry()-Factory"
+oldApproach: SimpleEntry
+modernApproach: "Map.entry()"
+summary: Map-Einträge mit einer sauberen Factory-Methode erstellen.
+explanation: "Map.entry() ersetzt den ausführlichen AbstractMap.SimpleEntry-Konstruktor.\
+  \ Es gibt einen unveränderlichen Eintrag zurück, der ideal für Map.ofEntries()\
+  \ und Stream-Operationen ist."
+whyModernWins:
+- icon: "📏"
+  title: Prägnant
+  desc: Eine Zeile statt drei mit klarerer Absicht.
+- icon: "🔒"
+  title: Unveränderlich
+  desc: Der zurückgegebene Eintrag kann nicht geändert werden.
+- icon: "🧩"
+  title: Kombinierbar
+  desc: "Funktioniert perfekt mit Map.ofEntries() für große Maps."
+support:
+  description: Weitgehend verfügbar seit JDK 9 (Sept. 2017)

translations/content/de/collections/reverse-list-iteration.yaml

@@ -0,0 +1,20 @@
+title: Umgekehrte Listen-Iteration
+oldApproach: Manueller ListIterator
+modernApproach: "reversed()"
+summary: Mit einer sauberen for-each-Schleife in umgekehrter Reihenfolge über eine Liste iterieren.
+explanation: "Die Methode reversed() von SequencedCollection gibt eine in umgekehrter\
+  \ Reihenfolge angeordnete Ansicht der Liste zurück. Diese Ansicht wird durch die\
+  \ ursprüngliche Liste gesichert, sodass kein Kopieren stattfindet. Die erweiterte\
+  \ for-Schleife macht die umgekehrte Iteration genauso lesbar wie die Vorwärts-Iteration."
+whyModernWins:
+- icon: "📖"
+  title: Natürliche Syntax
+  desc: Erweiterte for-Schleife statt des ausführlichen ListIterators.
+- icon: "⚡"
+  title: Kein Kopieren
+  desc: "reversed() gibt eine Ansicht zurück — kein Performance-Overhead."
+- icon: "🧩"
+  title: Konsistente API
+  desc: "Funktioniert einheitlich auf List, Deque und SortedSet."
+support:
+  description: Weitgehend verfügbar seit JDK 21 LTS (Sept. 2023)

translations/content/de/collections/sequenced-collections.yaml

@@ -0,0 +1,19 @@
+title: Sequenzierte Kollektionen
+oldApproach: Index-Arithmetik
+modernApproach: getFirst/getLast
+summary: "Auf das erste/letzte Element zugreifen und umgekehrte Ansichten mit sauberen API-Methoden erhalten."
+explanation: "SequencedCollection fügt getFirst(), getLast(), reversed(), addFirst()\
+  \ und addLast() zu List, Deque, SortedSet und LinkedHashSet hinzu. Keine size-1-Arithmetik\
+  \ oder manuelle umgekehrte Iteration mehr."
+whyModernWins:
+- icon: "📖"
+  title: Selbstdokumentierend
+  desc: "getLast() ist klarer als get(size()-1)."
+- icon: "🔄"
+  title: Umgekehrte Ansicht
+  desc: "reversed() gibt eine Ansicht zurück — kein Kopieren erforderlich."
+- icon: "🧩"
+  title: Einheitliche API
+  desc: "Funktioniert gleich auf List, Deque und SortedSet."
+support:
+  description: Weitgehend verfügbar seit JDK 21 LTS (Sept. 2023)

translations/content/de/collections/stream-toarray-typed.yaml

@@ -0,0 +1,19 @@
+title: Typisiertes Stream-toArray
+oldApproach: Manuelle Array-Kopie
+modernApproach: "toArray(generator)"
+summary: Streams mit einer Methodenreferenz in typisierte Arrays umwandeln.
+explanation: "Die Methode toArray(IntFunction) erstellt ein korrekt typisiertes Array\
+  \ aus einem Stream. Der Generator (String[]::new) teilt dem Stream mit, welchen\
+  \ Array-Typ er erstellen soll."
+whyModernWins:
+- icon: "🎯"
+  title: Typsicher
+  desc: "Kein Object[]-Cast — der Array-Typ ist korrekt."
+- icon: "🔗"
+  title: Verkettbar
+  desc: Funktioniert am Ende jeder Stream-Pipeline.
+- icon: "📏"
+  title: Prägnant
+  desc: Ein einziger Ausdruck ersetzt die manuelle Schleife.
+support:
+  description: Weitgehend verfügbar seit JDK 8 (März 2014)

translations/content/de/collections/unmodifiable-collectors.yaml

@@ -0,0 +1,21 @@
+title: Nicht-modifizierbare Collectors
+oldApproach: collectingAndThen
+modernApproach: "stream.toList()"
+summary: "Direkt in eine nicht-modifizierbare Liste mit stream.toList() sammeln."
+explanation: "Java 10 fügte toUnmodifiableList(), toUnmodifiableSet() und toUnmodifiableMap()\
+  \ hinzu, um den ausführlichen collectingAndThen-Wrapper zu ersetzen. Für Listen\
+  \ bietet stream.toList() aus Java 16 eine noch einfachere Alternative — ganz ohne\
+  \ collect()-Aufruf. Für andere Kollektionstypen toUnmodifiableSet() und\
+  \ toUnmodifiableMap() verwenden."
+whyModernWins:
+- icon: "📏"
+  title: Kürzest möglich
+  desc: "stream.toList() benötigt weder collect() noch einen Collectors-Import."
+- icon: "🔒"
+  title: Unveränderlich
+  desc: "Das Ergebnis kann nicht geändert werden — keine versehentlichen Mutationen."
+- icon: "📖"
+  title: Lesbar
+  desc: Liest sich natürlich als abschließender Schritt jeder Stream-Pipeline.
+support:
+  description: Weitgehend verfügbar seit JDK 16 (März 2021)

translations/content/de/concurrency/completablefuture-chaining.yaml

@@ -0,0 +1,19 @@
+title: CompletableFuture-Verkettung
+oldApproach: "Blockierendes Future.get()"
+modernApproach: CompletableFuture
+summary: Asynchrone Operationen ohne Blockierung mit CompletableFuture verketten.
+explanation: "CompletableFuture ermöglicht nicht-blockierende asynchrone Pipelines.\
+  \ Operationen mit thenApply, thenCompose, thenAccept verketten. Fehler mit\
+  \ exceptionally() behandeln. Mehrere Futures mit allOf/anyOf kombinieren."
+whyModernWins:
+- icon: "🔗"
+  title: Verkettbar
+  desc: Asynchrone Schritte zu einer lesbaren Pipeline zusammenfügen.
+- icon: "🚫"
+  title: Nicht-blockierend
+  desc: Kein Thread wartet untätig auf Ergebnisse.
+- icon: "🛡️"
+  title: Fehlerbehandlung
+  desc: "exceptionally() und handle() für saubere Fehlerwiederherstellung."
+support:
+  description: Weitgehend verfügbar seit JDK 8 (März 2014)

translations/content/de/concurrency/concurrent-http-virtual.yaml

@@ -0,0 +1,19 @@
+title: Parallele HTTP-Anfragen mit Virtual Threads
+oldApproach: Thread-Pool + URLConnection
+modernApproach: Virtual Threads + HttpClient
+summary: Viele URLs gleichzeitig mit Virtual Threads und HttpClient abrufen.
+explanation: "Virtual Threads machen es praktikabel, einen Thread pro HTTP-Anfrage\
+  \ zu erstellen. In Kombination mit HttpClient ersetzt dies komplexe asynchrone\
+  \ Callback-Muster durch einfachen blockierenden Code, der skaliert."
+whyModernWins:
+- icon: "♾️"
+  title: Ein Thread pro Anfrage
+  desc: "Kein Pool-Sizing — ein Virtual Thread pro URL."
+- icon: "📖"
+  title: Einfacher Code
+  desc: Unkomplizierten blockierenden Code schreiben.
+- icon: "⚡"
+  title: Hoher Durchsatz
+  desc: Tausende von gleichzeitigen Anfragen mit minimalen Ressourcen.
+support:
+  description: Weitgehend verfügbar seit JDK 21 LTS (Sept. 2023)

translations/content/de/concurrency/executor-try-with-resources.yaml

@@ -0,0 +1,19 @@
+title: ExecutorService automatisch schließen
+oldApproach: Manuelles Herunterfahren
+modernApproach: try-with-resources
+summary: try-with-resources für das automatische Herunterfahren des Executors verwenden.
+explanation: "Seit Java 19 implementiert ExecutorService AutoCloseable. Die Methode\
+  \ close() ruft shutdown() auf und wartet auf den Abschluss der Aufgaben. Keine\
+  \ manuellen try/finally-Shutdown-Muster mehr."
+whyModernWins:
+- icon: "🧹"
+  title: Automatische Bereinigung
+  desc: Das Herunterfahren erfolgt automatisch beim Verlassen des Blocks.
+- icon: "🛡️"
+  title: Keine Lecks
+  desc: "Der Executor wird immer heruntergefahren, auch bei Ausnahmen."
+- icon: "📖"
+  title: Bekanntes Muster
+  desc: "Dasselbe try-with-resources wie für Dateien, Verbindungen usw."
+support:
+  description: Weitgehend verfügbar seit JDK 19 (Sept. 2022)

translations/content/de/concurrency/lock-free-lazy-init.yaml

@@ -0,0 +1,19 @@
+title: Sperrenfreie Lazy-Initialisierung
+oldApproach: synchronized + volatile
+modernApproach: StableValue
+summary: Double-Checked Locking durch StableValue für Lazy-Singletons ersetzen.
+explanation: "StableValue kapselt das Lazy-Initialisierungsmuster mit korrekter\
+  \ Thread-Sicherheit. Die JVM kann den Lesepfad nach der Initialisierung optimieren\
+  \ und ihn potenziell schneller als volatile-Lesevorgänge machen."
+whyModernWins:
+- icon: "🧹"
+  title: Kein Boilerplate
+  desc: "Kein volatile, synchronized oder doppelte Null-Prüfung."
+- icon: "⚡"
+  title: Schnellere Lesevorgänge
+  desc: Die JVM kann den Wert nach der Initialisierung konstant falten.
+- icon: "✅"
+  title: Nachweislich korrekt
+  desc: "Keine subtilen Reihenfolge-Fehler — die JVM kümmert sich darum."
+support:
+  description: "Preview in JDK 25 (JEP 502, StableValue). Erfordert --enable-preview."

translations/content/de/concurrency/process-api.yaml

@@ -0,0 +1,19 @@
+title: Moderne Prozess-API
+oldApproach: "Runtime.exec()"
+modernApproach: ProcessHandle
+summary: OS-Prozesse mit ProcessHandle inspizieren und verwalten.
+explanation: "ProcessHandle stellt PIDs, Prozessinformationen (Befehl, Argumente,\
+  \ Startzeit, CPU-Nutzung), Eltern-Kind-Beziehungen und Prozessbeendigung bereit.\
+  \ Keine undokumentierten Process-Interna mehr."
+whyModernWins:
+- icon: "🔍"
+  title: Vollständige Informationen
+  desc: "Zugriff auf PID, Befehl, Argumente, Startzeit, CPU-Nutzung."
+- icon: "🌳"
+  title: Prozessbaum
+  desc: "Zwischen Eltern, Kindern und Nachkommen navigieren."
+- icon: "📊"
+  title: Überwachung
+  desc: "onExit() gibt ein CompletableFuture für asynchrone Überwachung zurück."
+support:
+  description: Weitgehend verfügbar seit JDK 9 (Sept. 2017)

translations/content/de/concurrency/scoped-values.yaml

@@ -0,0 +1,20 @@
+title: Scoped Values
+oldApproach: ThreadLocal
+modernApproach: ScopedValue
+summary: Daten über den Aufruf-Stack sicher teilen ohne die Fallstricke von ThreadLocal.
+explanation: "ScopedValue bietet unveränderlichen, vererbbaren, bereichsbegrenzten\
+  \ Kontext. Im Gegensatz zu ThreadLocal werden Scoped Values automatisch bereinigt,\
+  \ funktionieren mit Virtual Threads und können von aufgerufenen Methoden nicht\
+  \ verändert werden."
+whyModernWins:
+- icon: "🔒"
+  title: Unveränderlich
+  desc: Aufgerufene Methoden können den Scoped Value lesen, aber nie ändern.
+- icon: "🧹"
+  title: Automatische Bereinigung
+  desc: "Kein manuelles remove() — der Wert ist auf den Block beschränkt."
+- icon: "⚡"
+  title: Virtual-Thread-sicher
+  desc: Funktioniert effizient mit Millionen von Virtual Threads.
+support:
+  description: "Finalisiert in JDK 25 LTS (JEP 506, Sept. 2025)."

translations/content/de/concurrency/stable-values.yaml

@@ -0,0 +1,20 @@
+title: Stable Values
+oldApproach: Double-Checked Locking
+modernApproach: StableValue
+summary: Thread-sichere Lazy-Initialisierung ohne volatile oder synchronized.
+explanation: "StableValue bietet einen träge initialisierten, unveränderlichen Wert\
+  \ mit eingebauter Thread-Sicherheit. Kein Double-Checked Locking, keine volatile-Felder,\
+  \ keine synchronized-Blöcke. Die JVM kann den Lesepfad nach der Initialisierung\
+  \ sogar optimieren."
+whyModernWins:
+- icon: "🧹"
+  title: Null Boilerplate
+  desc: "Kein volatile, synchronized oder Null-Prüfungen."
+- icon: "⚡"
+  title: JVM-optimiert
+  desc: Die JVM kann den Wert nach der Initialisierung falten.
+- icon: "🛡️"
+  title: Garantiert einmalig
+  desc: "Der Supplier wird genau einmal ausgeführt, auch unter Contention."
+support:
+  description: "Preview in JDK 25 (JEP 502). Erfordert --enable-preview."

translations/content/de/concurrency/structured-concurrency.yaml

@@ -0,0 +1,20 @@
+title: Strukturierte Nebenläufigkeit
+oldApproach: Manueller Thread-Lebenszyklus
+modernApproach: StructuredTaskScope
+summary: Den Lebenszyklus nebenläufiger Aufgaben als eine einzige Arbeitseinheit verwalten.
+explanation: "Strukturierte Nebenläufigkeit behandelt eine Gruppe nebenläufiger\
+  \ Aufgaben als eine einzige Operation. Schlägt eine Teilaufgabe fehl, werden die\
+  \ anderen abgebrochen. Der Scope stellt sicher, dass keine Threads verloren gehen,\
+  \ und schafft klare Eltern-Kind-Beziehungen."
+whyModernWins:
+- icon: "🛡️"
+  title: Keine Thread-Lecks
+  desc: Alle verzweigten Aufgaben werden abgeschlossen, bevor der Scope geschlossen wird.
+- icon: "⚡"
+  title: Schnelles Versagen
+  desc: ShutdownOnFailure bricht Geschwister-Aufgaben ab, wenn eine fehlschlägt.
+- icon: "📐"
+  title: Klare Struktur
+  desc: Der Aufgaben-Lebenszyklus entspricht dem lexikalischen Scope im Code.
+support:
+  description: "Preview in JDK 25 (fünfte Preview, JEP 505). Erfordert --enable-preview."

translations/content/de/concurrency/thread-sleep-duration.yaml

@@ -0,0 +1,19 @@
+title: Thread.sleep mit Duration
+oldApproach: Millisekunden
+modernApproach: Duration
+summary: Duration für selbstdokumentierende Zeitangaben verwenden.
+explanation: "Thread.sleep(Duration) macht die Zeiteinheit explizit. Kein Rätselraten\
+  \ mehr, ob 5000 Millisekunden oder Mikrosekunden bedeutet. Funktioniert mit\
+  \ Duration.ofSeconds, ofMillis, ofMinutes usw."
+whyModernWins:
+- icon: "📖"
+  title: Selbstdokumentierend
+  desc: Duration.ofSeconds(5) ist eindeutig.
+- icon: "🛡️"
+  title: Einheitensicher
+  desc: Kein versehentliches Übergeben von Mikrosekunden als Millisekunden.
+- icon: "🧩"
+  title: Kombinierbar
+  desc: "Duration-Arithmetik: plus(), multipliedBy() usw."
+support:
+  description: Weitgehend verfügbar seit JDK 19 (Sept. 2022)