Dans ce guide, vous allez découvrir ce qu’est le langage Scala et comment il se différencie de Java. Nous vous présentons aussi quelques exemples pour vous aider à apprendre les rudiments de Scala.
À lire aussi:
Meilleur endroit pour bien apprendre Scala
Liste de contenu
Est-ce que Scala va devenir le nouveau grand langage de programmation?
Quand on parle de nouvelles tendances en termes de technologie, les nouveaux langages de programmation en font souvent partie.
Un des langages qui commence de plus en plus à capter l’attention est Scala. Même s’il n’est pas encore populaire, Scala semble gagner du terrain en offrant un bon équilibre entre la syntaxe accessible de Ruby et le support robuste de Java.
Voici quelques arguments pour prouver que Scala mérite d’être considéré.
Il fonctionne avec Java Virtual Machine (JVM)
La réalité de la programmation pour les entreprises est que Java est le plus populaire.
En outre, les grandes entreprises hésitent à prendre le risque de refaire toute une programmation déjà établie. Scala ne semble pas être un problème dans ce cas-là, parce qu’il peut toujours fonctionner avec Java Virtual Machine.
Scala est donc capable de jouer, ou plutôt d’opérer, avec les outils et pièces déjà mis en place par l’entreprise. La migration vers Scala est donc largement moins risquée qu’en le pense.
Scala est aussi amplement capable d’opérer avec les codes Java existant. Même si beaucoup prétendent que cela est cohérent, la réalité quant à elle est plus compliquée. Mais en dépit de ces problèmes, on peut affirmer que Scala opère mieux avec Java qu’avec d’autres langages de programmation.
Certains programmeurs ont aussi cette peur de ne pas être assez performant quand il est question de changer de langage de programmation. Mais puisque Scala utilise JVM, il n’y a pas de raison d’avoir peur.
En général, Scala fonctionne avec l’équivalent d’un programme Java, donc les entreprises ne devraient pas en souffrir s’ils décident d’utiliser Scala.
Scala permet aussi l’utilisation de la plupart des librairies JVM, qui sont souvent profondément intégrées dans les codes utilisés par l’entreprise. Par conséquent, Scala n’est pas un obstacle pour une entreprise qui utilise largement Java.
Scala est plus concis et plus facile à lire que Java
Scala a une syntaxe simple et facile à lire comme celle des langages populaires tel que Ruby.
C’est ce qui manque cruellement à Java. Cela a un impact sur la quantité du travail que l’équipe de développement doit faire sur la maintenance des codes. Un impact souvent négligé. Le travail additionnel nécessaire pour comprendre et entretenir le code Java est considérable.
Le fait que Scala soit concis présente aussi d’autres avantages:
- Un code qui s’écrit sur plusieurs lignes sur Java, ne prendrait qu’une petite fraction de ces lignes dans Scala. Cela permet aux programmeurs d’être plus productifs, en réalisant plus de travail en une journée.
- Le fait d’avoir peu de lignes permet aussi de réaliser les tests plus facilement, tout comme les évaluations de code ou de débogage (mise au point).
Les fonctionnalités de Scala
Scala utilise beaucoup de syntaxes faciles à lire qui sont devenues populaires auprès des développeurs.
Nombreux sont alors les développeurs qui le considérent comme un langage plus fonctionnel.
Un exemple est l’appariement de modèle, qui permet de facilement comparer les strings (chaînes). Un autre exemple est le mixins, qui permet d’inclure les fonctions dans une classe.
Cela peut faire gagner beaucoup de temps puisqu’on peut réutiliser les codes. Ces types de fonctionnalités attirent souvent les développeurs, particulièrement pour ceux qui sont devenus accoutumé à l’utilisation de langage autre que Java.
Facile à apprendre et « excitant »
Le fait que Scala soit similaire aux langages populaires comme Ruby peut être un avantage, parce que sa syntaxe est accessible et relativement facile à apprendre. C’est particulièrement vrai lorsqu’on le compare aux langages plus complexes comme Java ou C++.
Le fait qu’il soit nouveau, en plus de son accessibilité, a fait de lui un choix populaire pour les développeurs super motivés et passionné de découvrir de nouveaux langages de programmation.
Ces développeurs ont pour la plupart du temps flexibles, ils ont soif de nouvelles expériences, ils sont innovants et extrêmement adroits. Pour beaucoup d’organisations, c’est peut-être ce qu’ils ont réellement besoin dans leur équipe.
On n’est pas encore sûr si Scala va avoir ou pas sa montée en puissance en termes de popularité, puisque tous les langages ont chacun ses évangélistes et ses détracteurs. La vérité est que le choix de changer de langage pour utiliser Scala est un choix personnel et dépend largement de l’environnement. Cependant, les avantages mentionnés auparavant ont surement mieux éclairci sur la situation, particulièrement pour les entreprises qui utilisent Java.
Le dilemme
Ceux qui disent que Scala est difficile n’ont pas forcément tort, mais sa courbe d’apprentissage mérite l’investissement. Éventuellement, certaines des fonctionnalités les plus complexes du langage (Tuples, Functions, Macros, pour ne citer que ceux-là) aident les développeurs à facilement écrire de meilleurs codes et d’avoir de meilleures performances.
Franchement, si on est programmeur, mais qu’on n’est pas assez intelligent pour apprendre les parties complexes d’un langage, on devrait peut-être changer de travail.
Scala est un langage JVM sécurisé qui incorpore la programmation à objet orienté et la programmation fonctionnelle dans un langage extrêmement concis, logique et extraordinairement puissant. Certaines personnes seront surement surprises de savoir que Scala n’est pas si nouveau que ça. Il a été introduit pour la première fois en 2003. Mais ce n’est que récemment que Scala a commencé à avoir de nombreux adeptes.
Alors la question se pose: pourquoi devrait-on utiliser Scala ?
À partir d’ici, on va examiner concrètement les avantages de Scala, spécialement par rapport à Java (puisque Scala fonctionne avec JVM).
Contrairement à Scala, les langages de programmation Kotlin et Ceylon ont décidé de garder leur syntaxe aussi similaire que possible à celle du langage Java, pour faciliter l’apprentissage de leur langage. Ça semble être une bonne idée, mais le problème est qu’on reste dans ces mêmes paradigmes de Java, qui sont les raisons même qui nous a poussés à créer un « meilleur Java ».
En contraste, Scala a été spécifiquement créé dans le but d’être un meilleur langage, en se défaisant de tous les aspects restrictifs, trop laborieux, frustrants de Java.
Ainsi, il y a des codes et modèles de Scala très distincts de ceux de Java. On a donc une certaine difficulté au début quand on apprend le langage de Scala, mais le résultat est un langage plus affiné et mieux organisé. Un langage qui sera éventuellement plus facile à utiliser et va rendre plus productive.
Scala versus Java – qui est réellement le plus complexe ?
Une partie du succès de Java a été sa simplicité, mais ironiquement, cette simplicité a aussi contribué à sa complexité. Certes, on peut écrire à peu près tout avec Java, mais le nombre de lignes requis pour le faire peut être décourageant.
La programmation avec Scala quant à elle à une structure un tout petit peu plus complexe. Mais vous préféreriez quoi : une ligne de code un tout petit peu plus complexe de Scala ou son équivalent en Java qui s’étend à 20 lignes de code « plus simples » ?
La vérité est que Java est souvent trop verbeux (contenant trop de mots, plus que le nécessaire). Le compilateur de Scala est incroyablement intelligent.
Ainsi, le développeur n’a pas besoin de spécifier explicitement ces choses que le compilateur peut déduire. Regardez cette comparaison de Java et Scala, avec le simple programme « Hello World! » :
Hello World dans Java :
public class HelloJava {
public staticvoidmain(String[] args) {
System.out.println("Hello World!");
}
}
Hello World dans Scala:
objectHelloScala {
defmain(args: Array[String]): Unit = {
println("Hello World!")
}
}
Même si on n’observe pas une énorme distinction entre les deux langages. Scala est moins verbeux, même pour ce simple exemple.
Considérons un exemple plus pratique en regardant la création d’une simple liste de Strings (chaînes) :
Créer une liste avec Java :
List<String>list = new ArrayList<String>();
list.add("1");
list.add("2");
list.add("3");
Créer une liste avec Scala :
val list = List("1", "2", "3")
Évidemment, il y a des astuces pour écourter un peu les codes Java, mais pas avec l’utilisation standard.
Maintenant, considérons un cas avec une liste de strings qui sont des nombres, mais on veut convertir cette liste en une liste de nombres entiers.
Java :
List<Integer>ints = new ArrayList<Integer>();
for (String s : list) {
ints.add(Integer.parseInt(s));
}
Scala :
val ints = list.map(s =>s.toInt)
Grace aux propriétés simples de Scala, cette conversion devient extrêmement simple.
Exemple de Classe : Scala versus Java
Allons encore plus loin en comparant la création standard bean / plain old Java object (POJO) dans Java et Scala.
Premièrement, la version Java :
public class User {
private String name;
private List<Order>orders;
public User() {
orders = new ArrayList<Order>();
}
public String getName() {
returnname;
}
public voidsetName(String name) {
this.name = name;
}
public List<Order>getOrders() {
returnorders;
}
public voidsetOrders(List<Order>orders) {
this.orders = orders;
}
}
public class Order {
privateint id;
private List<Product>products;
public Order() {
products = new ArrayList<Product>();
}
public intgetId() {
return id;
}
public voidsetId(int id) {
this.id = id;
}
public List<Product>getProducts() {
returnproducts;
}
public voidsetProducts(List<Product>products) {
this.products = products;
}
}
public class Product {
privateint id;
private String category;
public intgetId() {
return id;
}
public voidsetId(int id) {
this.id = id;
}
public String getCategory() {
returncategory;
}
public voidsetCategory(String category) {
this.category = category;
}
}
OH 🙁 !!! C’est Très long.
Maintenant la version Scala :
class User {
varname: String = _
var orders: List[Order] = Nil
}
classOrder {
var id: Int = _
var products: List[Product] = Nil
}
class Product {
var id: Int = _
varcategory: String = _
}
Qui est donc le plus compliqué !?
Sommes-nous juste dans nos jugements ?
Si vous êtes allé aussi loin et que vous êtes un programmeur Java, vous êtes peut-être en train de vous dire que ma comparaison de ces deux codes n’est pas logique. Après tout, rien ne m’empêche de faire des variables publics dans Java et puis me défaire des Getters et des Setters.
Cependant, si vous considérez vraiment le raisonnement à la base des getters et setters de Java, c’est spécifiquement pour de futures actions.
C’est-à-dire que si, plus tard, vous voulez ajouter une certaine logique que ce soit pour les getters ou les setters des variables, vous auriez besoin de réécrire ces variables publics (c’est pour cela que l’utilisation des getters et des setters dès le commencement est encouragée dans Java).
Par contre, avec Scala, ce n’est pas le cas. Dû au design du langage, l’abstraction reste intacte sans l’usage des Getters et des Setters.
Considérez, par exemple, la classe User modifiée dans Scala qui montre un NullPointerException si vous essayez de configurer le nom en Null :
class User {
private var _name: String = _
var orders: List[Order] = Nil
defname = _name
defname_=(name: String) = {
if (name == null) {
throw new NullPointerException("User.name cannotbenull!")
}
_name = name
}
Et vous pouvez toujours écrire le nom comme cela :
user.name = "John Doe"
Remarquez que par conséquence on a plus besoin de configurer à l’avance les méthodes accesseurs (Method Accessors).
En outre, puisque Scala préfère la constance, je peux écrire cela de façon encore plus concise dans Scala avec les classes :
En outre, puisque Scala préfère la constance, je peux écrire cela de façon encore plus concise dans Scala avec les classes :
case class User(name: String, orders: List[Order])
case class Order(id: Int, products: List[Product])
case class Product(id: Int, category: String)
Il est impressionnant de voir que je peux écrire avec largement moins de code.
Allons encore plus loin
Maintenant considérez un scenario avec les classes mentionnées auparavant, où je veux ajouter une demande subtile dans la classe User qui va donner une liste de tous les Products (produits) que l’User (l’utilisateur) a commandé :
Avec Java :
public List<Product>getProducts() {
List<Product>products = new ArrayList<Product>();
for (Orderorder : orders) {
products.addAll(order.getProducts());
}
returnproducts;
}
Heureusement, java.util.List a une méthode addAll, ou getProducts() aurait été encore plus long avec Java.
Dans Scala, par contre, tout ce dont on a besoin c’est :
defproducts = orders.flatMap(o =>o.products)
Vous pouvez voir combien la mise en place de Scala est largement plus courte. Certes, pour ceux qui débutent avec Scala c’est un peu complexe, mais une fois que vous comprenez le concept, vous verrez que Scala est largement plus simple que le code Java.
Maintenant, rendant le cas encore plus compliqué. On veut voir les Products (Produits) dans une Category (catégorie) spécifique.
Dans ce cas-là, puisqu’on ne peut pas utiliser la méthode addAll dans java.util.List, ça devient très irritant avec Java :
public List<Product>getProductsByCategory(String category) {
List<Product>products = new ArrayList<Product>();
for (Orderorder : orders) {
for (Product product : order.getProducts()) {
if (category.equals(product.getCategory())) {
products.add(product);
}
}
}
returnproducts;
}
Par contre, avec Scala, le code reste très concis. On utilise juste flatMap pour combiner les listes de produits de chaque Order en une seule liste. Puis, on les filtre afin qu’ils correspondent seulement à la catégorie:
defproductsByCategory(category: String) = orders.flatMap(o =>o.products).filter(p =>p.category == category)
Dynamique versus statique
On a vu un tas de nouveaux langages ces dernières années, mais si presque la plupart de ces langages ont tous été créés pour être dynamiques, Scala lui est statique.
En tant que développeur professionnel, utilisant et connaissant beaucoup de langages dynamiques, je pense que les contrôles de temps de compilation sont incroyablement importants pour écrire des codes solides.
Dans un langage dynamique, avant d’avoir testé votre code dans de nombreux scenarios, vous n’êtes jamais sûr qu’il ne va pas avoir de bogue (défaut) et qu’il va être assez robuste. Il se peut alors qu’il y a de sérieux défauts dans les codes, et vous ne verrez ces défauts seulement qu’après la publication.
Résumé
L’article a beaucoup parlé de la comparaison Java versus Scala pour vous donner un aperçu de la puissance et des capacités de Scala, pour aussi vous pousser à apprendre ce langage.
Il n’est pas seulement un grand langage qui peut rendre la programmation moins laborieuse et plus plaisante, il est aussi utilisé par les plus grandes compagnies dans le monde (LinkedIn, Twitter, FourSquare, The Guardian, pour ne citer que ceux-là).
La popularité de Scala monte rapidement, tout comme le nombre de personnes qui l’utilisent. C’est évident quand on regarde le nombre de demandes pour des développeurs Scala qui ne cesse d’augmenter. Si vous avez encore hésité auparavant, il est temps maintenant de surfer la vague et d’arrêter de se demander: « Pourquoi apprendre Scala ?»
Auteure des blogs, Aina Strauss préfère penser à « carrière » comme un verbe plutôt qu’un nom. Elle est journaliste indépendant depuis les débuts du Web et écrit sur tout, de l’informatique, de nouvelles technologies au voyage. Son but n’est autre que d’apporter plus d’informations à tous ceux qui souhaitent adopter les nouvelles technologies du Web et de les aider à sélectionner le meilleur hébergement de manière pratique et rentable.
