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 Mooc, Massive 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 !!!!
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.