Innovation Pédagogique
Institut Mines-Telecom

Une initiative de l'Institut Mines-Télécom avec un réseau de partenaires

PyRat – Un jeu sérieux pour l’enseignement de l’informatique

7 juillet 2017 par Karmann Retours d’expériences 649 visites 0 commentaire

Un article publié au IXe Colloque des Questions de Pédagogie dans l’Enseignement Supérieur, Grenoble, 13 , 14, 15 et 16 Juin 2017.


Résumé

L’enseignement de l’informatique, et plus précisément de l’algorithmique et de la programmation, n’est pas une chose aisée en première année d’école d’ingénieur. L’hétérogénéité des provenances et des formations antérieures entraîne de fortes disparités dans les niveaux et dans les attentes des étudiants, rendant difficile la définition d’un enseignement adapté à tous. Il en résulte de nombreux échecs ainsi qu’un désintéressement global pour l’informatique. Face à ce constat, nous avons mis en place à la rentrée 2015 un cours à trois vitesses novateur, basé sur un jeu sérieux : PyRat. Ce retour d’expérience détaille nos idées ainsi que leur mise en place, et présente nos premiers résultats concernant l’impact de ce nouvel enseignement sur les résultats et la motivation des étudiants.

Summary

Computer science, and particularly algorithmics and programming, is not easy to teach in first year of engineering school. Due to a wide variety of origins and previous formations, there is a large inequality in backgrounds and expectations of the students. This makes creating a course adapted to everyone difficult. A consequence is a high number of failures and a global disinterest in computer science among the students. In the face of such challenges, we have set up for the 2015 school start a novel three-speed course based on a serious game : PyRat. This feedback details our ideas and how they were realized. It also introduces our first results concerning the impact of this new course on the results and motivations of students.

Mots-clés : Jeu sérieux, hétérogénéité, informatique, retour d’expérience

Bastien Pasdeloup, Marine Karmann

IMT Atlantique,655 Avenue du Technopôle, 29200 Plouzané

marine.karmann [at] imt-atlantique.fr


1. Introduction

1.1. Contexte
La réforme de l’enseignement en classes préparatoires aux grandes écoles (CPGE) de 2013 a induit de nombreux changements, notamment concernant l’informatique (Ministère de l’enseignement supérieur et de la recherche, 2013) qui est devenue une matière à part entière. Ces changements ont entre autres permis une modernisation des notions étudiées, mais aussi des outils. Le langage Python a ainsi supplanté le Caml, car plus simple à appréhender et plus répandu dans le monde industriel (Diakopoulos et Cass, 2016).
Avant cette réforme, à Télécom Bretagne , l’enseignement en informatique revêtait alors une forme classique, sous forme d’un triplet cours magistral / travaux dirigés / travaux pratiques, où la programmation était enseignée à travers des exemples d’implémentation de structures de données classiques, à l’aide du langage C. Ce langage a la particularité d’être très performant, car prenant en compte des éléments de l’architecture matérielle des ordinateurs. Pour cette raison, le C est très utilisé dans le monde industriel, et fait donc partie du bagage standard d’un étudiant en école d’ingénieur. Toutefois, un constat fait par les enseignants de Télécom Bretagne était que les caractéristiques très bas niveau (au sens de la proximité avec la machine) de ce langage constituaient un bruit qui empêchait les étudiants de saisir les concepts plus abstraits de l’informatique. Ce constat était encore plus important concernant les étudiants n’ayant pas suivi un cursus CPGE avant d’intégrer l’école. Il en résultait un désintéressement pour l’informatique, causant un échec de l’obtention des crédits ECTS associés pour près de 35 % des étudiants au premier semestre à l’école. Ce constat, bien connu de la recherche en didactique de l’informatique, ne vient que confirmer les résultats de nombreuses études qui concluent que « pour différentes raisons, l’apprentissage des fondamentaux de la programmation est une tâche difficile, en particulier pour les novices » (Muratet et al., 2011). Ce phénomène se traduit chez les étudiants par un manque de compétences en programmation en fin de première année d’études en informatique (Fincher et al., 2004).

1.2. Objectifs du cours
Les premiers étudiants ayant suivi le cursus post-réforme intégrant l’école à la rentrée 2015, il fut décidé de préparer pour l’occasion un nouvel enseignement pour l’informatique au premier semestre, respectant les contraintes suivantes :

  • Le nouveau cours devrait favoriser l’intéressement des étudiants à l’informatique, et réduire les échecs à la fin du semestre ;
  • Il devrait être adapté à un public hétérogène, pouvant provenir de CPGE (près de 80 % des étudiants), mais aussi d’universités, DUT, BTS, etc. Il devrait de plus s’adapter à la dimension interculturelle importante de l’école, considérant que près de la moitié des étudiants proviennent d’écoles étrangères ;
  • La charge de travail des enseignants hors-séance devrait être minimale ;
  • Le coût du nouveau cours devrait rester le même que l’existant ;
  • Le temps de travail des étudiants serait aussi important en présentiel qu’en autonomie.

Comme nous l’avons noté, la principale difficulté rencontrée par les enseignants dans la refonte de ce cours a été d’assurer et d’encourager la motivation des étudiants face à une tâche à priori rébarbative. « Une approche possible consiste à utiliser la culture vidéoludique des étudiants pour les motiver à travers le jeu » (Muratet et al., 2011). Pour susciter cette motivation et respecter les contraintes pré-citées, nous avons mis en place un cours basé sur le langage Python à travers un logiciel ludo-éducatif (voir par exemple Sanchez et al., 2011) créé pour l’occasion : PyRat. Ce format, privilégié par les enseignants parmi les autres solutions possibles (classes inversées, MOOC, etc.) a été choisi pour plusieurs raisons :

  • Si le langage Python permet de capitaliser sur les acquis de CPGE issus de la réforme, il est aussi très simple à appréhender, et en fait un langage idéal pour l’apprentissage de la programmation pour des personnes sans expérience ;
  • L’utilisation d’un jeu comme support permet de motiver les étudiants. En effet, les notions vues en cours peuvent être directement mises en pratique de manière ludique ;
  • Une plateforme logicielle donne la possibilité de monitorer les étudiants en temps réel, et de fournir une synthèse des problèmes rencontrés à l’enseignant, par étudiant ou pour le groupe. Cet aspect n’est à l’heure actuelle pas intégré au logiciel, mais fait partie des évolutions à venir.

Le cours a été façonné autour de cette plateforme logicielle sous forme de leçons donnant les clés pour atteindre des objectifs dans le jeu, donnant ainsi autant d’importance aux heures hors séances qu’à celles en présentiel. La section 2 présente ces enseignements, ainsi que la plateforme logicielle et le système d’évaluation. La section 3 fournit des statistiques et retours quant à l’impact du cours sur les étudiants. Enfin, la section 4 conclut cet article.

2. Présentation du cours

2.1. Le logiciel PyRat
Comme énoncé précédemment, PyRat est un cours basé sur un jeu sérieux. Celui-ci prend la forme d’un labyrinthe, dans lequel sont placés des pions (un par joueur), ainsi que des morceaux de fromage. Passer d’une case du labyrinthe à une autre case adjacente coûte un mouvement sauf si celles-ci sont séparées par de la boue, auquel cas le nombre de mouvements nécessaires est spécifié.
Le but du jeu est de ramasser plus de fromage que son adversaire en écrivant un programme pour déplacer son pion. Selon la configuration du logiciel, il est possible de proposer d’autres objectifs, comme par exemple ramasser un unique morceau de fromage, ou minimiser les déplacements.
Plus en détail, le logiciel PyRat peut être découpé en trois grands groupes :

  • Les lanceurs : ce sont des programmes Python de quelques lignes qui définissent une configuration pour le labyrinthe à travers des constantes (dimensions, densité de murs, nombre de morceaux de fromages, symétrie du labyrinthe…), et démarrent une partie avec ces paramètres via un simple appel à une fonction. Un exemple de lanceur est donné en annexe de cet article ;
  • Les programmes joueurs : ce sont des bibliothèques Python, constituées de très peu d’éléments : une variable représentant le nom du joueur, une fonction preprocessing décrivant les calculs à effectuer en début de partie, et une fonction turn appelée à chaque tour de jeu afin de déterminer le mouvement à effectuer par le pion ;
  • Le logiciel PyRat : cet ensemble inclut entre autres la génération aléatoire de labyrinthes, la gestion des scores, l’affichage, etc.

Le troisième groupe contient la mécanique du logiciel dont les étudiants n’ont pas besoin de connaître les détails. En revanche, ils interviennent sur les deux autres groupes, et principalement sur les programmes joueurs, qui implémentent leurs stratégies pour répondre aux objectifs du cours. Une fois leurs programmes fonctionnels, ils peuvent ensuite évaluer leurs performances grâce à des lanceurs adaptés. Il est ainsi possible, par exemple, de lancer un grand nombre de parties aléatoires, et de générer un graphique étudiant le nombre moyen de mouvements nécessaires pour remplir un objectif en fonction de la taille du labyrinthe.
Une partie du jeu PyRat consiste en sept étapes :

  1. L’étudiant exécute un lanceur qui décrit la partie et démarre le logiciel ;
  2. Le logiciel PyRat crée un labyrinthe selon ces paramètres, initialise les scores, les positions des joueurs et des fromages, puis il communique ces informations aux programmes joueurs via la fonction preprocessing ;
  3. Un temps est alloué aux joueurs pour effectuer des calculs ;
  4. Le logiciel PyRat envoie les informations à jour (positions des joueurs, fromages restants, etc.) aux programmes joueurs via la fonction turn ;
  5. Un temps est alloué aux joueurs pour décider du prochain mouvement à effectuer ;
  6. Les décisions des programmes joueurs sont appliquées afin de déplacer les pions dans le labyrinthe. Puis, s’il reste des morceaux de fromage, la partie reprend à l’étape 4 ;
  7. Une fois la partie terminée (tous les morceaux de fromages ramassés), le logiciel PyRat affiche le joueur gagnant, et renvoie des informations sur la partie au lanceur.

Le temps alloué aux différentes phases de jeu (pré-traitement et tours) est paramétrable dans le lanceur. Il est donc possible de laisser un court temps aux programmes joueurs pour prendre une décision, par exemple pour sensibiliser les étudiants à la notion de complexité des algorithmes. En effet, si un programme ne renvoie pas de décision dans le temps imparti, il passe son tour et se retrouve désavantagé par rapport à un adversaire qui aurait respecté les échéances temporelles. Le paramétrage inverse est possible pour rendre les décisions des programmes joueurs simultanées, et leur laisser un temps d’exécution arbitrairement long.

2.2. Le contenu du cours
Le cours a été découpé en sept leçons de trois heures, chacune correspondant à un objectif à atteindre. Ce nombre de séances a été contraint par le volume horaire associé au cours.
Chaque leçon du cours PyRat revêt la même forme. Les dix premières minutes sont consacrées à une interrogation simple, type questionnaire à choix multiples (voir section 2.3). La première heure est ensuite un cours classique introduisant un nouvel objectif, et présentant les outils pour l’atteindre, toujours sous la forme « description du problème, résolution par des algorithmes, implémentation par des programmes ». S’en suit une partie projet, durant laquelle les étudiants créent un programme joueur afin d’atteindre l’objectif du cours à travers le logiciel PyRat. Durant cette partie pratique, l’enseignant guide les étudiants et aide au démarrage du projet. Un créneau de trois heures en autonomie est ensuite programmé à l’emploi du temps pour laisser les étudiants terminer le travail.
Les notions vues en cours sont de difficulté croissante. Après un premier cours consacré à la prise en main du logiciel, nous avons choisi de présenter aux étudiants les objectifs suivants :

  1. Ramasser un unique morceau de fromage dans un labyrinthe ;
  2. Réaliser l’objectif 1. en effectuant un nombre minimal de mouvements ;
  3. Réaliser l’objectif 2. dans un labyrinthe contenant de la boue ;
  4. Ramasser plusieurs morceaux de fromage en minisant le nombre de mouvements ;
  5. Comme répondre à l’objectif 4. demande de longs calculs (de l’ordre du siècle), sacrifier légèrement l’optimalité du résultat pour gagner du temps ;
  6. Choisir une stratégie pour battre un adversaire. Un tournoi (non noté) est organisé entre l’ensemble des groupes en fin de module afin de motiver les étudiants.

Au delà de la simple réalisation d’objectifs, l’étude de ces problèmes permet de mettre en avant d’autres aspects de l’informatique (comme les notions de complexité, de terminaison, etc.), mais aussi du métier d’ingénieur. En effet, ces algorithmes peuvent être utilisés par exemple pour minimiser le trajet parcouru par un bras mécanique, ou pour un système GPS.
Nous ne détaillerons pas tout l’enseignement ici, mais le contenu est disponible en ligne (http://formations.telecom-bretagne.eu/pyrat/) sous la forme d’une plateforme Wordpress complétant les séances. Un tel système de blog a de nombreux intérêts comparé à un support papier dans l’appréhension de l’hétérogénéité des étudiants :

  • Il fournit à l’étudiant un outil pour poser anonymement des questions sur le cours ;
  • Des exemples de programmes informatiques directement exécutables peuvent être fournis à titres d’exemples pour illustrer les notions de manière interactive ;
  • Il est possible de corriger d’éventuelles erreurs très rapidement ;
  • L’étudiant peut passer naviguer entre les notions, et étudier à son propre rythme.

2.3. Le système d’évaluation

2.3.1. Le système de couleurs
Les étudiants suivant le cours n’ayant pas le même bagage de connaissances en arrivant à l’école, nous avons choisi de proposer un cours à trois vitesses. Ainsi, chaque fiche sur le blog support de cours est découpée en trois grandes sections, représentées par des couleurs :

  • Les notions en vert sont celles que nous jugeons essentielles pour tout étudiant de l’école. Valider l’ensemble des questions vertes permet l’obtention de la moyenne ;
  • Viennent ensuite des notions colorées en bleu. Elles sont plus complexes à appréhender, et représentent ce que nous attendons d’un étudiant à la sortie du cours ;
  • Enfin, une section rouge regroupe des liens vers des supports tels que des pages Wikipédia ou des papiers de recherche. L’idée est de permettre aux étudiants intéressés d’explorer en autonomie des notions avancées en lien avec le cours.

Ce système de couleurs permet aux étudiants d’explorer plus en détails certaines notions qui les intéressent plus que d’autres, tout en étant conscient du minimum attendu. Il est donc possible pour un étudiant en difficulté de se concentrer sur l’essentiel, alors qu’un étudiant ayant plus de facilités pourra approfondir le cours selon ses envies.

2.3.2. Les évaluations écrites
Les évaluations prennent deux formes. La première est un contrôle écrit régulier, sous la forme d’un questionnaire à choix multiples en début de cours. L’objectif est ici de s’assurer que les notions sont acquises régulièrement, mais aussi d’imposer une présence en cours.
Les questions sont simples et concernent uniquement les parties vertes et bleues du cours. Les étudiants disposent de dix minutes pour y répondre, et les questions bleues ne sont validées que si les vertes le sont toutes du premier coup. Dans le cas contraire, une seconde chance est offerte aux étudiants. L’enseignant corrige les interrogations pendant une pause entre les parties cours et projet, et les rend directement aux étudiants. Ceux-ci disposent ensuite du reste du cours pour comprendre et venir expliquer leurs erreurs aux questions vertes à l’enseignant, qui pourra les valider. Ils ont pour cela accès à toutes les ressources disponibles.

2.3.3. Les évaluations orales
Si les évaluations écrites forcent la régularité du travail, les évaluations orales se concentrent sur la compréhension des notions, ainsi que sur l’implication et l’autonomie. Aux cours trois et six, l’enseignant effectue de brefs entretiens avec les étudiants pendant la partie projet. Pendant cinq minutes, les étudiants doivent présenter leurs travaux issus des parties projet.
L’objectif de ce format d’évaluation est de faire prendre du recul aux étudiants sur leur travail, en mettant en avant les spécificités de leurs choix d’algorithmes et d’implémentations, leurs avantages et leurs limites. La notation de ces évaluations orales est simple : si les programmes fonctionnent et ont été testés par les étudiants, le niveau vert est validé. Si les étudiants présentent des aspects intéressants de leurs programmes via des analyses adaptées, le niveau bleu est validé. Enfin, les évaluations orales donnent aussi la possibilité aux étudiants de valider le niveau rouge, en présentant des notions jugées au-delà des attentes par l’enseignant.
Contrairement aux évaluations écrites qui sont individuelles, les évaluations orales se font en binômes. Nous avons choisi d’imposer des binômes de niveaux homogènes pour maximiser l’implication des étudiants, au sein de classes hétérogènes pour favoriser l’entraide.

3. Évaluation du dispositif

Les premiers retours du cours semblent montrer que les objectifs initiaux sont atteints. Sur les deux années où le cours a été joué, nous avons obtenu les résultats suivants :

  • Désintéressement, échec : Le nombre d’étudiants ne validant aucun crédit en informatique au premier semestre est passé de 35 % à environ 11 %. De plus, 80 % des étudiants ont préféré ce cours à un format plus classique. L’idée de participer à un tournoi a motivé plus de 60 % des étudiants à programmer (environ 20 % neutres et 20 % réticents). Enfin, les enseignants en informatique au second semestre ont constaté une augmentation de l’attrait des étudiants pour le domaine ;
  • Gestion de l’hétérogénéité : Les retours montrent que tous les étudiants, quel que soit leur niveau initial, ont progressé. Les système de cours à trois vitesses a plu aux étudiants, mais il semble nécessaire d’ajouter au cours un tutoriel de base sur Python ;
  • Charge de travail des enseignants : Les évaluations courtes corrigées pendant le cours, ainsi que le blog, limitent grandement la charge des enseignants entre les séances ;
  • Coût du cours : Le nombre d’enseignants est plus important (petites classes), mais il s’étend moins sur la durée. Le coût total est identique à l’existant. Concernant la mise en place, la programmation du logiciel PyRat, ainsi que la création des documents de cours, ont demandé un investissement temporel de trois mois-hommes environ ;
  • Temps hors-présentiel : le découpage en objectifs réguliers met à profit le temps attribué au travail hors-séances.

Ces résultats sont encourageants, et nous avons eu de nombreux retours d’étudiants, qui ont permis de cerner les points forts et points faibles du cours. Notre démarche est de faire évoluer le cours d’une année sur l’autre pour mieux l’adapter aux spécificités des étudiants.

4. Conclusion

Dans cet article, nous avons présenté un cours innovant mis en place il y a maintenant deux ans. Ce cours se base sur un jeu sérieux permettant l’apprentissage de l’informatique via une suite d’objectifs à atteindre en programmant les déplacements d’un rat dans un labyrinthe. Parmi les contraintes de mise en place du cours, l’hétérogénéité des étudiants en première année a guidé nos choix vers un cours à trois vitesses, permettant ainsi aux étudiants ayant des facilités de progresser en autonmie, tout en gardant ceux plus en difficulté à niveau.
Les premiers retours sur le cours sont très encourageants, particulièrement concernant l’intéressement des étudiants, qui pour 80 % d’entre eux ont préféré ce format à un cours classique. Les nombreux avis d’étudiants ont aussi permis de mettre en avant des faiblesses du cours, comme le besoin d’un cours plus formel sur Python en début d’année.
Ainsi, l’expérimentation autour du projet PyRat nous montre que ce qu’énonce Stamm (2007), « […] Les étudiants novices en informatique trouvent souvent la discipline théorique, technique, ou ennuyeuse », peut être contré avec succès par une approche vidéoludique visant la motivation, l’autonomie et la différenciation des objectifs d’apprentissage.

Remerciements

Les auteurs voudraient remercier les autres personnes ayant contribué à la mise en place de PyRat à Télécom Bretagne, à savoir Vincent Gripon, Philippe Picouet, Antoine Beugnard, Patrick Meyer et Grégoire Mercier, ainsi que tous les enseignants ayant participé au cours ces deux années. Enfin, merci à Lauren Lefumeur-Pasdeloup pour la réalisation des images utilisées dans le logiciel PyRat.

Références bibliographiques

Diakopoulos, N. et Cass, S. (2016). Interactive : the top programming languages 2016. Repéré à http://spectrum.ieee.org/static/interactive-the-top-programming-languages-2016

Fincher, S. et Petre, M. (2004). Mapping the territory. Computer Science Education Research.

Ministère de l’éducation nationale, de l’enseignement supérieur et de la recherche. (2013). Bulletin officiel spécial n°3 du 30 mai 2013 (Publication n°ESRS1306084A). Repéré à http://www.education.gouv.fr/pid25535/bulletin_officiel.html?cid_bo=71586

Muratet, M., Torguet, P., Viallet, F. et Jessel, J-P. (2001). Evaluation d’un jeu sérieux pour l’apprentissage de la programmation. Revue des sciences et technologies de l’information. Série RIA : revue d’intelligence artificielle, 25(2), 175–202.

Sanchez, E., Ney, M. et Labat, J-M. (2011). Jeux sérieux et pédagogie universitaire : de la conception à l’évaluation des apprentissages. Revue internationale des technologies en pédagogie universitaire, 8(1–2), 48–57.

Stamm, S. (2008). Mixed nuts : atypical classroom techniques for computer science courses. Crossroads The ACM Student Magazine, 14(4).

Annexes

Figure 1. Exemple de lanceur pour PyRat. Ce programme Python prend en argument un programme joueur, et démarre une partie sur un labyrinthe carré non-symétrique à onze cases de côté, contenant cinq morceaux de fromages. Le temps alloué à la fonction preprocessing est de trois secondes, et celui alloué à la fonction turn est de une déciseconde.

Figure 2. Exemple d’une partie pour PyRat. Ici, deux programmes joueurs s’affrontent dans un labyrinthe symétrique contenant de la boue. L’objectif est de ramasser plus de morceaux de fromage que l’adversaire.

Licence : Pas de licence spécifique (droits par défaut)

Répondre à cet article

Qui êtes-vous ?
Ajoutez votre commentaire ici
  • Ce formulaire accepte les raccourcis SPIP [->url] {{gras}} {italique} <quote> <code> et le code HTML <q> <del> <ins>. Pour créer des paragraphes, laissez simplement des lignes vides.

Suivre les commentaires : RSS 2.0 | Atom