Passer à Scala, ce qu’il faut retenir

Cela fait 3 ans que je développe avec Scala, à temps plein. Plusieurs projets plus tard, quel bilan tirer du langage et des librairies Scala ? Quels sont les difficultés pour ceux qui souhaitent découvrir le langage ? Et pourquoi une photo d’un site archéologique en Jordanie pour illustrer cela ? 

Après ma dernière expérience pour une grande Banque Française, j’ai découvert Scala en mai 2011. Découvert, pas tout à fait. J’avais tenté l’année précédente de me lancer, mais sans succès. Pas de projet et de motivation, j’avais mal abordé ce projet. C’est en revenant plus tard et en ayant aussi digéré le premier échec que le déclic s’est produit.

Certains articles vous marquent. Vous lisez quelques lignes, et vous vous dîtes : mais c’est moi. C’est en lisant « Transitioning to Scala » écrit par Kevin Webber, que j’ai eu envie d’écrire et de partager mon expérience sur Scala.

Je commencerai d’abord par partager où j’en suis aujourd’hui (avril 2014). Martin Odersky a publié un petit article avec une matrice simple, qui permet d’évaluer son niveau et surtout son profil. Il fait la distinction entre les développeurs de librairies, et les développeurs d’applicatifs. Clairement, mon objectif est d’être un excellent développeur applicatif. Je ne m’intéresse pas autant au profil « développeur de librairies ». Je pense que cela demande d’autres compétences, que je n’ai pas. Et par ailleurs, je suis plus dans la mise en oeuvre de solutions pour mes clients, que dans le développement d’un outil ou d’un framework. Je respecte autant les 2 profils, mais je suis vraiment plus orienté pragmatisme et production, que théorie et discussions creuses à 2 euros sur certains forums.

Savoir simplement se placer permet déjà de regarder Scala de 2 façons différentes. Imaginions que vous êtes développeur d’Hibernate en Java et que vous souhaitez apprendre Scala, pour faire un ORM en Scala (ce qui est pas forcément l’idée du siècle). Il est clair que l’effort d’apprentissage et le temps nécessaire à bien maîtriser le langage seront des freins dans votre projet. C’est possible, mais ça va être plus difficile.

L’autre option (celle que j’ai pris) c’est d’apprendre le langage sur des projets, en se positionnant comme intégrateur. Je suis parti du framework Web Play1 + Scala en 2011, pour ensuite passer à Play2+Scala en mai 2012. Clairement, le cycle d’apprentissage est plus facile en prenant ce chemin. Et c’est aussi celui que je conseillerai aux personnes qui souhaitent apprendre Scala. Apprenez tout d’abord à l’utiliser avec une librairie comme Akka, un framework web comme Scalatra ou une librairie comme Slick. Petit à petit, en se laissant guider au début.

Je pense que j’ai un niveau A3/L2 dans l’échelle d’Odersky. J’arrive à bien mieux maîtriser les types, je comprends le principe du Cake-Pattern, mais je n’ai pas le niveau pour apprécier les subtilités de Scala.Z pour l’instant.

Level A1: Beginning application programmer

• Java-like statements and expressions: standard operators, method calls, conditionals, loops, try/catch
• class, object, def, val, var, import, package
• Infix notation for method calls
• Simple closures
• Collections with map, filter, etc
• for-expressions

Level A2: Intermediate application programmer

• Pattern matching
• Trait composition
• Recursion, in particular tail recursion
• XML literals

Level A3: Expert application programmer

• Folds, i.e. methods such as foldLeft, foldRight
• Streams and other lazy data structures
• Actors (Akka only)
• Combinator parsers

Level L1: Junior library designer

• Type parameters
• Traits
• Lazy vals
• Control abstraction, currying
• By-name parameters

Level L2: Senior library designer

• Variance annotations
• Existential types (e.g., to interface with Java wildcards)
• Self type annotations and the cake pattern for dependency injection
• Structural types (aka static duck typing)
• Defining map/flatmap/withFilter for new kinds of for-expressions
• Extractors

Level L3: Expert library designer

• Early initializers
• Abstract types
• Implicit definitions
• Higher-kinded types

Pourquoi apprendre Scala ?

Je vais forcément vous donner un avis subjectif (un avis n’est-il d’ailleurs pas tout le temps subjectif…). Je pense que Scala est parfait pour les développeurs Java. Sans être en rupture avec la culture et les outils qu’ils maîtrisent déjà, il apporte assez de nouveautés et de belles choses pour en faire un language à utiliser Il ne faut que quelques jours pour atteindre le niveau A1. Vraiment. Pensez-y et mettez devant vous les 10 prochaines années.

Mon premier point donc est que Scala s’apprend simplement dès lors que l’on sait ce que l’on veut faire. Ne comptez pas maîtriser l’ensemble du langage en quelques semaines. Vous étiez un expert Java mais vous êtes un junior Scala. Et pourtant, dès le début, on voit déjà qu’il y a assez de nouveautés pour être productif et surtout heureux. Car ce qui donne la banane, c’est d’avancer et de ne pas être frustré.

Deuxième point intéressant : Scala permet de comprendre et de mettre en oeuvre les lambdas de Java 8 sans aucuns efforts. Apprendre Scala permet de mélanger le paradigme fonctionnel et le paradigme objet. Sans entrer dans un autre débat, j’apprécie de conserver l’approche objet, tout en mettant en oeuvre du fonctionnel. Moi ça me plaît car c’est parfait pour mon métier de développeur et d’intégrateur.

Troisième point : je suis devenu un fan du typage statique. Cela fait gagner un temps impressionnant lorsque vous développez. Et croyez-moi, pour moi qui suit passé par les cases Perl, PHP, Python, Groovy et Javascript, c’était étonnant. Mes premiers essais avec Play2+Scala d’ailleurs n’étaient pas concluants. J’avais vraiment du mal à passer au typage fort. Aujourd’hui je m’en sers comme d’un squelette robuste, pour refactorer du code sans avoir peur. Scala y ajoute l’inférence de type, ce qui permet aussi de réduire « le bruit » pour ne garder que le signal utile. Cela facilite la relecture du code, et vous force aussi à travailler plus proprement. Scala est moins verbeux que Java. C’est simple, factuel et sans discussions.

Quatrième point : j’avoue que je suis assez fan de la qualité de la pile technique proposée par Typesafe. Prenez par exemple Akka. C’est une boîte à outils simple qui permet de construire des applications concurrentes et distribuées. Ajoutez à cela un modèle de tolérance de panne et une approche orientée événement, que du bonheur. Je suis par contre moins fan de SBT (Simple Build Tool), l’équivalent de Maven pour le monde Scala.

Cinquième point : Scala est pour moi une alternative plus intéressante que Java. Je le pense maintenant sans soucis. J’adore les deux langages, mais je trouve que Scala est tout simplement plus productif. Non, l’écriture n’est pas plus longue. C’est simplement le temps de désapprendre ses réflexes de développeur Java qui donne ce sentiment.

Sixième point : Scala est un langage qui s’enseigne plutôt bien. J’ai lancé 2 personnes sur Scala lorsque j’étais Lead-developer chez Zaptravel. Le premier est maintenant à Montréal, et il programme en Scala à temps plein. Le second, excellent développeur Front-end et Ruby, m’a dit que refaire du Rails était un peu dur lorsque l’on était passé par la case play2/scala. Le langage s’apprend plus facilement que Java, car il y a moins de cérémonial. Comparez une case class Scala à un PO2VJO (Plain old very verbose java object (tm nicolas)). L’API Collections est tout simplement de l’or en barre, surtout lorsque l’on compare celle-ci à Java (même Java 9)

Oui mais comment apprendre ?

Je pense que le mentoring fonctionne bien. J’ai eu la chance de travailler en binôme avec Alexis Agahi, qui m’a lancé sur Scala. Puis ensuite de pouvoir échanger avec Sadek Drobi, de Zengularity. Ensuite j’ai aussi pas mal lu de livres. Je recommande le livre de référence de Martin Odersky (l’un des pères de Scala), A.Spoon et B.Venners, « Programming in Scala »

Coursera propose un excellent cours sur la programmation fonctionnelle, qui permet justement de se confronter à des exercices appliqués. Cette formation donne réellement les bases de l’approche fonctionnelle, indispensable pour apprécier Scala.

Si vous faîtes un peu de Web, Typesafe propose Activator, des templates de projet (SBT, Play2 et autre) prêt à l’emploi. Ceci permet de démarrer rapidement un petit projet avec AngularJS, Play2 et une petite base MySQL par exemple.

J’ai aussi découvert pas mal d’astuces en lisant le code source de Play2. Clairement, c’est plus difficile que de lire du code applicatif. Mais aujourd’hui j’apprécie et je comprends mieux en étant d’abord passé par la case « Développeur applicatif » pour maintenant prendre le chemin d’un développeur de librairie.

Voici un exemple tiré de la documentation de Finagle, un framework RPC simple de Twitter :

import com.twitter.finagle.{Http, Service}
import com.twitter.util.{Await, Future}
import java.net.InetSocketAddress
import org.jboss.netty.handler.codec.http._

object Client extends App {
  val client: Service[HttpRequest, HttpResponse] = Http.newService("www.google.com:80")
  val request =  new DefaultHttpRequest( HttpVersion.HTTP_1_1, HttpMethod.GET, "/")
  val response: Future[HttpResponse] = client(request)

  response onSuccess { resp: HttpResponse =>
    println("GET success: " + resp)
  }
  Await.ready(response)
}

Prendre un nouveau départ

Le langage et les nombreuses librairies font de Scala un choix pertinent. Il suffit aussi de regarder l’écosystème. L’innovation vient des grands du Web, qui vous donnent accès à des outils (comme Finagle justement, qui vient de Twitter).

A titre personnel, je pense investir encore plus dans les semaines qui viennent, sur Scala et sur les différentes technologies autour de Scala. Cela commencera par des formations avancées, afin de développer une expertise et pour aussi pouvoir partager avec d’autres développeurs. Est-ce que Scala est stratégique lorsque l’on est freelance comme moi ? Ce que je sais, c’est que le langage m’a donné des opportunités ces derniers mois. Le fait de ne pas être centré sur le profil « Java super méga senior (17 d’expérience, limite un peu trop vieux) » permet de rencontrer d’autres personnes. Sur Paris, il est assez simple de trouver une mission « expert Java » facturée entre 700 et 900 euros. Il est plus difficile pour l’instant de trouver ce type de mission avec Scala. Après c’est un choix. J’accepte de facturer moins, mais de faire du Scala.

Tout est une affaire de choix, de ce que l’on souhaite faire et des personnes que l’on rencontre.

Articles similaires:

Présentation de Play! Scala au Scala User Group Scala, case, Option, None et Some Lancement du Paris Scala User Group Soirée Scala au Paris JUG