Compte rendu de la soirée Scala avec Bruce Eckel

Hier soir Bruce Eckel nous a présenté sa vision du langage Scala.
Il constate que Scala est généralement mal enseigné. Il co-écrit donc un livre pour débutant : « Scala comme premier langage de programmation ».

Scala a la réputation d’être un langage compliqué et difficile. C’était donc intéressant de voir l’approche différente, surtout venant d’un pédagogue de renom.
Au début, Bruce trouvait Scala trop compliqué lui aussi. Mais il est arrivé à la conclusion que les « early adopters » voulaient faire la preuve de leur intelligence en écrivant du code profitant de toutes les libertés syntaxiques du langage et tirant profit au maximum de sa puissance. Ce sont ces exemples délicats à relire et à comprendre qui ont donné une image faussée du langage.

Il nous a ensuite expliqué pourquoi il pense que Scala est en fait beaucoup plus simple que Java ou C++ pour un débutant :

  • « Hello world » plus simple:on peut commencer à coder sans la notion de classe, d’import, …
  • Possibilité de tester des bouts de code directement dans le REPL Scala (pas de compilation, feedback immédiat)
  • Possibilité d’écrire des scripts (bouts de code sans définir de classe)
  • Pas besoin de déclarer tous les types (inférence de type)
  • Les génériques sont plus simples à appréhender qu’en Java

Et surtout la syntaxe est plus légère qu’en Java/C++ et simplifie grandement les choses en éliminant tout le code de cérémonie.
Il a ensuite attaqué un cours très didactique, en commençant par les déclarations de variables et fonctions, montrant notamment la régularité dans la déclaration de type « : NomDuType » dans les deux cas.
Ensuite il présente les Case Class avant les classes. En effet, elles sont plus simple et bien pratique. Il introduit au passage le pattern matching diantrement puissant. Le focus est définitivement sur les aspects haut niveau, on ne s’encombre pas de savoir comment ca marche sous le capot.

Puis il parle des parameterized class et évoque la variance / contra-variance. Ces concepts intéresseront les créateurs de librairies. Mais l’utilisateur bénéficiera de leur puissance, sans subir leur complexité.

Le type « Any » permet de souligner la régularité des types dans Scala. Il n’y a pas de cas particulier à gérer.

Les slides très clairs montraient comment on peut faire évoluer le code pour profiter des raccourcis syntaxiques. Si au départ Bruce refusait de montrer ce code il en parle finalement car il sait bien que tôt ou tard un développeur se retrouvera face à un code ainsi écrit.
On s’attarde donc sur les problèmes de style, la tentation du « one-liner », et l’aspect fonctionnel avec « yield ». Ce qui au passage m’aura enfin permis de comprendre cette syntaxe.
Tout au long de la présentation, Bruce a bien insisté sur la nécessité de définir des règles quant à la syntaxe afin d’avoir un code cohérent et lisible. Ces règles doivent être validées lors de code review, la meilleure manière d’éviter du code de mauvaise qualité.

Pour finir il évoque les acteurs et le parallélisme. Là encore, le focus est sur la facilité d’écriture, pas sur l’implémentation qui sous-tend ces concepts.
Cette approche insistant sur les avantages de Scala sans chercher à mettre en avant toute sa puissance et ses fonctionnalités avancées donne envie de s’y mettre.
Après ce survol rapide, les questions s’orientent sur le choix des langages: pourquoi Scala ?
La réponse tient en un mot: productivité.

Pour visionner les slides