Scala

Scala pour le Big Data et la Fouille de Données

1. Informations Générales

   1. Objectifs du cours

      1. Comprendre les bases du langage Scala et ses paradigmes (orienté objet et fonctionnel).
      2. Apprendre à manipuler les collections et travailler avec des données en Scala.
      3. Découvrir les bibliothèques et frameworks Scala pour le Big Data (Spark, Akka, etc.).
      4. Appliquer Scala dans des projets de fouille de données et d’analyse de grandes quantités de données.

   2. Public cible

      • Étudiants ou professionnels ayant des bases en programmation et un intérêt pour le Big Data ou la fouille de données. Des connaissances préalables en Python/Java et sur les concepts de Big Data (Hadoop, Spark, etc.) seraient un plus.

2. Modules

   1. Introduction à Scala

      1. Introduction

         1. Histoire et contexte de Scala

            Scala (acronyme de Scalable Language) est un langage de programmation créé en 2003 par Martin Odersky à l'École polytechnique fédérale de Lausanne (EPFL).

            • Inspiré par Java, Scala s'exécute sur la JVM (Java Virtual Machine).
            • Fusionne programmation orientée objet et programmation fonctionnelle.
            • Particulièrement apprécié dans les domaines du Big Data et de l’ingénierie logicielle avancée.

         2. Caractéristiques principales

            • Syntaxe concise et expressive.
            • Interopérabilité complète avec Java.
            • Support des concepts avancés comme l’immutabilité, les fonctions pures, et les collections immuables.

         3. Avantages de Scala pour le Big Data

            Scala est largement utilisé pour le Big Data en raison de ses fonctionnalités avancées :

            • Compatibilité Spark : Scala est le langage natif d'Apache Spark, l'un des frameworks Big Data les plus populaires.
            • Performance : Grâce à la JVM, Scala combine vitesse et robustesse.
            • Écosystème riche : Accès aux bibliothèques Java et Scala pour des tâches complexes comme la gestion de données, la parallélisation, ou l’analyse.

         4. 🧪 Mini-lab Scala : Les bases et la data

            Objectif : Découvrir les bases de Scala à travers des exemples pratiques, puis manipuler une petite liste de données comme un Data Scientist !

            1. Variables et types
               

               val nom = "Alice" // immutable
               var age = 30        // mutable
               println(s"Bonjour $nom, tu as $age ans.")

            2. Collections et opérations
               

               val notes = List(12, 15, 17, 8, 13)
               val moyenne = notes.sum.toDouble / notes.length
               val notesSup12 = notes.filter(_ > 12)
               println(s"Moyenne : $moyenne, Notes > 12 : $notesSup12")

            3. Fonctions et map/filter
               

               def maj(x: Int): Int = x + 1
               val notesMaj = notes.map(maj)
               println(notesMaj)

            4. Case class et pattern matching
               

               case class Etudiant(nom: String, note: Int)
               val etudiants = List(Etudiant("Alice", 15), Etudiant("Bob", 10))
               for (e <- etudiants) e match {
                 case Etudiant(n, note) if note >= 12 => println(s"$n a la moyenne")
                 case Etudiant(n, note) => println(s"$n n'a pas la moyenne")
               }

            5. Mini-analyse de données
               

               val ventes = List(
                 ("stylo", 10, 1.5),
                 ("cahier", 5, 2.0),
                 ("stylo", 7, 1.5),
                 ("livre", 3, 10.0)
               )
               val totalParProduit = ventes.groupBy(_._1).map {
                 case (produit, items) =>
                   val total = items.map { case (_, qte, prix) => qte * prix }.sum
                   (produit, total)
               }
               println(totalParProduit)

            Tu viens de manipuler des listes, des fonctions, des classes et de faire une mini-analyse comme un pro du Big Data !

      2. Outils, Installation et configuration (Scala REPL, sbt, IntelliJ IDEA)

         1. Outils nécessaires

            Pour commencer avec Scala, il faut avoir les outils suivants :

            1. Coursier

               Coursier est un gestionnaire de paquets et de dépendances pour l’écosystème Scala et Java. Il simplifie l'installation des outils nécessaires pour travailler avec Scala et permet de gérer les dépendances d'un projet de manière rapide et efficace.

               1. Principales fonctionnalités de Coursier

                  1. Installation d'outils Scala

                     1. Permet d’installer Scala, sbt, et d'autres outils comme ammonite et bloop.
                     2. Remplace ou complète des outils comme SDKMAN ou les installateurs manuels.

                  2. Gestion des dépendances

                     1. Télécharge rapidement les bibliothèques nécessaires pour un projet Scala ou Java depuis Maven Central, Ivy, ou d’autres dépôts.
                     2. Résout les conflits entre versions de dépendances.

                  3. Exécution d'applications

                     1. Peut exécuter directement des applications Scala ou Java depuis les dépôts Maven (par exemple, un exécutable JAR).
                     2. Multi-plateforme : Fonctionne sur Windows, macOS, et Linux.

               2. Pourquoi utiliser Coursier ?

                  1. Rapidité : Téléchargement et résolution des dépendances plus rapides que les outils traditionnels.
                  2. Légèreté : Conçu pour être léger et efficace.
                  3. Interopérabilité : Compatible avec des projets Java et Scala.
                  4. Praticité : Offre une interface simple pour installer et gérer plusieurs versions de Scala ou d’autres outils.

               3. Installer Coursier

                  Coursier

                  Coursier peut être installé facilement avec une commande simple :

                  1. linux

                     # On x86-64 (aka AMD64)

                     curl -fL https://github.com/coursier/launchers/raw/master/cs-x86_64-pc-linux.gz | gzip -d > cs

                     chmod +x cs

                     ./cs setup

                  2. macOS - brew based installation

                     brew install coursier/formulas/coursier

                     cs setup

                  3. Windows

                     # PowerShell

                     Invoke-WebRequest -Uri "https://github.com/coursier/launchers/raw/master/cs-x86_64-pc-win32.zip" -OutFile "cs-x86_64-pc-win32.zip"

                     Expand-Archive -Path "cs-x86_64-pc-win32.zip" -DestinationPath .

                     Rename-Item -Path "cs-x86_64-pc-win32.exe" -NewName "cs.exe"

                     Remove-Item -Path "cs-x86_64-pc-win32.zip"

                     .\cs setup

                  coursier docs cli-installation

               4. Commandes courantes de Coursier

                  1. Installer Scala :

                     cs install scala

                  2. Vérifiez l'installation avec :

                     scala -version

                  3. Installer sbt :

                     cs install sbt

                  4. Télécharger une bibliothèque spécifique : Par exemple, pour télécharger la bibliothèque cats :

                     cs fetch org.typelevel:cats-core_2.13:2.9.0

                  5. Lancer un programme Scala directement : Si vous voulez exécuter une application Scala publiée comme artefact :

                     cs launch org.scalameta:scalafmt-cli_2.13:3.7.1 -- --help

            2. Le REPL

               1. Présentation

                  Le REPL (Read-Eval-Print Loop) est un environnement interactif qui permet d’écrire et d’exécuter des morceaux de code de manière immédiate.

                  Le REPL est souvent décrit comme une "calculette pour le code", offrant une manière simple et interactive d’expérimenter un langage de programmation.

                  L'acronyme décrit les étapes de son fonctionnement :

                  1. Read : Le REPL lit une commande ou une expression entrée par l’utilisateur.
                  2. Eval : Il évalue (exécute) cette commande ou expression.
                  3. Print : Il affiche le résultat de l’évaluation.
                  4. Loop : Il revient au début pour attendre une nouvelle commande ou expression.

                  C’est un outil précieux pour les développeurs, en particulier pour tester rapidement des idées, expérimenter du code, ou encore pour apprendre un langage de programmation.

               2. Caractéristiques principales du REPL

                  1. Interactivité : Permet de tester du code ligne par ligne sans avoir à écrire un programme complet.
                  2. Rapidité : Idéal pour valider de petites portions de code ou pour déboguer.
                  3. Flexibilité : Très utile pour les débutants ou pour découvrir les fonctionnalités d’un langage.

               3. Le REPL dans Scala

                  Scala dispose de son propre REPL. Il est accessible en ligne de commande après l’installation de Scala.

               4. Lancer le REPL Scala

                  1. Ouvrez un terminal.
                  2. Tapez la commande :

                     scala

                  3. Nous allons voir apparaître un environnement interactif comme ceci :

                     Welcome to Scala 2.13.x (OpenJDK 64-Bit Server VM, Java 11).

                     Type in expressions for evaluation. Or try :help.

                  4. Nous pouvons alors saisir des expressions Scala :

                     println("Hello, Scala!")

                     val x = 42

                     println(x * 2)

               5. Commandes utiles dans le REPL Scala

                  1. :help

                     : Affiche les commandes disponibles.

                  2. :quit

                     : Quitte le REPL.

                  3. :load filename.scala

                     : Charge un fichier Scala et exécute son contenu.

                  4. :reset

                     : Réinitialise l’état du REPL (supprime les variables et définitions).

               6. Applications pratiques du REPL

                  1. Apprentissage : Parfait pour les débutants pour essayer et comprendre les concepts de base.
                  2. Prototypage rapide : Tester des fonctions, des algorithmes ou des idées avant de les intégrer dans un projet.
                  3. Exploration des APIs : Permet de découvrir et tester les bibliothèques et fonctions d’un langage.

            3. Giter8: .g8

               1. Qu'est-ce que Giter8 ?

                  Giter8 est un outil qui permet de générer des projets basés sur des modèles prédéfinis. Ces modèles incluent des fichiers et des configurations nécessaires pour commencer rapidement un projet Scala, sbt, ou autre.

               2. Pourquoi utiliser .g8 ?

                  1. Automatisation : Facilite la création rapide de projets avec une structure standard.
                  2. Personnalisation : Les fichiers peuvent inclure des variables dynamiques pour personnaliser des éléments comme le nom du projet, la version Scala, etc.
                  3. Standardisation : Garantit que tous les projets respectent une structure cohérente.

               3. Exemple avec sbt et Giter8

                  Quand vous utilisez la commande suivante :

                  sbt new scala/hello-world.g8

                  Voici ce qui se passe :

                  1. scala/hello-world.g8 est un modèle de projet hébergé sur GitHub (par exemple, dans un dépôt https://github.com/scala/hello-world.g8).
                  2. sbt utilise Giter8 pour cloner ce modèle et l’appliquer localement.
                  3. Le projet généré contient déjà une structure avec des fichiers comme build.sbt, src/main/scala/Main.scala, etc., prêts à l’emploi.

               4. Fichiers typiques dans un projet Giter8

                  Un projet .g8 contient généralement :

                  1. Des fichiers modèles pour le code et la configuration (par exemple, build.sbt, Main.scala).
                  2. Un fichier default.properties pour définir des variables (nom du projet, organisation, version).
                  3. Des scripts pour personnaliser le processus de génération.

               5. Avantages pour Scala

                  1. Possibilité de démarrer avec une base solide sans perdre de temps à configurer manuellement votre projet.
                  2. Idéal pour les débutants et les équipes souhaitant utiliser une structure homogène.

                  Pour en savoir plus sur Giter8, consultez la documentation officielle.

            4. sbt (Simple Build Tool) : Outil de gestion des projets Scala.
            5. IDE : IntelliJ IDEA (recommandé) ou Visual Studio Code avec le plugin Metals.

         2. Étapes d'installation

            1. Installation de Scala

               1. Téléchargez et installez Scala via le gestionnaire de versions Coursier par exemple.

            2. Vérifiez l'installation

               scala -version

            3. Installation de sbt

               1. Téléchargez sbt à partir du site officiel.
               2. Vérifiez l'installation :

                  sbt about

            4. Installation d’IntelliJ IDEA

               1. Téléchargez IntelliJ IDEA Community Edition : IntelliJ IDEA.
               2. Installez le plugin Scala :
                  1. Ouvrez IntelliJ IDEA.
                  2. Allez dans File > Settings > Plugins.
                  3. Recherchez Scala et installez-le.

      3. Premiers pas avec Scala

         1. Lancement du REPL Scala

            Le REPL (Read-Eval-Print Loop) permet d’exécuter du code interactivement.

            1. Ouvrez un terminal.
            2. Lancez le REPL avec :

               scala

            3. Essayez quelques commandes simples :

               println("Bonjour Scala!")

               val x = 10

               val y = 20

               println(s"La somme de x et y est : ${x + y}")

      4. Bases du langage

         1. Syntaxe de base.
         2. Types de données, variables et constantes.
         3. Entrées et sorties (lecture de fichiers simples).

      5. Paradigmes de programmation

         1. Programmation orientée objet en Scala (classes, objets, traits).
         2. Programmation fonctionnelle (fonctions anonymes, curryfication, immutabilité).

   2. Manipulation de données en Scala

      1. Collections Scala

         1. Listes, tableaux, ensembles et maps.
         2. Collections immuables et mutables.
         3. Opérations courantes (filtrage, tri, mappage).

      2. Gestion des fichiers

         1. Lecture et écriture de fichiers CSV, JSON.
         2. Préparation des données pour des analyses.

      3. Concurrence et parallélisme

         1. Futures et Promises.
         2. Aperçu de l’API Akka.

   3. Scala pour le Big Data

      1. Introduction à Apache Spark

         1. Configuration d’un environnement Spark avec Scala.
         2. Concepts de base : RDD, DataFrames, DataSets.
         3. Exécution de transformations et actions avec Spark.

      2. Traitement de Big Data avec Scala

         1. Chargement et manipulation de grandes quantités de données.
         2. Pré-traitement et nettoyage des données.

      3. Optimisation

         1. Amélioration des performances avec les DataFrames et SQL Spark.
         2. Introduction à Catalyst et Tungsten.

   4. Fouille de données avec Scala

      1. Introduction à la fouille de données

         1. Concepts de base et applications pratiques.
         2. Méthodologies : préparation des données, exploration et modélisation.

      2. Utilisation des bibliothèques Scala pour l’analyse

         1. MLlib pour les algorithmes d’apprentissage machine.
         2. GraphX pour l’analyse de graphes.

      3. Cas pratiques

         1. Analyse de logs de serveurs web.
         2. Traitement des données de réseaux sociaux.
         3. Détection des fraudes dans des bases de données transactionnelles.

3. Projet final

   1. Choix du projet

      1. Analyse d’un grand jeu de données (par ex., données climatiques ou données financières).
      2. Mise en place d’un pipeline Big Data pour traiter et analyser un flux de données en temps réel.

   2. Développement du projet

      1. Mise en œuvre des concepts étudiés.
      2. Suivi et correction.

   3. Présentation des résultats

      1. Rapport technique.
      2. Visualisations et interprétation des résultats.

4. Ressources et Références

   • Coursier
   • scala
   • sbt
   • Environnement de développement Scala : IntelliJ IDEA (Community ou Ultimate Edition) ou Visual Studio Code avec le plugin Metals.
   • Accès à un cluster Spark ou configuration locale avec Hadoop/Spark.
   • Jeux de données réels : Kaggle, UCI Machine Learning Repository, etc.
   • Documentation officielle de Scala, Spark, et bibliothèques associées.

5. Méthodes pédagogiques

   • Cours théorique : concepts clés et exemples pratiques.
   • TP/TD : exercices réguliers pour manipuler Scala et Spark.
   • Projets pratiques : application des connaissances dans des cas concrets.
   • Évaluation : quizz, exercices notés et présentation de projet final.