Add French (fr) locale

html-generators/locales.properties

@@ -3,4 +3,5 @@ en=English
 de=Deutsch
 es=Español
 pt-BR=Português (Brasil)
+fr=Français
 ja=日本語

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

@@ -0,0 +1,18 @@
+---
+title: "Collectors.teeing()"
+oldApproach: "Deux passages"
+modernApproach: "teeing()"
+summary: "Calcule deux agrégations en un seul passage du stream."
+explanation: "Collectors.teeing() envoie chaque élément à deux collectors aval et combine les résultats. Cela évite de parcourir les données deux fois ou d'utiliser un accumulateur mutable."
+whyModernWins:
+- icon: "⚡"
+  title: "Un seul passage"
+  desc: "Traite le stream une seule fois au lieu de deux."
+- icon: "🧩"
+  title: "Composable"
+  desc: "Combine deux collectors quelconques avec une fonction de fusion."
+- icon: "🔒"
+  title: "Résultat immutable"
+  desc: "Fusionne directement dans un record ou un objet valeur."
+support:
+  description: "Disponible depuis JDK 12 (mars 2019)"

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

@@ -0,0 +1,18 @@
+---
+title: "Copie immutable de collections"
+oldApproach: "Copie manuelle + wrapper"
+modernApproach: "List.copyOf()"
+summary: "Crée une copie immutable de n'importe quelle collection en un seul appel."
+explanation: "List.copyOf(), Set.copyOf() et Map.copyOf() créent des instantanés immutables de collections existantes. Si la source est déjà une collection immutable, aucune copie n'est effectuée."
+whyModernWins:
+- icon: "⚡"
+  title: "Copie intelligente"
+  desc: "Ignore la copie si la source est déjà immutable."
+- icon: "📏"
+  title: "Un seul appel"
+  desc: "Sans construction manuelle d'ArrayList + wrapper."
+- icon: "🛡️"
+  title: "Copie défensive"
+  desc: "Les modifications de l'original n'affectent pas la copie."
+support:
+  description: "Disponible depuis JDK 10 (mars 2018)"

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

@@ -0,0 +1,18 @@
+---
+title: "Création de listes immutables"
+oldApproach: "Wrapper verbeux"
+modernApproach: "List.of()"
+summary: "Crée des listes immutables en une seule expression claire."
+explanation: "List.of() crée une liste véritablement immutable — sans wrapper, sans copie défensive. Elle rejette les éléments null et est structurellement immutable. L'ancienne méthode nécessitait trois appels imbriqués."
+whyModernWins:
+- icon: "📏"
+  title: "Un seul appel"
+  desc: "Remplace trois appels imbriqués par une unique méthode factory."
+- icon: "🔒"
+  title: "Véritablement immutable"
+  desc: "Ce n'est pas juste un wrapper — la liste elle-même est immutable."
+- icon: "🛡️"
+  title: "Sûre contre null"
+  desc: "Rejette les éléments null à la création, échouant rapidement."
+support:
+  description: "Disponible depuis JDK 9 (sept. 2017)"

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

@@ -0,0 +1,18 @@
+---
+title: "Création de maps immutables"
+oldApproach: "Pattern builder de Map"
+modernApproach: "Map.of()"
+summary: "Crée des maps immutables en ligne sans avoir besoin d'un builder."
+explanation: "Map.of() accepte des paires clé-valeur en ligne et retourne une map immutable. Pour plus de 10 entrées, utilisez Map.ofEntries() avec des paires Map.entry()."
+whyModernWins:
+- icon: "📏"
+  title: "Création en ligne"
+  desc: "Aucune map mutable temporaire nécessaire."
+- icon: "🔒"
+  title: "Résultat immutable"
+  desc: "La map ne peut pas être modifiée après sa création."
+- icon: "🚫"
+  title: "Sans clés/valeurs null"
+  desc: "Les entrées null sont rejetées immédiatement."
+support:
+  description: "Disponible depuis JDK 9 (sept. 2017)"

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

@@ -0,0 +1,18 @@
+---
+title: "Création de sets immutables"
+oldApproach: "Wrapper verbeux"
+modernApproach: "Set.of()"
+summary: "Crée des sets immutables avec un unique appel factory."
+explanation: "Set.of() crée un set véritablement immutable qui rejette les éléments null et les doublons à la création. Fini de wrapper des sets mutables."
+whyModernWins:
+- icon: "📏"
+  title: "Concis"
+  desc: "Une ligne au lieu de trois appels imbriqués."
+- icon: "🚫"
+  title: "Détecte les doublons"
+  desc: "Lève une exception si vous passez des éléments dupliqués par accident."
+- icon: "🔒"
+  title: "Immutable"
+  desc: "Impossible d'ajouter ou de supprimer après la création."
+support:
+  description: "Disponible depuis JDK 9 (sept. 2017)"

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

@@ -0,0 +1,18 @@
+---
+title: "Factory Map.entry()"
+oldApproach: "SimpleEntry"
+modernApproach: "Map.entry()"
+summary: "Crée des entrées de map avec une méthode factory propre."
+explanation: "Map.entry() remplace le constructeur verbeux de AbstractMap.SimpleEntry. Elle retourne une entrée immutable, idéale pour Map.ofEntries() et les opérations de stream."
+whyModernWins:
+- icon: "📏"
+  title: "Concis"
+  desc: "Une ligne au lieu de trois, avec une intention plus claire."
+- icon: "🔒"
+  title: "Immutable"
+  desc: "L'entrée retournée ne peut pas être modifiée."
+- icon: "🧩"
+  title: "Composable"
+  desc: "Fonctionne parfaitement avec Map.ofEntries() pour les grandes maps."
+support:
+  description: "Disponible depuis JDK 9 (sept. 2017)"

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

@@ -0,0 +1,18 @@
+---
+title: "Itération inverse de listes"
+oldApproach: "ListIterator manuel"
+modernApproach: "reversed()"
+summary: "Itère sur une liste dans l'ordre inverse avec une boucle for-each propre."
+explanation: "La méthode reversed() de SequencedCollection retourne une vue dans l'ordre inverse de la liste. Cette vue est soutenue par la liste originale, donc aucune copie n'est effectuée. La syntaxe de la boucle for améliorée rend l'itération inverse aussi lisible que l'itération vers l'avant."
+whyModernWins:
+- icon: "📖"
+  title: "Syntaxe naturelle"
+  desc: "Boucle for améliorée au lieu du verbose ListIterator."
+- icon: "⚡"
+  title: "Sans copie"
+  desc: "reversed() retourne une vue — sans surcharge de performance."
+- icon: "🧩"
+  title: "API cohérente"
+  desc: "Fonctionne uniformément sur List, Deque et SortedSet."
+support:
+  description: "Disponible depuis JDK 21 LTS (sept. 2023)"

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

@@ -0,0 +1,18 @@
+---
+title: "Collections séquencées"
+oldApproach: "Arithmétique d'indices"
+modernApproach: "getFirst/getLast"
+summary: "Accédez au premier et dernier élément et obtenez des vues inversées avec des méthodes d'API propres."
+explanation: "SequencedCollection ajoute getFirst(), getLast(), reversed(), addFirst() et addLast() à List, Deque, SortedSet et LinkedHashSet. Fini l'arithmétique size-1 ou l'itération inverse manuelle."
+whyModernWins:
+- icon: "📖"
+  title: "Auto-documenté"
+  desc: "getLast() est plus clair que get(size()-1)."
+- icon: "🔄"
+  title: "Vue inverse"
+  desc: "reversed() offre une vue — sans besoin de copier."
+- icon: "🧩"
+  title: "API uniforme"
+  desc: "Fonctionne pareillement sur List, Deque et SortedSet."
+support:
+  description: "Disponible depuis JDK 21 LTS (sept. 2023)"

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

@@ -0,0 +1,18 @@
+---
+title: "toArray typé dans les streams"
+oldApproach: "Copie manuelle de tableau"
+modernApproach: "toArray(generator)"
+summary: "Convertit des streams en tableaux typés avec une référence de méthode."
+explanation: "La méthode toArray(IntFunction) crée un tableau correctement typé à partir d'un stream. Le générateur (String[]::new) indique au stream quel type de tableau créer."
+whyModernWins:
+- icon: "🎯"
+  title: "Sûr en termes de types"
+  desc: "Sans cast vers Object[] — le type du tableau est correct."
+- icon: "🔗"
+  title: "Enchaînable"
+  desc: "Fonctionne à la fin de n'importe quel pipeline de stream."
+- icon: "📏"
+  title: "Concis"
+  desc: "Une seule expression remplace la boucle manuelle."
+support:
+  description: "Disponible depuis JDK 8 (mars 2014)"

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

@@ -0,0 +1,18 @@
+---
+title: "Collectors non modifiables"
+oldApproach: "collectingAndThen"
+modernApproach: "stream.toList()"
+summary: "Collecte directement dans une liste non modifiable avec stream.toList()."
+explanation: "Java 10 a ajouté toUnmodifiableList(), toUnmodifiableSet() et toUnmodifiableMap() pour remplacer le wrapper verbose collectingAndThen. Pour les listes spécifiquement, stream.toList() de Java 16 offre une alternative encore plus simple — sans appel à collect() du tout. Utilisez toUnmodifiableSet() et toUnmodifiableMap() pour les autres types de collections."
+whyModernWins:
+- icon: "📏"
+  title: "Le plus court possible"
+  desc: "stream.toList() ne nécessite pas collect() ni l'import de Collectors."
+- icon: "🔒"
+  title: "Immutable"
+  desc: "Le résultat ne peut pas être modifié — sans mutations accidentelles."
+- icon: "📖"
+  title: "Lisible"
+  desc: "Se lit naturellement comme étape terminale de n'importe quel pipeline de stream."
+support:
+  description: "Disponible depuis JDK 16 (mars 2021)"

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

@@ -0,0 +1,18 @@
+---
+title: Chaînage avec CompletableFuture
+oldApproach: Future.get() bloquant
+modernApproach: CompletableFuture
+summary: Enchaîne des opérations asynchrones sans blocage avec CompletableFuture.
+explanation: CompletableFuture permet des pipelines asynchrones non bloquants. Enchaînez les opérations avec thenApply, thenCompose, thenAccept. Gérez les erreurs avec exceptionally(). Combinez plusieurs futurs avec allOf/anyOf.
+whyModernWins:
+- icon: 🔗
+  title: Enchaînable
+  desc: Composez des étapes asynchrones dans un pipeline lisible.
+- icon: 🚫
+  title: Sans blocage
+  desc: Aucun thread ne reste inactif en attendant les résultats.
+- icon: 🛡️
+  title: Gestion des erreurs
+  desc: exceptionally() et handle() pour une récupération propre des erreurs.
+support:
+  description: Disponible depuis JDK 8 (mars 2014)

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

@@ -0,0 +1,18 @@
+---
+title: HTTP concurrent avec les threads virtuels
+oldApproach: Thread Pool + URLConnection
+modernApproach: Virtual Threads + HttpClient
+summary: Récupère de nombreuses URLs en parallèle avec les threads virtuels et HttpClient.
+explanation: Les threads virtuels rendent pratique la création d'un thread par requête HTTP. Combiné avec HttpClient, cela remplace des patterns complexes de callbacks asynchrones par du code bloquant simple qui passe à l'échelle.
+whyModernWins:
+- icon: ♾️
+  title: Un thread par requête
+  desc: Sans dimensionner les pools — un thread virtuel par URL.
+- icon: 📖
+  title: Code simple
+  desc: Écrivez du code bloquant direct et simple.
+- icon: ⚡
+  title: Haute performance
+  desc: Des milliers de requêtes concurrentes avec des ressources minimales.
+support:
+  description: Disponible depuis JDK 21 LTS (sept. 2023)

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

@@ -0,0 +1,18 @@
+---
+title: Fermeture automatique d'ExecutorService
+oldApproach: Fermeture manuelle
+modernApproach: try-with-resources
+summary: Utilisez try-with-resources pour la fermeture automatique de l'executor.
+explanation: Depuis Java 19, ExecutorService implémente AutoCloseable. La méthode close() appelle shutdown() et attend que les tâches se terminent. Fini les patterns manuels try/finally pour la fermeture.
+whyModernWins:
+- icon: 🧹
+  title: Nettoyage automatique
+  desc: La fermeture se fait automatiquement à la sortie du bloc.
+- icon: 🛡️
+  title: Sans fuites
+  desc: L'executor est toujours fermé, même si des exceptions se produisent.
+- icon: 📖
+  title: Pattern familier
+  desc: Le même try-with-resources utilisé pour les fichiers, connexions, etc.
+support:
+  description: Disponible depuis JDK 19 (sept. 2022)

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

@@ -0,0 +1,18 @@
+---
+title: Initialisation paresseuse sans verrous
+oldApproach: synchronized + volatile
+modernApproach: StableValue
+summary: Remplace le double-checked locking par StableValue pour les singletons paresseux.
+explanation: StableValue encapsule le pattern d'initialisation paresseuse avec une sécurité thread correcte. La JVM peut optimiser le chemin de lecture après l'initialisation, le rendant potentiellement plus rapide que les lectures volatile.
+whyModernWins:
+- icon: 🧹
+  title: Sans code répétitif
+  desc: Sans volatile, synchronized ni double-null-check.
+- icon: ⚡
+  title: Lectures plus rapides
+  desc: La JVM peut plier les constantes après l'initialisation.
+- icon: ✅
+  title: Correction démontrable
+  desc: Sans erreurs subtiles d'ordonnancement — la JVM s'en charge.
+support:
+  description: Aperçu dans JDK 25 (JEP 502, StableValue). Nécessite --enable-preview.

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

@@ -0,0 +1,18 @@
+---
+title: API moderne des processus
+oldApproach: Runtime.exec()
+modernApproach: ProcessHandle
+summary: Inspectez et gérez les processus du système d'exploitation avec ProcessHandle.
+explanation: ProcessHandle fournit les PIDs, les informations de processus (commande, arguments, heure de démarrage, utilisation CPU), les relations parent-enfant et la destruction de processus. Fini de dépendre des parties internes non documentées de Process.
+whyModernWins:
+- icon: 🔍
+  title: Informations complètes
+  desc: Accès au PID, commande, arguments, heure de démarrage, utilisation CPU.
+- icon: 🌳
+  title: Arbre de processus
+  desc: Naviguez entre parent, enfants et descendants.
+- icon: 📊
+  title: Surveillance
+  desc: onExit() retourne un CompletableFuture pour la surveillance asynchrone.
+support:
+  description: Disponible depuis JDK 9 (sept. 2017)

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

@@ -0,0 +1,18 @@
+---
+title: Valeurs à portée
+oldApproach: ThreadLocal
+modernApproach: ScopedValue
+summary: Partagez des données le long de la pile d'appels en toute sécurité sans les problèmes de ThreadLocal.
+explanation: ScopedValue fournit un contexte immutable, héritable et limité à une portée. Contrairement à ThreadLocal, les valeurs à portée sont nettoyées automatiquement, fonctionnent avec les threads virtuels et ne peuvent pas être modifiées par les méthodes appelées.
+whyModernWins:
+- icon: 🔒
+  title: Immutable
+  desc: Les méthodes appelées peuvent lire mais jamais modifier la valeur à portée.
+- icon: 🧹
+  title: Nettoyage automatique
+  desc: Sans remove() manuel — la valeur est limitée au bloc.
+- icon: ⚡
+  title: Compatible avec les threads virtuels
+  desc: Fonctionne efficacement avec des millions de threads virtuels.
+support:
+  description: Finalisé dans JDK 25 LTS (JEP 506, sept. 2025).

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

@@ -0,0 +1,18 @@
+---
+title: Valeurs stables
+oldApproach: Double-Checked Locking
+modernApproach: StableValue
+summary: Initialisation paresseuse thread-safe sans volatile ni synchronized.
+explanation: StableValue fournit une valeur initialisée paresseusement et immutable avec une sécurité thread intégrée. Sans double-checked locking, sans champs volatile, sans blocs synchronized. La JVM peut même optimiser le chemin de lecture après l'initialisation.
+whyModernWins:
+- icon: 🧹
+  title: Zéro code répétitif
+  desc: Sans volatile, synchronized ni vérifications de null.
+- icon: ⚡
+  title: Optimisé par la JVM
+  desc: La JVM peut plier la valeur après l'initialisation.
+- icon: 🛡️
+  title: Exécution unique garantie
+  desc: Le fournisseur s'exécute exactement une fois, même sous contention.
+support:
+  description: Aperçu dans JDK 25 (JEP 502). Nécessite --enable-preview.

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

@@ -0,0 +1,18 @@
+---
+title: Concurrence structurée
+oldApproach: Cycle de vie manuel des threads
+modernApproach: StructuredTaskScope
+summary: Gérez le cycle de vie des tâches concurrentes comme une seule unité de travail.
+explanation: La concurrence structurée traite un groupe de tâches concurrentes comme une seule opération. Si une sous-tâche échoue, les autres sont annulées. La portée garantit qu'il n'y a pas de fuites de threads et établit des relations claires parent-enfant.
+whyModernWins:
+- icon: 🛡️
+  title: Sans fuites de threads
+  desc: Toutes les tâches bifurquées se terminent avant la fermeture de la portée.
+- icon: ⚡
+  title: Échec rapide
+  desc: ShutdownOnFailure annule les tâches sœurs si l'une échoue.
+- icon: 📐
+  title: Structure claire
+  desc: Le cycle de vie de la tâche correspond à la portée lexicale dans le code.
+support:
+  description: Aperçu dans JDK 25 (cinquième aperçu, JEP 505). Nécessite --enable-preview.

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

@@ -0,0 +1,18 @@
+---
+title: Thread.sleep avec Duration
+oldApproach: Millisecondes
+modernApproach: Duration
+summary: Utilisez Duration pour des valeurs temporelles auto-documentées.
+explanation: Thread.sleep(Duration) rend l'unité de temps explicite. Plus besoin de deviner si 5000 signifie des millisecondes ou des microsecondes. Fonctionne avec Duration.ofSeconds, ofMillis, ofMinutes, etc.
+whyModernWins:
+- icon: 📖
+  title: Auto-documenté
+  desc: Duration.ofSeconds(5) est sans ambiguïté.
+- icon: 🛡️
+  title: Sûr en termes d'unités
+  desc: Sans passer accidentellement des microsecondes comme des millisecondes.
+- icon: 🧩
+  title: Composable
+  desc: "Arithmétique avec Duration : plus(), multipliedBy(), etc."
+support:
+  description: Disponible depuis JDK 19 (sept. 2022)

translations/content/fr/concurrency/virtual-threads.yaml

@@ -0,0 +1,18 @@
+---
+title: Threads virtuels
+oldApproach: Threads de plateforme
+modernApproach: Virtual Threads
+summary: Créez des millions de threads virtuels légers au lieu de lourds threads du système d'exploitation.
+explanation: Les threads virtuels sont des threads légers gérés par la JVM, pas par le système d'exploitation. Vous pouvez en créer des millions sans ajuster les pools de threads. Ils sont idéaux pour les tâches avec beaucoup d'E/S comme les appels HTTP et les requêtes de bases de données.
+whyModernWins:
+- icon: ⚡
+  title: Légers
+  desc: Les threads virtuels utilisent des Ko de mémoire, les threads de plateforme utilisent des Mo.
+- icon: ♾️
+  title: Évolutifs
+  desc: Créez des millions de threads — sans besoin de dimensionner les pools.
+- icon: 🧹
+  title: Modèle simple
+  desc: Écrivez du code bloquant qui passe à l'échelle comme du code asynchrone.
+support:
+  description: Disponible depuis JDK 21 LTS (sept. 2023)