Vous souhaiter apprendre un langage de programmation ? Vous souhaitez vous orienter dans un métier qui requiert la maîtrise d’un langage fonctionnel comme les métiers du Big Data ? Alors en choisissant Scala, vous avez fait le bon choix !

Dans les métiers de la data ou de la programmation, apprendre le langage Scala est devenu obligatoire. Dans ce tutoriel, vous allez apprendre à programmer en Scala. Plus concrètement, nous allons vous apprendre les structures de base qui permettent d’écrire des programmes informatiques en Scala, et à la fin du tutoriel, vous pourrez télécharger un tutoriel vidéo d’une heure pour pratiquer Scala sur votre PC. Allons-y ! Commençons par les bases.

Qu’est ce que le langage Scala et à quoi sert-il ?

Scala est un langage fonctionnel, créé par Martin Odersky qui a connu une croissance spectaculaire ces dernières années, au point de devnir un standard dans de nombreuses entreprises Comme Twitter ou BBVA, mais également dans de nombreuses startups et universités du monde entier. Il a été conçu à l’École polytechnique fédérale de Lausanne (EPFL) pour exprimer les modèles de programmation courants dans une forme concise et élégante.

Scala est très plébiscité dans de nombreux domaines, spécialement le développement d’applications Big Data. Les développeurs, les data engineers et les entreprises l’utilisent pour le traitement de données sur des frameworks tels que Apache Spark. Les développeurs web vont l’utiliser pour le développement d’applications sur le framework Play.

Ces technologies (Spark et Play), en plus d’être des projets à fort impact sur le marché, ont été intentionnellement construits à partir du langage Scala.

La particularité majeure de Scala réside sans aucun doute sur le fait qu’il est exécuté sur la machine virtuelle Java, permettant ainsi une union des deux langages.

En effet, vous pouvez programmer en Java et Scala en même temps ! Qu’est ce que cela veut dire ? Cela signifie que vous pouvez utiliser les bibliothèques de classes de Java dans Scala, et à la fin compiler votre code scala en bytecode qui s’exécutera sur une machine virtuelle. Le code exécuté .scala, produit un fichier .class , qui lorsque compilé, génère un fichier .class, qui est exécuté dans une JVM, une machine virtuelle Java.

Ainsi, lorsqu’on parle de Scala, on parle avant tout d’un langage de programmation “polyglotte”.

De plus, scala combine les propriétés des langages orientés objet avec celles des langages fonctionnels. Par exemple, des fonctions peuvent être définies au sein d’autre fonctions ou au sein d’objets appartenant à n’importe quelle classe. Nous allons y revenir un peu plus bas dans le tutoriel…

Ces caractéristiques uniques de Scala vous donnent la possibilité de programmer une multitude de cas d’usage différents, tels que l’analyse de données, le développement web, le développement streaming, ou encore le développement d’applications Big Data.

Pourquoi devez-vous apprendre à programmer en Scala ?

Quelles sont les principales raisons pour lesquelles il est essentiel à notre époque d’apprendre à programmer en Scala ? Nous allons vous donner la réponse à cette question ici.

En effet, il peut y avoir de nombreuses raisons d’apprendre le langage Scala. Comme le fait d’y être obligé parce qu’il est utilisé dans la nouvelle entreprise qui vous a embauché…

Cependant, pour tous les développeurs, spécialement les corps de métiers du Big Data, Scala est devenue l’une des alternatives Java les plus puissantes ces derniers temps. C’est le langage de choix pour ses nombreux points forts :

Scala est un langage fonctionnel

Scala est à la base un langage fonctionnel. A titre de rappel, le style fonctionnel de programmation repose sur 2 éléments principaux : les fonctions et l’immutabilité.

Dans un programme fonctionnel, tous les composants sont considérés comme des fonctions et le code est exécuté par des appels successifs de fonctions. Par exemple :

val ssession = SparkSession.builder.config(rdd_kafka.sparkContext.getConf).enableHiveSupport().getOrCreate()

Le code que vous voyez ci-dessous est en fait la déclaration d’un objet en Scala, qui exécute en une opération 2 fonctions : la fonction getOrCreate() et la fonction enableHiveSupport(). C’est ça le style de programmation fonctionnelle !

Ce style d’écriture fait naître une caractéristique importante chez scala : le Lazy computation. En effet, les calculs sont “paresseux” par défaut avec Scala. Cela signifie que Scala exécute les expressions uniquement lorsqu’elles sont nécessaires. Cela améliore grandement les performances de l’application. Du coup, dans mon exemple précédent, le code n’est compilé que s’il est réellement appelé à un moment ou un autre du programme. On n’est pas comme dans d’autres langages comme Java où chaque fois, tout le code est exécuté, même lorsqu’on avait voulu exécuté seulement une partie précise du programme.

Le principe d’immutabilité est une autre caractéristique propre au paradigme de programmation fonctionnelle. Dans le monde des bases de données et l’exécution concurrente, les systèmes qui s’appuient sur le principe de la mutabilité ont le défaut de ne pas être tolérant aux pannes. Cela signifie que lorsqu’un système est basé sur le principe de mutabilité, les changements d’état (ou de données) à un moment donné sont irréversibles ! En cas d’erreur, on ne peut plus revenir en arrière. La mutabilité pose de sérieux problèmes dans toutes les problématiques où les données sont utilisées de façon concurrente, notamment les problématiques de base de données.

L’immutabilité résout ce problème et permet de conserver les valeurs de chaque état à tout instant de la progression du programme. Cela garantit qu’à chaque instant, on peut retracer la valeur précédente d’un état avant la modification par un autre processus. Celà est extrêmement utile dans les calculs distribués, les bases de données, l’exécution concurrente de processus.

Grâce à l’immutabilité native de Scala, les programmes peuvent être distribués entre les cœurs d’un serveur multi cœur et les serveurs d’un centre de données. L’immutabilité permet de tirer parti des architectures de processeurs multi cœurs d’une façon générale. C’est pourquoi Scala est le langage de choix pour toutes les problématiques du Big Data et du Cloud, dans lesquelles il faut traiter de façon massivement distribuée les données.

Ainsi, si vous souhaitez vous orienter vers les métiers du Big Data, l’apprentissage du langage Scala est indispensable !!

En Scala, l’immutabilité est automatiquement intégrée au langage et pour l’utiliser, il suffit simplement de déclarer des variables grâce au mot-clé “val”. Par exemple :

Val test : Int = 15 
test = test + 2  ===> renvoie une erreur 

Pour corriger l'erreur, faut créer une 2ème variable immutable 
val test2 = test + 2 

Scala est un langage orienté-objet

Comme Java, Scala est un langage orienté objet. Les développeurs venant de Java et d’autres langages orientés objet peuvent donc facilement appliquer des modèles de conception similaires avec Scala.

De plus, en scala il est facile de tirer parti de fonctionnalités orientées objet puissantes telles que les traits et la composition à base de mixin. Regardons ces deux fonctionnalités de plus près :

Les traits scala

En programmation orienté-objet, les traits sont des composants réutilisables qui peuvent être utilisés pour étendre le comportement d’une classe (entendez “ses méthodes”). Ils sont très similaires au concept d’interface et contiennent à la fois des méthodes/propriétés concrètes et abstraites. A titre de rappel, une méthode abstraite, est une méthode d’une classe abstraite (ou d’une interface) et une classe abstraite est une classe qui ne peut être utilisée. Pour l’utiliser, il faut créer une classe qui hérite d’elle.

Pour créer un trait en scala, il suffit d’indiquer le mot-clé Trait, et son identifiant. Exemple :

trait HairColor

Les traits deviennent particulièrement utiles en tant que types génériques et avec des méthodes abstraites. Exemple

trait Iterator[A] {
  def hasNext: Boolean
  def next(): A
}

L’extension de trait Iterator[A]nécessite un type Aet des implémentations des méthodes hasNextet next.

Les mixins en scala

Les mixins sont des traits utilisés pour composer une classe. Exemple :

abstract class A { 
  val message: String 
} 

class B extends A { 
  val message = "Je suis une instance de la classe B qui hérite de la classe abstraite A" 
} 

trait C extends A { 
  def loudMessage = message.toUpperCase() 
} 

class D extends B with C 
val d = new D 
println(d.message) // Je suis une instance de la classe B
println(d.loudMessage) // Je suis une instance de la classe B

La classe Da une superclasse Bet un mixin C. Les classes ne peuvent avoir qu’une seule superclasse mais plusieurs mixins. Pour cela, on utilise les mots extends– clés et with respectivement. Les mixins et la superclasse peuvent toutefois avoir le même super type.

Typage statique

Une autre caractéristique très intéressante de scala pour les développeurs c’est le typage statique (encore appelé vulgairement typage fort). Scala est équipé d’un système de typage qui force statiquement les abstractions à être utilisées de manière cohérente et sûre. Ce typage détecte et empêche de nombreux types d’erreurs d’application lors de la compilation. 

En même temps, il dispose d’un système d’inférence de type sophistiqué qui permet aux développeurs de ne pas avoir à écrire des informations de frappe redondantes dans le programme. Par exemple, les 2 expressions suivantes sont autorisées en même temps dans scala.

//typage fort, où on indique le type de la variable avant la compilation
val ssession : SparkSession = SparkSession.builder.config(rdd_kafka.sparkContext.getConf).enableHiveSupport().getOrCreate()

//typage faible, où scala infère le type de la variable à la compilation
val ssession  = SparkSession.builder.config(rdd_kafka.sparkContext.getConf).enableHiveSupport().getOrCreate()

les Case Class

En dehors des traits, scala apporte une structure particulière aux développeurs, qui enrichit ses fonctionnalités orientées-objet : il s’agit de la structure case class. La structure Case Class est un type particulier de classe qui est propre à scala, qui permet de modéliser l’immutabilité, et donc de forcer le typage des données. Dans le Case Class on n’a pas de méthodes, juste des propriétés et on ne peut pas l’utiliser pour étendre par héritage une autre classe. C’est celà qui la différencie principalement d’une classe normale.

case class Flight(DEST_COUNTRY_NAME: String,
                  ORIGIN_COUNTRY_NAME: String,
                  count: BigInt)
val flightDF : Flight = new Flight ("cameroun", "Dubai", 10) 

langage extensible

Le langage Scala contient aussi une combinaison unique de mécanismes de langage, ce qui facilite l’ajout de nouvelles constructions de langage sous forme de bibliothèque ou la création de DSL.

Langage productif

Grâce à son système d’inférence de type et à d’autres fonctionnalités, scala est un langage concis. Il donne aux développeurs la possibilité de réduire la taille du code source d’un facteur 2 ou 3 par rapport à Java. Scala est de loin moins verbeux que Java. Regardez ce code en Java :

List<Integer> even = new ArrayList<Integer>();
for (String num : numbersAsStrings) {
 int parsedInt = Integer.parseInt(num);
 if (parsedInt % 2 == 0) {
  ints.add(parsedInt);
 }
} 

En scala, le même code s’écrit en une ligne :

val ints = for (num <- numbersAsStrings; if num.toInt % 2 == 0) yield num.toInt 

// ou bien : 
val ints = numbersAsStrings map { _.toInt } filter {_ % 2 == 0}

Le Scala apporte ainsi avec lui un riche ensemble d’outils de développement qui, pour vous donner une idée, se traduisent par une productivité similaire à celle de langages comme Ruby ou Python. 

Scala vous permet également de définir des types associés à la fois aux

  • attributs de données – avec des classes se comportant comme des classes C ++ / Java
  • attributs de comportement – avec des traits correspondant aux interfaces Java

Tout comme dans d’autres langages de programmation fonctionnels, dans Scala, les fonctions peuvent être transmises en tant que valeurs. Scala prend également en charge les fonctions anonymes et le currying – application partielle de fonctions multi-arguments.

Ainsi, cette combinaison de fonctionnalités permet d’écrire des programmes Scala assez concis et élégants.

Interopérabilité du langage Scala avec Java

Le Scala est compilé directement en bytecode Java, s’exécutant sur la machine virtuelle Java. Il tire parti de la puissance et de la maturité de la JVM, et de techniques de déploiement bien comprises. En profitant de cela, il n’y a pratiquement aucun impact sur l’avancement du projet. 

Les développeurs ne verront pas la différence et continueront à travailler avec leurs outils. En effet, ils peuvent utiliser les bibliothèques Java directement à partir du code Scala. Également, les codes seront plus courts, plus rapides, plus évolutifs, plus corrects… Et peut-être même, plus amusant !

Le langage scala est un langage open-source

Le langage Scala est open source et disponible sous la licence BSD-Style Scala. Il est donc libre de droit et vous pouvez l’utiliser gratuitement aussi bien pour vos projets personnels que dans des projets commerciaux.

Scala offre énormément d’opportunités professionnnelles dans le Big Data

Comme nous vous l’avons mentionné précédemment, scala est très adéquat pour les problématiques d’accès concurrente à des états (données), notamment les problématiques de base de données. Cela fait de lui, le langage privilégié en Big Data. D’ailleurs, la plateforme de calcul massivement parallèle Apache Spark, et la plateforme de Big Data Streaming Akka ont été conçu avec Scala.

Les employeurs dans le monde de la data (spécialement pour les postes d’ingénieur Big Data) accordent donc une importance critique à la maîtrise de scala, et selon les estimations de Job-boards, le salaire des développeurs maîtrisant scala dans le Big Data peut allègrement dépasser les 60 000 euros/an ! Alors donnez-vous les moyens d’avoir une belle carrière dans le Big Data en apprenant Scala ! 

Scala est un langage “polyglotte”

Polyglotte signifie “plusieurs”. Scala est un langage polyglotte sur plusieurs points :

  • Scala est un langage à plusieurs paradigmes : le paradigme orienté-objet et le paradigme fonctionnel. Cela augmente les cas d’usage pour lesquels il peut être utilisé sans le rendre plus difficile à utiliser.
  • scala est un langage doté d’une dualité Java/Scala : grâce à cette dualité, il est possible d’utiliser les bibliothèques natives de Java sans aucun problème dans vos programmes scala, et de les déployer dans des JVM. Les 2 langages sont inter-opéables. Vous bénéficiez donc en scala de toute la puissance de Java lorsque nécessaire.

Scala en front-end des applications Web

Scala possède une version orientée pour le développement des applications web en front-end, au même titre que le javascript. Cette version c’est le Scala.js, un compilateur qui cible JavaScript, contrairement au compilateur Scala traditionnel qui cible le bytecode JVM. 

Cela signifie qu’en pratique avec la bibliothèque Scala.js, vous pouvez écrire du code Scala qui sera exécuté en front de l’application web au niveau du navigateur.

Scala.js utilise le moteur Javascript pour convertir le code Scala.  Ainsi le langage de programmation Scala peut être exécuté avec le runtime Javascript plutôt que sur la machine virtuelle Java. Et exécuté dans le navigateur Web. Également, Scala.js va dans l’autre sens. Et prend un langage backend, puis, le compile en JavaScript exécutable.

Donc, avec Scala.js, vous pouvez utiliser toutes les astuces Scala que vous avez apprises en backend pour créer des applications Web !

Les bases de la programmation en scala

Maintenant que vous avez compris l’origine de scala, son intérêt dans le monde professionnel, et les caractéristiques qui le rendent si attractif, il est temps d’entrer dans la programmation en scala proprement dite. Les parties précédentes étaient là pour planter le décor.

Fondamentalement, un programme Scala décrit l’interaction entre les objets qui échangent les messages. Par exemple, des éléments tels que les nombres, les caractères et les chaînes, etc. sont des objets qui peuvent interagir avec d’autres objets ou des types d’objets similaires.  Cela signifie que lorsque vous écrivez vos programmes scala, vous commencez à partir d’une classe ou un singleton, et à l’intérieur de celle-ci, vous faites appel aux autres composants de la programmation classique (variables, procédures, fonctions) ou de la programmation orientée-objet (classes, traits, objets, structures de données, etc.).

Voici comment s’écrit le mythique “Hello World” en scala pour démarrer l’apprentissage du langage :

object HelloWorld {
  def main(args: Array[String]): Unit = {
    println("Hello, world!")
  }
}

Les variables et les types de base en Scala 

L’élément de base dans tout programme informatique, quelque soit son langage c’est la variable. Scala en dispose de 2 types : les variables dont la valeur peut changer (variables mutables) et les variables dont la valeur ne peut changer (les variables immutables).

Notez quel’une ou l’autre de ces 2 types de variables peut prendre ses valeurs dans les types suivants :

  • Byte : un octet
  • Int : un entier naturel
  • String : une chaîne de caractère
  • Boolean : une valeur booléenne
  • Any : le fourre-tout de scala

Les variables immutables sont déclarées grâce au mot-clé “val” et ne peuvent pas être changées. Syntaxe : Val mavariable_immutable : type = valeur 

//variable immutable en scala
Val test : Int = 15 
test = test + 2  ===> renvoie une erreur 

Pour corriger l'erreur, faut créer une 2ème variable immutable 
val test2 = test + 2 

Les variables mutables quant à elles sont déclarées grâce au mot-clé “var” et peuvent changer d’état à tout moment dans la progression du programme. Syntaxe : Var mavariable_mutable : type = valeur 

Var test = 15 
test = test + 2  ===> renvoie 17

Les Structures de données du langage Scala

Scala est justement plébiscité dans le calcul distribué, les problématiques d’accès concurrent à des états, le Cloud et le Big Data en raison de ses structures de données adéquates. Il possède une riche bibliothèque pour la collecte de données.

Les collections Scala distinguent systématiquement les collections mutables et les collections immutables. Une collection mutable peut être mise à jour ou étendue sur place. Cela signifie que vous pouvez modifier, ajouter ou supprimer des éléments d’une collection. Les collections immutables, par contre, ne changent jamais ! Vous avez toujours des opérations qui simulent des ajouts, des suppressions ou des mises à jour, mais ces opérations renverront dans chaque cas une nouvelle collection et laisseront l’ancienne collection inchangée.

Toutes les structures de données de scala se trouvent dans les bibliothèques de classes de collectionsuivantes :

La collection immutable est par défaut chargée et il faut importer la collection mutable avant de pouvoir l’utiliser. Les collections les plus utilisées sont :

  • les listes,
  • les tuples,
  • les Maps,
  • les sets
  • et les “tableaux”

Découvrons cela dans le détail…

Les listes scala

La liste Scala est une séquence immuable d’éléments ordonnée.  C’est une collection immutable et ordonée de données de même type. Contrairement à un tableau, une liste est une collection immutable. Les listes prennent en charge uniquement l’ajout efficace de nouveaux éléments à l’avant.

Une liste se crée en scala à l’aide du mot-clé List.  

val list2 : List[Int] = List(1,8,5,6,9,58,23,15,4)  
val names = List("joel", "ed", "chris", "maurice")
val nums = List.range(0, 10)

for (name <- names) : {
  println(name)
}  

Les fonctions anonymes sont très importantes pour manipuler les listes. 

val resultat2 = names.count( s => s.startsWith("b"))
val liste2 = names.filter(s => s.startsWith("b"))

val ints = List(1,2,3)
val doubledInts = ints.map(_ * 2)
val doubledInts = ints.map(_ * 2)

val doubledInts = ints.map((i: Int) => i * 2)
val doubledInts = ints.map(i => i * 2)

val x = ints.filter(_ > 5)
val x = ints.filter((i: Int) => i % 2 == 0)

A défaut d’utiliser les fonctions anonymes pour parcourir les listes, vous pouvez aussi utiliser l’itérateur foreach. 

names.foreach(println) 
// ou bien 
names.foreach{ 
  e => println(e)
}
names.filter(s => s.startsWith("b")).foreach(println) 

Vous pouvez aussi utiliser la fonction map, sauf que celle-ci est utilisée pour appliquer un calcul spécifique à tous les éléments de la liste (ou de la collection) à la fois.

//créer une liste dont les éléments sont les éléments de la première liste mais en majuscule. 
val capNames = names.map(_.capitalize)

// créer une liste dont les éléments sont les éléments inférieur à 5 de la liste 2
val lessThanFive = liste2.map(_ < 5)

// créer une deuxième liste dont les éléments sont égaux aux éléments de la liste 2 multiplié par 2. 
val doubles = liste2.map(_ * 2)

Attention !! en scala il y’a deux méthodes qui permettent d’appliquer des calculs à une collection : la fonction map() et la fonction flatmap().

La méthode map() transforme une collection en appliquant une fonction à chaque élément de cette collection. La méthode flatmap() quant à elle bien que très similaire à la méthode map(), va effectuer une agrégation interne des éléments de la collection. La méthode flatMap agit comme un raccourci du map() et va immédiatement “aplatir” la collection de données.

val rdd = List("ceci est un test des deux fonctions") 

// ici rdd1 produit 7 colonnes, soit une colonne par élément
val rdd1 = rdd.map(l => l.split(" "))

//tandis que ici, rdd3 est automatiquement aplati et on obtient une structure de données à 7 lignes, une colonne. 
val rdd3 = rdd.flatMap( l => l.split(" "))

Les Tuples scala

Collection immutable de données hétérogènes, les tuples sont des ensembles ordonnés de valeurs. Ce sont des enregistrements immuables qui peuvent être référencés par leur position.  

A la différence d’un type ou d’un tableau dont les éléments sont tous du même type, un tuple est une collection scala qui contient un nombre fixe d’éléments, chacun avec son propre type. Les types dans un tuple scala peuvent être différents.

Ainsi, les tuples sont particulièrement pratiques pour renvoyer plusieurs valeurs à partir d’une méthode.

Un tuple avec deux éléments peut être créé comme suit :

val ingredient = ("Sugar" , 25)
Val nom_tuple_1 = ("jvc", 40, True)

nom_tuple_1  renvoie “jvc” (la référence dans les tuples commence à 1, et non 0 comme dans les tableaux et listes).

class Person(var name: String)
val t = (11, "Eleven", new Person("Eleven"))
println(t._1, t._2)

Notez qu’on peut facilement convertir des tuples en liste

val nums = (1 to 10 by 2).toList
val letters = ('a' to 'f').toList
val letters = ('a' to 'f' by 2).toList

La collection Maps en scala

Le Scala Map est une collection de paires clé / valeur. les Maps sont des tables de hachage, c’est-à-dire un tableau de clé-valeur.

Toute valeur peut être récupérée en fonction de sa clé.  Les clés sont uniques dans Map, mais les valeurs n’ont pas besoin de l’être.

Il en existe deux types de collection scala map : les scala map immuables et les scala map mutables. Par défaut, Scala utilise la map immuable. Syntaxe : val nom_map = Map(“clé” -> valeur, “clé” -> valeur, etc..)

test_map = Map("nom" -> "Julien", "prenom" -> "chokogoue", "age" -> 40)
//manipulation
test_map.keys
test_map.values
test_map.keys.foreach(x => println(x))

Toutefois, si vous souhaitez utiliser la Map mutable, vous devrez importer explicitement la classe scala.collection.mutable.Map

Enfin, si vous souhaitez utiliser à la fois des cartes mutables et immuables, vous pouvez continuer à faire référence à la map immuable sous le nom de “map”, puis faire référence à l’ensemble mutable comme mutable.Map”.

Les tableaux scala

Un tableau en scala est une collection ordonnée et mutables des valeurs du même type. La seule différence qui la distingue des listes c’est l’immutabilité. Les tableaux sont mutables, là où les listes sont immutables. En dehors de celà, la manipulation est sensiblement la même. Syntaxe de création d’un tableau scala : val arrayName : Array[arrayType] = Array(elt1, el2, el3, etc)

val tab = new Array[String] ("a", "b", "c") 
For (i <- 0 to 3) {
    print (tab(i))
}

//changer la valeur d'un élément dans le tableau
tab(0) = "z" 

Les structures conditionnelles en scala

Scala possède 4 instructions conditionnelles : le IF, le WHILE, le FOR, et le FOR EACH.

la boucle While()

le WHILE est boucle conditionnelle qui signifie que l’expression s’exécute tant que la condition est vrai.
Syntaxe : while (condition) { expression }

var i = 0 
     while (i < 7) {
	   println(i)
	  i = i + 1
	}

la boucle For ()

le FOR est une boucle conditionnelle, qui exécute une action pour une plage de valeur donnée du compteur.
Syntaxe : for (condition) {expression}

var i = 0 
for (i <- 0 to 10) {
   println(i)
}

l’itérateur forEach()

ForEach() n’est pas vraiment une structure conditionnelle, même si elle est classée dans la catégorie des boucles. C’est un itérateur. Il est conçu exclusivement pour parcourir les éléments d’une collection (comme une liste, un tableau ou un tuple).

names.foreach(println)
names.foreach( e => println(e))
names.filter(s => s.startsWith("b")).foreach(println) 

Programmer en Scala pour Spark

Pour terminer ce tutoriel sur scala, nous allons aborder la programmation en Scala pour Apache Spark. Rappelez-vous, scala doit sa grande influence ces dernières années grâce aux problématiques soulevées par le Big Data. Scala fournit les abstractions et les structures nécessaires pour traiter les données efficacement, exploiter les processeurs SMP (Simultaneous Multi Processing) ou Multi-coeurs, et gérer les accès concurrents.

Toutes ces caractéristiques ont permis à scala d’être le langage à travers lequel le framework de calcul massivement parallèle Apache Spark a été développé. Aujourd’hui, la maîtrise de Spark est incontournable pour quiconque souhaite travailler dans le Big Data. Dans cette partie, nous allons vous initier au développement d’application Spark en scala.

L’abstraction principale de Spark c’est le RDD (Resilient distributed dataset – jeu de données distribué et résilient). Cela signifie que lorsqu’on développe des applications en Spark, on travaille ultimement avec les RDD.

Le RDD est une “collection” (au sens scala du terme) d’éléments partitionnée à travers les nœuds d’un cluster informatique. C’est une abstraction de collection données distribuée qui permet aux développeurs d’effectuer des calculs parallèles en mémoire sur un cluster de façon complètement tolérante aux pannes.

Formellement, un RDD est une collection partitionnée d’objets (instance de classe) accessible en lecture-seule. Etant donné qu’une RDD est une abstraction, elle n’a pas d’existence réelle, dès lors elle doit être explicitement créée ou instanciée à travers des opérations déterministes sur des fichiers de données existants ou sur d’autres instances de RDD.

Les RDD ont été modélisés exactement sur la collection Scala. Cela signifie que ses caractéristiques sont identiques aux caractéristiques d’une collection scala (comme une liste ou un tableau) :

  • lazy : les RDD héritent de la propriété de “paresse” liée au paradigme fonctionnel de scala.
  • immutable : les RDD héritent de l’immutabilité des collections immutables de scala (comme les listes).
  • In-memory : les RDD héritent de la capacité de scala de mettre en cache les variables.

Un exemple d’application Spark écrit en scala :

 def main(args: Array[String]): Unit = {
      val spark:SparkSession = SparkSession.builder().master("local[1]")
          .appName("Session Sparl")
          .getOrCreate()

      val rdd_test :RDD[Int] = spark.sparkContext.parallelize(List(1,2,3,4,5))
      val rddCollect:Array[Int] = rdd.collect()

      println("Action: premier element: "+rdd.first())
      rddCollect.foreach(println)

      println("read all text files from a directory to single RDD")
      val rdd = spark.sparkContext.textFile("C:/tmp/files/*")
      rdd.foreach(f=>{
      println(f)
  })

  }

Voilà ! Nous sommes arrivés au terme de ce tutoriel sur le langage Scala. Nous espérons que vous avez compris l’intérêt de Scala dans le marché et son intérêt dans votre carrière. Si vous souhaitez aller plus loin dans le tutoriel, suivez les ressources ci-après. Aussi, nous mettons à votre disposition, une heure de vidéo-tutoriel plus complet pour apprendre la programmation scala. Vous pouvez télécharger cette vidéo gratuitement en cliquant dans le formulaire qui s’affiche à la fin de l’article.


Ressources utiles

Pour aller plus loin dans le développement d’applications Spark en Scala, cliquez ici : Maîtrisez Spark pour le Big Data avec Scala

Pour plus de détails sur le langage Scala, n’hésitez pas à consulter le site officiel : https://www.scala-lang.org/
Consultez la documentation officielle de Scala : https://docs.scala-lang.org/overviews/scala-book/introduction.html


Juvénal JVC

Juvénal est spécialisé depuis 2011 dans la valorisation à large échelle des données. Son but est d'aider les professionnels de la data à développer les compétences indispensables pour réussir dans le Big Data. Il travaille actuellement comme Lead Data Engineer auprès des grands comptes. Lorsqu'il n'est pas en voyage, Juvénal rédige des livres ou est en train de préparer la sortie d'un de  ses livres. Vous pouvez télécharger un extrait de son dernier livre en date ici : https://www.data-transitionnumerique.com/extrait-ecosystme-hadoop/

>