Scheda di revisione: Introduction à Scala et ses Pipelines Big Data

📋 Plan du Cours

1. Introduction aux pipelines Scala Spark
2. Stack technologique
3. Présentation Spark
4. Principes de Scala
5. Programmation orientée objet Scala
6. Programmation fonctionnelle Scala
7. Typage statique Scala
8. Organisation du cours Scala
9. Variables et types Scala
10. Structures de contrôle Scala
11. Collections Scala

📖 1. Introduction aux pipelines Scala Spark

🔑 Notions clés & Définitions

Pipelines de données : Processus permettant de transformer des données brutes en insights exploitables, en utilisant une succession d’étapes automatisées (source : Low-level Pipelines with Scala and Spark).
Objectifs des pipelines : Construire un flux efficace pour traiter, analyser et exploiter de grands volumes de données, en intégrant des outils comme Spark, Hadoop, ou d’autres systèmes de traitement massivement parallèle (source : Low-level Pipelines with Scala and Spark).
Contexte et enjeux : La gestion du volume de données, la tolérance aux fautes, la gestion des ressources, et l’utilisation de logiciels adaptés (ex. Spark, Hadoop, Flink) pour assurer la performance et la fiabilité des traitements (source : Low-level Pipelines with Scala and Spark).
Vue d’ensemble de la fiche de révision : Présente une introduction aux concepts fondamentaux des pipelines Scala Spark, leur contexte d’utilisation, et les objectifs principaux pour transformer efficacement des données brutes en résultats exploitables dans un environnement big data.

📝 Points essentiels

• Les pipelines de données visent à répondre au défi de transformer des données brutes en insights exploitables, en utilisant des outils adaptés à la gestion de grands volumes (source : Low-level Pipelines with Scala and Spark).
• La technologie Spark offre un cadre complet pour la préparation et l’analyse de big data, avec une API, SQL, ML pipeline, graphes, et connecteurs variés (source : Low-level Pipelines with Scala and Spark).
• La construction d’un pipeline efficace repose sur la gestion du volume, la tolérance aux fautes, la gestion des ressources, et l’utilisation de modèles parallèles comme Map-reduce, BSP (source : Low-level Pipelines with Scala and Spark).
• Scala, en tant que langage, est choisi pour sa compatibilité avec Java, sa concision, son haut niveau d’abstraction, et sa typage statique, facilitant la programmation orientée objet et fonctionnelle dans les pipelines (source : Low-level Pipelines with Scala and Spark).

💡 À retenir

Les pipelines Scala Spark sont des processus automatisés et efficaces pour transformer de grands volumes de données brutes en insights exploitables, en combinant la puissance de Spark avec la flexibilité de Scala.

📖 2. Stack technologique

🔑 Notions clés & Définitions

• Stack technologique : Ensemble des outils, logiciels, systèmes et frameworks utilisés pour concevoir, déployer et gérer une infrastructure de traitement de données massives, permettant la transformation efficace des données brutes en insights exploitables.
• Systèmes et logiciels utilisés dans le traitement de données massives : Ensemble des composants logiciels tels que Hadoop MR, Spark, Flink, Dask pour le calcul, et HDFS, Hbase pour le stockage, qui assurent la gestion, le traitement et l’analyse de volumes importants de données.
• Architecture technologique : Organisation structurée des composants logiciels et matériels (hardware, clusters de machines) permettant la mise en œuvre d’un traitement distribué, tolérant aux fautes, et optimisé pour la scalabilité et la performance.

📝 Points essentiels

• La pile technologique inclut des systèmes de calcul distribués tels que Hadoop MapReduce, Spark, Flink, Dask, qui adoptent des modèles parallèles massifs (ex : Map-Reduce, BSP).
• La gestion des ressources s’appuie sur des clusters de machines de commodité, garantissant la tolérance aux fautes et une gestion efficace des ressources.
• Les systèmes de stockage comme HDFS et Hbase permettent de gérer de gros volumes de données, souvent en mode partagé-nothing.
• La technologie Spark est une plateforme complète pour la préparation de données, l’analyse, le pipeline ML, la gestion de graphes, avec une API accessible via plusieurs langages (Scala, Java, Python, R) et de nombreux connecteurs (NoSQL, BI tools).
• La structure technologique repose sur une architecture distribuée, permettant une exécution parallèle et efficace, adaptée à la volumétrie et à la complexité des données traitées.

💡 À retenir

La stack technologique dans le traitement de données massives combine des systèmes de calcul distribués, des solutions de stockage adaptées, et une architecture distribuée optimisée pour la scalabilité, la tolérance aux fautes et la performance.

📖 3. Présentation Spark

🔑 Notions clés & Définitions

Framework : Ensemble intégré d'outils et de composants permettant le traitement, l’analyse et la gestion de données massives. Dans ce contexte, Spark est présenté comme un framework pour l’analyse de données massives.

API : Interface de programmation permettant aux développeurs d’interagir avec Spark pour réaliser des opérations de traitement de données, de requêtes SQL, ou de machine learning.

SQL : Langage de requête utilisé dans Spark pour manipuler et interroger des données structurées, notamment via l’API SQL de Spark pour CSV, JSON, etc.

ML pipeline : Pipeline de machine learning dans Spark, constitué de plusieurs étapes distribuées pour l’entraînement, la validation et la prédiction à partir de grands volumes de données.

Graphes : Structures de données représentant des relations entre éléments, traitées dans Spark selon le modèle BSP (Bulk Synchronous Parallel).

Connecteurs : Interfaces permettant à Spark de se connecter à diverses sources ou systèmes NoSQL (ex : Couchbase, MongoDB), outils BI (ex : Tableau, Superset), ou autres systèmes de stockage et d’analyse.

📝 Points essentiels

• Spark est un framework complet pour la préparation et l’analyse de big data, avec une API de base, SQL, ML pipeline, et gestion de graphes.
• Il supporte plusieurs langages hôtes : Scala (natif), Java, Python, R.
• Spark utilise une architecture de calcul partagé sans mémoire commune (shared nothing), avec plusieurs modèles comme MapReduce ou BSP.
• Il intègre divers connecteurs pour accéder à des systèmes NoSQL, outils de Business Intelligence, et autres sources de données.
• La plateforme est utilisée en production, notamment pour le traitement de données complexes, la modélisation via ML, et la visualisation.

💡 À retenir

Spark est un framework robuste et flexible pour le traitement distribué de données massives, intégrant API, SQL, ML, graphes et connecteurs pour une analyse complète et efficace.

📖 4. Principes de Scala

🔑 Notions clés & Définitions

Principes de Scala : Scala est un langage évolutif qui combine des paradigmes orienté objet et fonctionnel, tout en étant compatible avec Java. Il est conçu pour être concis, haut niveau, et statiquement typé, permettant une vérification précoce des types et une sécurité accrue lors du développement.

Langage évolutif : Scala permet d’adopter progressivement ses fonctionnalités, facilitant la transition entre paradigmes et la montée en complexité selon les besoins du projet.

Compatible Java : Scala fonctionne sur la machine virtuelle Java (JVM), ce qui lui permet d’interopérer avec le code Java existant et d’utiliser l’écosystème Java.

Conciseness : Scala favorise la production de code compact grâce à des abstractions puissantes, des inférences de types, et une syntaxe expressive.

Haut niveau : Scala offre des abstractions de haut niveau, telles que les fonctions de première classe, la gestion des collections, et les modèles de programmation avancés, pour augmenter la productivité.

Statiquement typé : La vérification des types se fait à la compilation, ce qui permet de détecter précocement les erreurs et d’assurer la sécurité du code.

📝 Points essentiels

• Scala intègre les paradigmes orienté objet et fonctionnel, permettant une programmation mixte.
• La compatibilité avec Java facilite l’intégration dans des environnements existants.
• La concision et le haut niveau de Scala augmentent la productivité tout en maintenant la sécurité grâce au typage statique.
• La vérification des types à la compilation permet d’éviter des erreurs courantes et de simplifier le refactoring.
• Scala est conçu pour une adoption progressive, permettant d’utiliser ses fonctionnalités selon la complexité du projet.

💡 À retenir

Scala est un langage évolutif, concis, et haut niveau, qui combine programmation orientée objet et fonctionnelle, tout en étant compatible avec Java et doté d’un typage statique pour une vérification précoce des erreurs.

📖 5. Programmation orientée objet Scala

🔑 Notions clés & Définitions

Classes : Structures fondamentales pour organiser le code orienté objet, permettant de regrouper attributs et méthodes. Elles servent de modèle pour créer des objets.
Encapsulation : Principe consistant à cacher les attributs et à n’y accéder que via des méthodes, protégeant ainsi l’intégrité des données.
Héritage : Mécanisme permettant à une classe (sous-classe) d’étendre une autre classe (super-classe), en héritant ses attributs et méthodes.
Polymorphisme : Capacité d’utiliser une interface commune pour des objets de différentes classes, permettant d’appeler des méthodes spécifiques à chaque sous-classe via une référence de type parent.
Objets : Instances concrètes de classes, contenant des valeurs pour les attributs et pouvant exécuter des méthodes définies dans leur classe.

📝 Points essentiels

• La programmation orientée objet en Scala repose principalement sur la définition de classes, qui encapsulent données (attributs) et comportements (méthodes).
• L’encapsulation est assurée par la visibilité des attributs et méthodes, souvent en utilisant des modificateurs d’accès (privé, protégé, public).
• L’héritage permet la réutilisation du code en créant des sous-classes qui étendent des classes existantes, facilitant la généralisation et la spécialisation.
• Le polymorphisme est rendu possible par l’utilisation de classes abstraites, de classes cas (case classes), et de classes scellées (sealed classes), permettant un traitement uniforme d’objets de types différents.
• Chaque objet est une instance d’une classe, créée via le mot-clé new, et possède ses propres valeurs pour les attributs définis dans la classe.

💡 À retenir

La programmation orientée objet en Scala s’appuie sur la définition de classes pour structurer le code, en utilisant l’encapsulation, l’héritage et le polymorphisme pour favoriser la réutilisation, la modularité et la flexibilité des applications.

📖 6. Programmation fonctionnelle Scala

🔑 Notions clés & Définitions

Programmation fonctionnelle Scala : Approche de programmation qui privilégie l'utilisation de fonctions comme valeurs, l'immutabilité et les opérations sans effets de bord, permettant un code plus sûr, modulaire et scalable (source : Mohamed-Amine Baazizi).

Fonctions comme valeurs : Principe selon lequel les fonctions sont traitées comme des objets de première classe, pouvant être passées en argument, retournées par une autre fonction, ou stockées dans des variables (source : Baazizi).

Immutabilité : Caractère des structures de données ou variables qui ne peuvent pas être modifiées après leur création. Par défaut, Scala favorise l'utilisation de structures immuables, ce qui facilite la vérification et la prévisibilité du code (source : Baazizi).

Opérations sans effets de bord : Fonctions qui, lorsqu'elles sont exécutées, ne modifient pas l'état global ou les données extérieures, permettant une meilleure composition et testabilité du code (source : Baazizi).

📝 Points essentiels

• Scala combine styles orienté objet et fonctionnel, mais la programmation fonctionnelle insiste sur l'utilisation de fonctions comme valeurs, l'immutabilité et l'absence d'effets de bord.
• La majorité des structures de données en Scala sont immuables par défaut, comme List, Map, Set, ce qui facilite la vérification statique et la sécurité du code.
• Les fonctions peuvent être passées comme arguments, retournées, et utilisées pour transformer des collections via des opérations comme map, filter, reduce, fold, favorisant un style déclaratif.
• La gestion de l'état mutable est possible mais doit être explicitement utilisée, en privilégiant l'immutabilité pour garantir la fiabilité et la simplicité du traitement.
• La programmation fonctionnelle permet de construire des pipelines de traitement de données efficaces, notamment dans le contexte de traitement massif avec Spark.

💡 À retenir

La programmation fonctionnelle en Scala repose sur l'utilisation de fonctions comme valeurs, l'immutabilité des structures, et l'absence d'effets de bord, ce qui facilite la création de code sûr, modulaire et scalable.

📖 7. Typage statique Scala

🔑 Notions clés & Définitions

• Typage statique : Vérification des types à la compilation, permettant de s'assurer que les variables, fonctions et expressions respectent les types déclarés ou inférés avant l'exécution (source).
• Annotations : Déclarations explicites de types lors de la déclaration d'une variable ou d'une fonction, permettant de préciser le type attendu (source).
• Inférence de types : Capacité du compilateur Scala à déduire le type d'une variable ou d'une expression sans déclaration explicite, lorsque cela est possible, notamment pour simplifier le code (source).

📝 Points essentiels

• Scala vérifie les types des variables, fonctions et expressions au moment de la compilation, ce qui permet de détecter précocement les erreurs de type (source).
• La déclaration explicite d'un type se fait via une annotation lors de la déclaration (ex : val name: String = "Alice"), mais Scala peut aussi inférer le type si aucune annotation n'est fournie (source).
• L'inférence de types est limitée notamment dans le cas de fonctions récursives, où le compilateur ne peut pas toujours déduire le type automatiquement (source).
• La vérification statique favorise la sécurité, la lisibilité et facilite le refactoring du code (source).

💡 À retenir

Le typage statique en Scala assure la sécurité du code en vérifiant les types à la compilation, tout en offrant une flexibilité grâce à l'inférence de types, ce qui permet d'écrire un code concis et sûr.

📖 8. Organisation du cours Scala

🔑 Notions clés & Définitions

• Organisation du cours Scala : Structure pédagogique combinant théorie et pratique, visant à familiariser les étudiants avec les concepts fondamentaux et l'application de Scala dans un contexte de traitement de données massives (source : Aivancity Fall 2025 Mohamed-Amine Baazizi). Elle inclut une alternance entre enseignements théoriques, exercices pratiques en notebook, et évaluations (article, examen).

• Structure du cours : Séquencement des modules comprenant l’introduction à Scala, la programmation en style fonctionnel et orienté objet, la gestion des variables, types, collections, et la mise en pratique via des applications concrètes (ex : parsing CSV/JSON, traitement avec Spark). Elle est conçue pour favoriser l’apprentissage progressif et l’intégration des concepts.

• Alternance de théorie et pratique : Méthodologie pédagogique combinant des exposés théoriques pour comprendre les principes, suivis d’exercices pratiques en notebook pour appliquer ces concepts, notamment en utilisant Scala 2 ou 3, dans le but de préparer à l’utilisation de Spark et au traitement de données (source : outline du cours).

• Évaluation : Modalités d’évaluation comprenant la présentation d’articles lors de la journée 4, ainsi qu’un examen final. Elle permet de mesurer la compréhension théorique et la capacité à appliquer les concepts appris dans des situations concrètes (source : outline du cours).

📝 Points essentiels

• La structure du cours est conçue pour mêler théorie et pratique, avec une progression pédagogique claire, de l’introduction aux variables et types, jusqu’aux collections, classes, et programmation avancée (source : outline du cours).

• La méthodologie privilégie l’interaction en mode notebook, favorisant l’expérimentation immédiate, la réflexion et l’apprentissage actif. La pratique est essentielle pour maîtriser la syntaxe, les collections, et les principes de programmation Scala (source : organisation du cours).

• La évaluation par présentation d’articles et examen final vise à vérifier la compréhension globale et l’aptitude à appliquer les concepts dans des projets concrets, notamment en lien avec Spark et le traitement de données massives (source : outline du cours).

💡 À retenir

L’organisation du cours Scala repose sur une alternance structurée entre théorie et pratique, permettant aux étudiants d’acquérir des compétences concrètes tout en maîtrisant les principes fondamentaux du langage dans un contexte de traitement de données.

📖 9. Variables et types Scala

🔑 Notions clés & Définitions

Variables : Espaces de stockage pour des données, permettant de conserver et de manipuler des valeurs durant l'exécution du programme.
Val : Mot-clé Scala pour déclarer une variable immuable, initialisée une seule fois, ne peut pas être réaffectée. (AIVANCITY, 2025) : "val" est utilisé pour une déclaration immuable, style fonctionnel.
Var : Mot-clé Scala pour déclarer une variable mutable, pouvant être réassignée plusieurs fois. (AIVANCITY, 2025) : "var" permet une modification ultérieure de la valeur.
Types primitifs : Types de base tels que Int, Double, Boolean, Char, etc., utilisés pour définir la nature des valeurs stockées. (AIVANCITY, 2025) : Types primitifs assurent la vérification statique des données.
Déclaration : Processus de création d’une variable ou d’un objet en spécifiant son nom, son type (optionnel) et sa valeur initiale. (AIVANCITY, 2025) : La déclaration peut se faire avec ou sans annotation de type, grâce à l'inférence de type.
Utilisation : Action de manipuler ou d’accéder à une variable ou un type dans le code, en respectant leur mutabilité ou immutabilité. (AIVANCITY, 2025) : La bonne utilisation privilégie "val" par défaut, sauf nécessité de "var".

📝 Points essentiels

• Val est recommandé par défaut pour garantir l’immutabilité, favorisant un style fonctionnel.
• Var doit être utilisé uniquement lorsque la mutation de la valeur est indispensable, notamment dans des scopes locaux.
• La déclaration sans type explicite repose sur l’inférence de type, mais il est conseillé de préciser le type pour plus de clarté ou lors de la récursion.
• Types primitifs comme Int, Double, etc., sont vérifiés à la compilation, assurant la sécurité du typage statique.
• La déclaration de variables en Scala se fait en utilisant "val" ou "var", suivie du nom, éventuellement du type, puis de l’assignation.

💡 À retenir

En Scala, privilégier "val" pour déclarer des variables immuables afin d’adopter un style de programmation sûr et fonctionnel, tout en utilisant "var" uniquement lorsque la mutation est nécessaire.

📖 10. Structures de contrôle Scala

🔑 Notions clés & Définitions

Structures de contrôle : mécanismes permettant de gérer le flux d'exécution d'un programme, notamment via des conditions, des choix multiples, ou des répétitions.

if : structure conditionnelle permettant d'exécuter un bloc de code si une condition est vraie, et éventuellement un autre si elle est fausse.
Point essentiel : possibilité de chaîner des conditions avec des if imbriqués ou des if-else if-else.

match : structure de sélection permettant de faire une correspondance entre une valeur et plusieurs cas possibles, similaire à un switch-case dans d’autres langages.
Point essentiel : utilisation de pattern matching pour gérer différentes formes ou valeurs d’une expression.

boucles : mécanismes pour répéter un bloc de code plusieurs fois.

• while : répète tant qu’une condition est vraie.
• do-while : répète au moins une fois, puis tant que la condition est vraie.
• for : itère sur une plage ou une collection, souvent en utilisant des générateurs ou des ranges.

gestion du flux de programme : ensemble des instructions permettant de contrôler l’ordre d’exécution, incluant conditionnels, boucles, et autres structures de contrôle.

📝 Points essentiels

• if permet d’exécuter conditionnellement un bloc de code, avec possibilité de chaîner plusieurs conditions via else if et else.

• match offre une alternative expressive au if-else pour la sélection multiple, utilisant le pattern matching.

• boucles :

  • while : répète tant que la condition est vraie, attention aux boucles infinies si la variable de contrôle n’est pas modifiée.
  • do-while : garantit une exécution initiale, puis répète selon la condition.
  • for : itère sur des ranges ou collections, souvent avec une syntaxe compacte, évitant les erreurs d’incrémentation manuelle.

• La gestion du flux inclut aussi l’utilisation de break ou continue, mais ces concepts ne sont pas explicitement mentionnés dans la source.

• La syntaxe de match permet une correspondance claire avec des cas précis, facilitant la gestion de structures complexes ou de pattern matching.

💡 À retenir

Les structures de contrôle Scala, telles que if, match, et les boucles, permettent de gérer efficacement le flux d’exécution du programme en combinant conditions, choix multiples et répétitions, tout en favorisant une syntaxe claire et expressive.

📖 11. Collections Scala

🔑 Notions clés & Définitions

• Collections Scala : ensembles de données organisés permettant leur manipulation et transformation, avec des opérations expressives et typées. (source : contexte général)
• List : collection ordonnée, chaînée, adaptée à une utilisation en style fonctionnel, permettant la manipulation via des opérations comme map, filter, reduce. (source : manipulation et transformations)
• Array : collection de taille fixe, dont les éléments sont accessibles par leur index, mutable, supporte transformations et pattern matching. (source : manipulation et transformations)
• Set : collection non ordonnée, sans doublons, permettant l’ajout, la suppression, et la vérification d’existence d’éléments, mutable ou immuable. (source : manipulation et transformations)
• Map : collection de paires clé-valeur, permettant la recherche, l’ajout, la suppression, et la fusion de données, avec des clés uniques. (source : manipulation et transformations)
• Tuples : valeurs hétérogènes de taille fixe, accessibles par leur position, utilisées pour manipuler des valeurs complexes ou structurées. (source : manipulation et transformations)
• Manipulation : opérations sur collections, telles que ajout, suppression, transformation, concaténation, conversion, souvent via des méthodes de haut niveau (map, filter, reduce, fold). (source : manipulation)
• Transformations : modifications ou créations de nouvelles collections à partir d’anciennes, en utilisant des opérations fonctionnelles ou mutables, pour adapter ou analyser les données. (source : transformations)

📝 Points essentiels

• Les collections Scala se divisent en deux catégories principales : mutable (modifiable) et immutable (non modifiable, par défaut). (source : manipulation)
• List : adaptée au traitement fonctionnel, avec opérations comme map, filter, reduce, fold, et pattern matching pour la décomposition. (source : manipulation, transformations)
• Array : collection à taille fixe, accessible par index, supporte en place des opérations comme arr(0)=11 ou ++ pour concaténer. (source : manipulation, transformations)
• Set : élimine automatiquement les doublons, avec opérations d’union (++), intersection (&), différence (--). (source : manipulation)
• Map : permet de gérer des associations clé-valeur, avec opérations d’ajout (+), suppression (-), fusion (++), et recherche (get, getOrElse). (source : manipulation)
• Tuples : permettent de regrouper plusieurs valeurs de types différents, avec accès par position (._1, ._2) ou déconstruction. (source : manipulation)
• Les opérations sur collections utilisent souvent des méthodes de haut niveau, favorisant un style fonctionnel, notamment map, filter, reduce, fold, et pattern matching. (source : transformations)
• La conversion entre collections (ex : toList, toArray, toSet, toMap) facilite la compatibilité et la manipulation spécifique. (source : manipulation)

💡 À retenir

Les collections Scala, qu’elles soient immuables ou mutables, offrent un large éventail d’opérations pour manipuler, transformer et analyser efficacement des ensembles de données structurées ou hétérogènes, en privilégiant souvent un style fonctionnel.

📊 Tableaux de Synthèse

Aspect	Scala	Java	Auteur / Source
Paradigmes	Orienté objet et fonctionnel	Orienté objet	Low-level Pipelines with Scala and Spark
Typage	Statique, vérifié à la compilation	Statique, vérifié à la compilation	Low-level Pipelines with Scala and Spark
Syntaxe	Concise, expressive	Verbose	Low-level Pipelines with Scala and Spark
Interopérabilité	Compatible avec Java	N/A	Low-level Pipelines with Scala and Spark
Abstractions	Fonctions de première classe, collections avancées	Classes, interfaces	Low-level Pipelines with Scala and Spark

⚠️ Pièges & Confusions Fréquentes

1. Confondre la programmation orientée objet et fonctionnelle dans Scala, qui sont toutes deux intégrées mais doivent être utilisées à bon escient.
2. Sous-estimer l’importance du typage statique, qui permet de détecter précocement les erreurs.
3. Confondre la syntaxe concise de Scala avec une syntaxe simplifiée, alors qu’elle repose sur des abstractions puissantes.
4. Oublier que Scala fonctionne sur la JVM, facilitant l’interopérabilité avec Java, mais nécessitant une gestion attentive des dépendances.
5. Confusion entre les paradigmes de programmation, notamment lors de l’utilisation de fonctions de première classe.
6. Négliger l’impact de la compatibilité avec Java sur la conception des API et des bibliothèques.
7. Se méfier des faux-amis entre Scala et d’autres langages fonctionnels ou OO.

✅ Checklist Examen

1. Connaître la définition de pipelines de données selon Low-level Pipelines with Scala and Spark.
2. Expliquer le rôle de Spark dans la stack technologique, notamment ses API, SQL, ML pipeline, et connecteurs.
3. Identifier les principaux composants de la stack technologique : Hadoop MR, Spark, Flink, HDFS, Hbase.
4. Définir un framework et ses fonctions dans le contexte de Spark.
5. Maîtriser les modèles de calcul distribués utilisés par Spark : MapReduce, BSP.
6. Connaître les sources de données connectées à Spark via ses connecteurs (ex : NoSQL, BI tools).
7. Comprendre les principes fondamentaux de Scala : paradigmes, compatibilité Java, syntaxe concise, typage statique.
8. Savoir que Scala combine programmation orientée objet et fonctionnelle.
9. Identifier les avantages de la compatibilité avec Java pour l’interopérabilité.
10. Connaître les abstractions clés de Scala : fonctions de première classe, collections avancées.
11. Être capable d’expliquer la différence entre programmation orientée objet et fonctionnelle dans Scala.
12. Vérifier la maîtrise des notions de typage statique et de vérification à la compilation.