Publié par
Il y a 6 années · 6 minutes · Java / JEE

Retour sur les bancs de l’école avec Coursera

Nous vous en parlions il y a quelques semaines dans notre revue de presse. Martin Odersky propose gratuitement, sur Coursera, une introduction à la programmation fonctionnelle à l’aide de Scala, le langage dont il est le père. Une dizaine de Xebians s’est inscrite et une folle course de huit semaines s’en est suivie. La session est désormais terminée, il est grand temps d’en faire le bilan.

Notez que ce bilan ne contient pas les solutions aux différents exercices. En effet, comme chaque étudiant, nous avons accepté le code d’honneur de Coursera qui nous interdit de les dévoiler. Ce type d’initiative est remarquable en soi, et c’est par respect pour le travail des participants, auteurs comme étudiants, que nous nous y conformons.

Coursera

Coursera est un site qui propose des cours en ligne gratuitement. Et comme tout le monde a le droit à son acronyme, on peut dire que Coursera fait partie de la vage MoocMassive Open Online Course. En partenariat avec plusieurs universités à travers le monde, il propose une large gamme de formations dans plusieurs domaines : médecine, physique, économie, informatique, littérature, histoire…

Le site regroupe les cours par catégorie et par université. Une fois son compte créé, libre à vous de vous inscrire aux cours que vous souhaitez. 

Un cours est généralement composé de plusieurs modules, un par semaine. Chaque module contient un examen avec une note. A la fin de la session, si les critères d’obtention sont remplis, l’université rattachée à la formation nous délivre un certificat ! 

Les cours des modules sont disponibles sous la forme : 

  • de cours au format vidéo (streaming ou en téléchargement)
  • des diaporamas de support de cours
  • un forum d’entraide entre élèves
  • un wiki propre à chaque session regroupant toutes les informations

Petite précision, la très grande majorité des cours sont en anglais. Quelques initiatives en français commencent à voir le jour, comme par exemple celui-ci pour la programmation orientée objet.

Alors que les ressources de cours sont toujours disponibles après leur date de publication, il y a un temps imparti pour remplir les examens. Vous pouvez suivre un cours trois mois après sa date de sortie sans problème. Par contre, il n’y aura pas possibilité de se faire évaluer.

C’est pour cette raison que les solutions des exercices ne seront jamais données. C’est assez frustrant.

Programmation fonctionnelle

Ce cours était une initiation à la programmation fonctionnelle illustrée avec Scala, mais pas un cours sur le langage Scala.

Quelques grands principes ont été abordés :

  • les fonctions (simples ou d’ordre supérieur)
  • l’immuabilité
  • la récursion
  • les structures de données et les collections
  • for-comprehension

Les vidéos ont une durée d’environ dix minutes en moyenne, avec environ six vidéos par semaine. A partir d’exemples souvent très académiques, Martin nous explique ces grands concepts du langage et de la programmation fonctionnelle. Le débit est soutenable et les explications claires. 

Lors de la dernière session sur les Stream (suite d’éléments évaluée tardivement), Martin propose une résolution du "Water Pouring Problem" d’une façon très élégante. C’est le seul exemple concret de la session. Dommage !

L’investissement personnel est dans la moyenne de quatre à cinq heures par semaine. L’avant-dernière session sur les anagrammes a quant à elle demandé beaucoup plus de travail que les autres. Globalement, cela respecte ce qui était prévu. 

Chaque module est accompagné d’un exercice. Il y a une limite de dix jours pour le rendre à compter de la date de sortie du module. Pour chaque jour de retard, on perd 20% de la note maximale. 

Pour soumettre un exercice, une tâche dans SBT a été créée par l’équipe pédagogique. L’exercice est alors évalué automatiquement. Dans les 10 minutes qui suivent, la note tombe avec quelques retours. Il est possible de soumettre plusieurs fois le même exercice. La note la plus élevée est conservée au final. 

Une série de tests unitaires privés à l’équipe pédagogique est lancée pour tester notre code. Chaque test qui ne passe pas fait perdre des points. En retour, nous n’avons que la stacktrace ainsi que le nom du test pour comprendre nos erreurs. Il est très frustrant de ne pas avoir accès au code des tests pour tenter de s’améliorer.

Côté outillage, proposer Eclipse et son plugin Scala Worksheet est une très bonne idée, aussi bien pour les exercices que les démonstrations en vidéo. C’est un très bel outil !

Résultats des cours et impressions personnelles

Selon Martin Odersky, 50 000 étudiants à travers le monde se sont inscrits à ce cours. Cela représente un bel amphi ! Selon les premiers résultats, 20% des étudiants ont réussi les examens (en ayant au minimum 60% des points totaux). Je vous propose une retrospective personnelle de ce cours sous la forme du Mad, Glad, Sad :

Mad

Les traces issues d’exceptions en résultat des tests privés de l’équipe pédagogique. Ne pas avoir le code m’a souvent ralenti dans la compréhension de mes erreurs.

Il n’y a pas encore de debugger adapté à Scala sous Eclipse. Par exemple, la fonction Watch ne fonctionne pas. J’ai sans doute perdu l’habitude de résoudre des problèmes d’algorithme sans regarder son fonctionnement. Les piles d’appels remplies d’appels à des classes anonymes font vite perdre la tête.

Sad

Les exercices étaient à base de code avec des trous à remplir. Il était parfois plus compliqué de comprendre la conception de l’exercice plutôt que de coder la fonction. En même temps, vouloir exécuter des tests automatisés pour les notations et ne pas imposer de signatures, cela devient un vrai défi !!!!

Je suis resté cependant sur ma faim. J’aurais aimé voir comment exploiter l’immuabilité et la programmation orientée fonction pour travailler plus facilement en parallèle. Mais la bonne nouvelle est que c’est annoncé pour la prochaine session. Reste à savoir quand elle sera programmée. Feront aussi partie du programme l’écriture de DSL et la mutabilité des objets dans le code. Vivement la prochaine session!

Glad

Cette même frénésie tous les mardis midi, date de publication des cours, pour regarder les cours et tenter d’avoir son 10/10 avant ses collègues ! C’était dans l’ensemble très fun.

J’ai trouvé ce cours très intéressant et agréable à suivre. Il reprend vraiment les bases de la programmation fonctionnelle sans dire une seule fois le mot Monade ! On est aussi sûr que le langage est utilisé correctement avec un professeur aussi approprié !

J’ai surtout apprécié d’être obligé de reprendre un papier et un crayon pour faire des schémas d’algorithmes. Et c’est bon ! C’est un besoin que je sens moins fort en impératif. En Java, il est facile de commencer par faire une boucle, de créer des variables, de les modifier dans tous les sens avec des différentes conditions pour arriver au résultat. En Scala, se lancer dans l’écriture d’une ligne de code sans savoir exactement ce que l’on veut s’annonce périlleux. Il faut renouer avec la conception et savoir bien formuler les règles métiers.

J’ai aimé apprendre à appréhender certains problèmes avec un oeil nouveau ! C’est rafraîchissant et très enrichissant.

 

Xavier Bucchiotty
Software Engineer Scala Fanboy FP constant learner Akka trainer

3 thoughts on “Retour sur les bancs de l’école avec Coursera”

  1. Publié par Sebastien Lorber, Il y a 6 années

    Hello,

    Pour ceux qui se demanderaient à quoi ressemble le certificat:
    http://sebastien.lorber.free.fr/Scala.pdf

    Pour ma part c’était un peu tendu vu que je faisais le cours de machine learning en même temps :) Pour info les cours ont tous l’air d’avoir une forme différente avec un système de notation propre.

    C’est vrai que le debug Scala est parfois délicat.
    Et c’est un peu dommage de ne pas publier tous les tests, car parfois l’output de correction ne nous aide pas vraiment…

    J’ai trouvé que le sujet sur les streams était vraiment intéressant et j’ai hate de poursuivre, car on ne voit dans ce cours qu’une partie de Scala avec une approche vraiment fonctionnelle. Mais c’était pas plus mal, car une fois sorti de l’école on a plus trop l’habitude de faire des récursions complexes…

    Petite « astuce » pour l’immutabilité, pas abordée dans le cours mais importante a connaitre: sur chaque case class il y a une methode copy, qui permet de créer une nouvelle instance updatée à partir de la case class originale. J’ai perdu pas mal de temps sur un projet car je ne la connaissais pas… Pour les grappes d’objets complexes, on peut utiliser les Lenses qui sont implémentés dans Scalaz (ps: c’est pas hyper compliqué).

  2. Publié par Lima, Il y a 4 années

    je suis très intéressé par ces cours et je souhaite m’inscrire.
    merci

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *