Update 02-partie2.md

B13-examen-mi-session-01/02-partie2.md

@@ -1,5 +1,6 @@
+----------------------------------------------------------------------------
 # proposition de réponse 1 
-
+----------------------------------------------------------------------------
 
 Le code proposé est fonctionnel, mais il y a plusieurs aspects qui peuvent être optimisés pour améliorer la lisibilité, la performance et la sécurité du code. 
 
@@ -93,8 +94,9 @@ Ces optimisations améliorent la lisibilité, la performance et la robustesse du
 
 
 
+----------------------------------------------------------------------------
 # proposition de réponse 2
-
+----------------------------------------------------------------------------
 
 
 Le code fourni est globalement correct et fonctionnel pour le traitement de données textuelles à l'aide de Spark. Cependant, plusieurs améliorations peuvent être apportées pour optimiser les performances et assurer une meilleure pratique en programmation. Voici un retour détaillé sur les points à corriger ou à améliorer :
@@ -192,3 +194,83 @@ def displayResults(results: Array[(Int, (String, Int))]): Unit = {
 ### **Conclusion** :
 En suivant ces améliorations, le code sera non seulement plus sûr et maintenable, mais il sera aussi mieux adapté pour traiter de grandes quantités de données. L’utilisation de bonnes pratiques comme l'immutabilité (`val`), la gestion des erreurs (`try-catch`), et l’optimisation des opérations coûteuses en mémoire (`cache()`, `saveAsTextFile()`) est cruciale pour garantir un traitement performant et fiable des données dans un projet Big Data.
 
+
+----------------------------------------------------------------------------
+# Code amélioré 
+----------------------------------------------------------------------------
+
+
+- Je vous proposeune version complète et optimisée du code, intégrant toutes les recommandations pour assurer une meilleure lisibilité, performance, et robustesse dans un contexte de Big Data :
+
+```scala
+import org.apache.spark.{SparkConf, SparkContext}
+import org.apache.spark.rdd.RDD
+
+object RDDExample {
+  def main(args: Array[String]): Unit = {
+    // Configuration et initialisation de Spark avec une session immuable
+    val conf = new SparkConf().setAppName("RDD Example").setMaster("local[*]")
+    val sc = new SparkContext(conf)
+
+    try {
+      // Chargement de grandes données depuis un fichier texte (en vérifiant le chemin du fichier)
+      val lines = loadLines(sc, "large_dataset.txt")
+
+      // Comptage des occurrences de mots
+      val wordCounts = countWords(lines)
+
+      // Tri des mots par longueur
+      val sortedByLength = sortByLength(wordCounts)
+
+      // Enregistrer les résultats triés dans un fichier
+      sortedByLength.saveAsTextFile("sorted_results.txt")
+
+    } catch {
+      case e: Exception => println(s"Erreur lors de l'exécution : ${e.getMessage}")
+    } finally {
+      // Toujours fermer SparkContext pour libérer les ressources
+      sc.stop()
+    }
+  }
+
+  // Fonction pour charger les lignes d'un fichier texte
+  def loadLines(sc: SparkContext, path: String): RDD[String] = {
+    sc.textFile(path)
+  }
+
+  // Fonction pour compter les occurrences des mots après avoir mis les mots en minuscule
+  def countWords(lines: RDD[String]): RDD[(String, Int)] = {
+    lines.flatMap(_.toLowerCase.split("\\s+"))
+         .map(word => (word, 1))
+         .reduceByKey(_ + _)
+         .cache() // Mise en cache pour optimiser la réutilisation
+  }
+
+  // Fonction pour trier les mots par leur longueur
+  def sortByLength(wordCounts: RDD[(String, Int)]): RDD[(Int, (String, Int))] = {
+    wordCounts.map { case (word, count) => (word.length, (word, count)) }
+              .sortByKey()
+  }
+}
+```
+
+### **Explication des améliorations :**
+
+1. **Immutabilité avec `val` :** Toutes les variables qui ne changent pas après leur création (par exemple, `conf`, `sc`, `lines`) sont déclarées en tant que `val` pour garantir l'immutabilité.
+
+2. **Fermeture du SparkContext :** Ajout de `sc.stop()` dans le bloc `finally` pour s'assurer que le SparkContext est toujours fermé, même en cas d'erreur.
+
+3. **Gestion des erreurs :** Un bloc `try-catch` est ajouté pour capturer et gérer les exceptions potentielles, ce qui est crucial pour les environnements de production.
+
+4. **Gestion de la casse des mots :** Les mots sont convertis en minuscules avant d'être comptés pour éviter de considérer « Bonjour » et « bonjour » comme deux mots différents.
+
+5. **Optimisation avec `cache()` :** Utilisation de `cache()` pour stocker les résultats intermédiaires en mémoire, améliorant ainsi les performances en évitant de recalculer les RDDs si réutilisés.
+
+6. **Écriture des résultats dans un fichier :** Le tri des résultats est écrit dans un fichier avec `saveAsTextFile()` au lieu de tout collecter en mémoire, ce qui est plus adapté pour les grands ensembles de données.
+
+7. **Refactorisation en fonctions** : Le code est divisé en plusieurs fonctions (`loadLines`, `countWords`, `sortByLength`) pour améliorer la lisibilité et la maintenabilité.
+
+---
+
+### **Conclusion :**
+Ce code est maintenant plus sûr, maintenable, et performant. Il intègre des pratiques de programmation recommandées dans un environnement de Big Data avec Spark, tout en évitant les pièges courants liés à la gestion de la mémoire et des erreurs.