Scala on Coursera

La semaine dernière s’achevait le cours Functional Programming Principle in Scala de Coursera, animé par Martin Odersky en personne. Si vous ne connaissez pas Coursera, sachez que c’est l’une des startups californiennes qui se lance dans le domaine de l’éducation en ligne (l’une de leur dernière recrue est Pamela Fox, speakeuse à Mix-it 2012, et qui, alors qu’elle n’était pas encore employée, avait fait une keynote sur l’éducation). Sur le site, vous suivez des cours en vidéo, vous avez des exercices à faire et à rendre, vous recevez des notes et à la fin un diplome si vous avez été sages. Avec pas loin de 2 000 000 d’inscrits, le site a pris son envol, à juste titre il faut dire car la plateforme est très bien conçue. Martin Odersky, et sa société TypeSafe, frappe donc encore un grand coup marketing en lançant ce cours en ligne sur Coursera. Si ce nom vous est également inconnu, Martin est le créateur de Scala avec une équipe de l’EPFL (Ecole Polytechnique Fédérale de Lausanne) où il est chercheur. Il a également bossé sur le compilateur Java et notamment contribué aux génériques de Java5. On peut donc dire sans trop se tromper qu’il en connaît un rayon en matière de JVM et de langage.

 

Je ne l’avais jamais vu en revanche donner un cours, mais les videos sur Coursera qu’il a réalisé sont claires et compréhensibles à condition d’avoir un minimum d’anglais (et également de faire abstraction de l’accent allemand, qui est quand même plus compréhensible que l’accent français probablement). Le volume de cours n’est pas négligeable : s’étalant sur 7 semaines, il fallait quand même prévoir une à deux heures pour les vidéos et de quelques minutes à plusieurs heures pour les exercices. Mais cela n’a pas décourager les foules : le cours a compté 50000 participants (ou plutot inscrits, je ne sais pas si tous en sont venus à bout). Ce que j’en retiendrais :

 

Les plus :

– la plateforme Coursera : rien à dire, je trouve ça bien très bien fait. Les vidéos sont téléchargeables ou visionnables en ligne, avec une possibilité d’accélérer la lecture qui est très appréciable tout en restant compréhensible. Les exercices sont très clairs, vous téléchargez un projet tout prêt dans le cas de ce cours, une fois terminé, vous pouvez le soumettre en ligne de commande avec ‘submit monmail monpassword’. Des tests unitaires vont alors se lancer sur votre projet directement sur la plateforme et vous pouvez voir votre résultat sur la page de feedback. Il faut patienter quelques minutes mais rien de dramatique. Le système de note est intéressant, avec un petit côté gamification : on cherche à avoir le 10/10 même si une note inférieure permet de valider le cours. Seul point négatif à ce propos : l’absence de trace vraiment explicite pour comprendre quel test et quand votre programme a échoué : on se retrouve à mettre de vieux println dans le code pour essayer de cerner le problème.

– les leçons étaient très souvent intéressantes, mettant bien en avant la programmation fonctionnelle, avec des exemples bien choisis et des solutions élégantes. J’avais lu le livre d’Odersky “Programming in Scala” lors de sa sortie, et j’ai retrouvé des exemples du livre, mais je m’y suis bien moins ennuyé. Les exercices étaient loin d’être triviaux pour certains : celui sur les anagrammes que je pensais faire en quelques minutes m’a finalement pris les 2h de ma pause déjeuner… La progression était correcte, et j’ai eu l’impression d’apprendre des choses tout au long du cours : je pouvais difficilement en demander plus.

– au delà de Scala, difficile de ne pas aimer la programmation fonctionnelle. Et la pratiquer en Java est un vrai plaisir. Les collections scala sont géniales, vraiment. Dans la vie de tous les jours, je pallie comme beaucoup le manque grâce à l’excellente librairie Guava par exemple, et ce n’est pas sans déplaisir que je vois l’arrivée de Java8 (dont de nombreux concepts sont déjà dans Scala).

 

Le moins :

– Certains exercices étaient plus “mathématiques” que “programmatique”, j’avais l’impression de retourner en prépa plus que d’apprendre un langage. On sent ici le côté académique de Odersky et je me demande si cela n’a pas rebuté un certain nombre de participants. Cela se sent aussi sur le langage en lui même, avec son système de type. Ce n’est pas le genre de chose qui m’intéresse outre mesure (que le système de type soit complet ou pas…), et certaines vidéos à ce sujet étaient moins intéressantes à regarder.

– Je me suis limité à utiliser l’IDE conseillé, un Eclipse packagé pour Scala. Et j’ai trouvé l’expérience horrible (je travaille pourtant très souvent sous Eclipse), l’IDE plantait régulièrement, la complétion était longue, les erreurs souvent obscures et lancer les tests était lent. Autrement dit je ne sais pas comment les équipes qui travaillent sur des projets conséquents se débrouillent pour être productives. Il est fort possible qu’il y ait eu un problème avec ma machine, mais j’ai un macbook avec jdk7 assez standard : j’imagine donc que d’autres peuvent avoir ce problème. J’ai vu que beaucoup utilisait TextMate, et IntelliJ pour certains, ce qui est certainement mieux mais pas toujours possible dans une entreprise. Et globalement tout est lent, la compilation, les tests, l’execution… TypeSafe fournit un gros travail à ce sujet mais il y encore du chemin à parcourir.

– J’ai souvent cherché des solutions alternatives une fois mes exercices rendus et je me suis rendu compte que même en connaissant très bien le problème, j’avais parfois du mal à comprendre celles-ci, tant les possibilités et styles peuvent varier. Je trouve ça assez inquiétant pour la maintenabilité d’une application, en tout cas si personne ne prend le temps de bien fixer certaines règles. La liberté amenée par Scala vient avec un prix de rigueur, Odersky le dit lui même dans ses vidéos, n’hésitez pas à nommer les résultats intermédiaires de vos programmes. Et c’est vrai que l’API donne parfois envie de chaîner les appels sur une ligne, il faut donc résister et accepter de perdre en “oneliner” pour gagner en lisibilté.

– Les boucles “for comprehension” sont un concept puissant mais on se retrouve vite perdu entre les types disponibles, les itérateurs déclarés et les filtres. Alors que le code executé est souvent simple, toute la logique se trouve dans la déclaration du for. C’est souvent compliqué à débugger, parfois correct mais incroyablement lent si vous avez fait un mauvais choix (dont on ne se rend pas toujours compte immédiatement). Pour les anagrammes j’avais par exemple une solution qui fonctionnait correctement mais qui mettait 30 secondes de plus pour un itérateur mal déclaré. Il doit y avoir des carnages dans certaines applications… Il est parfois plus simple de faire le code avec des “map” et des “filter” puis de convertir en “for comprehension” par la suite.

 

Si le sujet vous intéresse un autre article bien plus complet sur Scala et Coursera se trouve ici. Je ne peux qu’admirer l’excellence marketing de TypeSafe qui réussit encore une fois un très beau coup (après l’annonce récente de l’entrée de Rod Johnson au board par exemple). Et à titre personnel, je suis content d’avoir participer : j’ai appris de nouvelles choses et voir d’autres langages est toujours un excellent moyen de progresser. Je ne suis par contre toujours pas convaincu pour faire un vrai gros projet de la vraie vie avec. Ou alors avec un mec de chez Twitter ou Foursquare qui vient m’aider à démarrer et à prendre les bonnes options et les bonnes pratiques. Mais on en a rarement sous la main. Je surveille quand même du coin de l’oeil, on ne sait jamais…

À propos de Cédric Exbrayat

Cédric Exbrayat, développeur et fondateur Ninja Squad, se réunit avec ses semblables régulièrement que ce soit au Lyon JUG ou à Mix-it, dont il est le fondateur. Java et JS for food and fun.

Publié le 30/11/2012, dans Getting started, et tagué , , . Bookmarquez ce permalien. 7 Commentaires.

  1. Gaetan Zoritchak

    J’ai également suivi le cours intégralement, mais sans aucun autre support ou connaissance que le cours.

    Je suis complètement en phase avec toi sur les côtés positifs et négatifs.

    Je rajouterais dans les côtés positifs sur scala : le moteur d’inférence très puissant. Déclarer une variable sans la typer mais avec l’IDE et le compilateur qui comprennent bien de quoi il s’agit est très confortable.

    Dans les côtés négatifs, je trouve aussi que les générateurs peuvent se transformer en cauchemar. Sous prétexte d’avoir un code plus concis on passe parfois beaucoup plus de temps à l’écrire.

    Bref, depuis ce cours, je prends beaucoup de plaisir à écrire du code sous … kotlin😉

    • Pas encore essayé Kotlin. Vraiment bien?

      • Gaetan Zoritchak

        C’est vraiment à mi-chemin entre java et scala. Ce qui me plaît:
        – typage fort (pas de surprise au runtime)
        – moteur d’inférence permettant d’éviter de définir le type quand la compréhension ne le nécessite pas,
        – mise en avant du côté immutable avec des val (par opposition au var),
        – gestion très proches des collections et map (à la groovy) rendant leur utilisation plus facile qu’avec guava (fonction de map, de fold, …)
        – surcharge des opérateurs (sans possibilité de créer de nouveaux opérateur du genre ×> comme en scala)
        – high-order function
        – extension des classes java (comme en ObjectiveC) très pratique pour ajouter des fonctions manquantes dans un contexte donné
        – compilation javascript
        – bon support de l’IDE avec toutefois des problèmes de perf. Il faut parfois attendre 1 ou 2 secondes pour avoir la complétion ou la validation de l’ensemble du code édité.
        – définition de classes, de constructeur et de get/set très très light. Une classe peut se limiter à : data class Point(val x:Int, val y:Int). L’annotation data entraîne la génération automatique de equals,hascode, toString. Hyper pratique pour des ValueObject ou simplement du typage dans des calculs intermédiaires.

        Au final, on a un code beaucoup plus concis qu’en java et très lisible.

        Le choix de coller à java rend le langage moins pur que clojure. On a des objets et ils ne sont pas forcément immutables.

  2. Cédric, tu me connais, en réaction à ton post, je n’ai pas pu m’empêcher de me demander, après avoir maintenant du recul sur la prog. fonctionnelle en Clojure et en Scala (et aussi disons la prog. en général en Clojure et en Scala), si tu pouvais faire une analyse comparée, *ton* point de vue, en prenant les versions disponibles à un instant T (pas de projection sur le futur genre tel truc est prometteur, etc., juste ce qui marche aujourd’hui).

    En tant que développeur d’outil autour de Clojure, et de personne pouvant avoir une influence (modeste) sur le développement de Clojure, ce retour de ta part me serait très utile.

    • Question difficile! Je ne connais pas assez Clojure je crois. En scala le point qui rassure, c’est que tu retrouves plus ou moins ton Java en cas de problème. Clojure, je manque de repères, et je me retrouve bloqué par le côté pur fonctionnel par moment. Ca m’avait beaucoup fait progresser en programmation fonctionnelle de commencer à l’apprendre, et il faudrait que je m’y replonge, mais avec un vrai petit projet derrière. La marche est clairement moins haute pour démarrer en Scala. Niveau outils en revanche, je pense que Clojure n’a rien a envier à Scala. Niveau Eclipse tu le sais🙂
      Mais rien ne saurait concurrencer Scala en marketing et buzz, toutes qualités des langages mises à part… A part peut être un cours de Rich Hickey sur Coursera? Je serais preneur! On en discutera de vive voix la prochaine fois.

  3. Merci pour cet article

    J’ai suivi le cours et j’ai trouvé cela génial. C’est vrais qu’il y avait un coté académique et mathématique qui m’a projeté assez loin en arrière😉 mais pas sans plaisir.

    J’ai aussi appris plein de choses qui ne se limitent pas à l’usage de scala => Les stackoverflow sont tout aussi vraies quand on ne fait pas du tail récursif en java !

    J’ai trouvé le cours très bien construit. Une belle introduction au fonctionnel, scala n’était à mon avis qu’au second plan. Le développeur javascript y trouvera aussi du sens.

    Cela dit je suis resté un peu sur ma fin. En effet le cours ne donne pas l’autonomie suffisante pour faire des projets en scala où exploiter la stack typesafe.: Rien sur les collections parallèles, rien sur l’usage des variables (non ce n’est pas sale même en scala), rien sur les Futurs ou introduction à la stack (play2, akka, STM, Itératee…) bref il y a de la belle matière

    Pour le moment je mixe java et scala dans mes projets play2… Autant sur les controleurs, la gestions des futurs, les appels asynchrone ou les events akka je trouve scala bien plus simple; Autant sur les entités persistantes j’ai vraiment du mal avec l’approche immutable et je trouve JPA ou morphia tellement pratique !

    Martin Odersky annonce à la fin du cours une suite pour aller plus loin avec scala. j’attend cela avec impatience !

Laisser un commentaire

Entrez vos coordonnées ci-dessous ou cliquez sur une icône pour vous connecter:

Logo WordPress.com

Vous commentez à l'aide de votre compte WordPress.com. Déconnexion / Changer )

Image Twitter

Vous commentez à l'aide de votre compte Twitter. Déconnexion / Changer )

Photo Facebook

Vous commentez à l'aide de votre compte Facebook. Déconnexion / Changer )

Photo Google+

Vous commentez à l'aide de votre compte Google+. Déconnexion / Changer )

Connexion à %s

%d blogueurs aiment cette page :