Introduction #

Dans ce manuel, nous proposons une approche pour enseigner la programmation avec des cartes à jouer. Les étudiant·e·s seront invité·es à réaliser une procédure informatique avec des cartes, avant de programmer cette procédure en Java et, puis de valider leur code à l’aide d’un logiciel créé spécifiquement pour accompagner ce manuel.

Nous utilisons ensuite cette approche pour expliquer les notions d’efficacité (complexité des algorithmes) et de structure de données (en particulier les listes, les arbres et les mappages).

À qui s’adresse ce manuel ? #

L’approche développée dans ce manuel cible des étudiant·e·s ayant déjà suivi un cours d’introduction à la programmation, mais qui pourraient éprouver certaines difficultés à :

• Imaginer les étapes exactes d’une procédure informatique.
• Imaginer comment les données du programme sont organisées en mémoire.
• Réfléchir à l’efficacité du programme.
• Distinguer les notions d’interface (ce que le programme doit faire) et d’implantation (comment le programme le fait).

Comme les exemples de code sont en Java, il est préférable d’avoir une certaine familiarité avec ce langage (ou avec un langage similaire comme C#).

Pourquoi utiliser des cartes à jouer ? #

L’idée est d’utiliser un médium physique pour expliquer des notions de programmation, afin de répondre à différents styles d’apprentissage (visuel, kinesthésique) et d’encourager les étudiant·e·s à bien comprendre le déroulement d’une procédure informatique avant même de commencer à la programmer.

Les cartes à jouer sont avantageuses parce qu’elles sont accessibles et peu coûteuses. P. ex. il est facile de se procurer des cartes surdimensionnées pour expliquer des notions informatiques devant la classe de façon très visuelle.

Crédit photo : Mikael Tardif

Un autre avantage est qu’on peut vérifier la compréhension des étudiant·e·s dès la période de théorie, sans même avoir besoin d’ordinateurs. Dans l’exemple ci-dessous, on spécifie visuellement une opération à effectuer sur une liste de cartes. Cette opération consiste à déplacer une carte (identifiée par un marqueur) au début de liste, ce qui nécessite en retour de décaler certaines cartes vers la droite.

On peut demander aux étudiant·e·s d’effectuer cette opération avec des vraies cartes, permettant ainsi à l’enseignant·e de vérifier que l’énoncé a bien été compris (c.-à-d. l’interface, ou ce que le programme doit faire).

On peut ensuite présenter une procédure afin de réaliser l’opération (c.-à-d. l’implantation, ou comment le programme doit le faire). Dans l’exemple ci-dessous, on utilise une procédure qui parcourt la liste du début vers la fin (ce qui correspond au genre de boucle que les étudiant·e·s ont probablement déjà appris). Encore une fois, les étudiant·e·s pourront réaliser la procédure sur la table, avec de vraies cartes, et ainsi s’assurer de comprendre ce qu’il faut programmer avant même d’écrire les premières lignes de code.

Finalement, à noter les animations ci-haut sont tirées de l’outil de validation qui accompagne ce manuel. Grâce à cet outil, les étudiant·e·s peuvent valider leur programme, en particulier :

• Visualiser les étapes d’exécution de leur code.
• Vérifier que leur code arrive au bon résultat.

Expliquer l’efficacité des algorithmes avec des cartes #

Une fois les étudiant·e·s habitué·es à réaliser des procédures avec les cartes à jouer, on peut passer à expliquer la notion d’efficacité (complexité des algorithmes), c.-à-d. comment différentes procédures informatiques peuvent accomplir la même opération (arriver au même résultat), tout en nécessitant un nombre d’étapes significativement différent.

On distingue ainsi entre les procédures naïves (souvent plus faciles à comprendre, mais peu efficaces) et les procédures efficaces (souvent plus difficiles à comprendre, mais plus rapides à réaliser). P. ex. pour une liste de 10 cartes, ordonner les cartes avec une procédure naïve de tri nécessitera une centaine étapes, alors qu’une procédure efficace de tri arrivera au même résultat en une trentaine d’étapes.

En effectuant diverses procédures sur la table, avec des vraies cartes à jouer, les étudiant·e·s gagnent une compréhension très intuitive de la notion d’efficacité informatique: les procédures naïves se révèlent rapidement comme longues et ennuyantes à réaliser!

Expliquer les structures de données avec des cartes #

Finalement, on peut aussi se servir de cartes à jouer afin de visualiser l’organisation des données dans un programme informatique, ce qui est particulièrement intéressant utile pour expliquer comment une structure de données, comme une liste, peut être implantée de différentes façons dans un langage de programmation.

En s’appuyant sur la notion d’efficacité, on peut aussi expliquer les avantages et inconvénients de ces différentes implantations. P. ex. une liste implantée par références (liste chaînée) sera moins efficace qu’une liste implantée par tableau au moment de visiter une valeur mémorisée au milieu de la liste. Par contre, la liste par référence utilisera moins d’espace en mémoire.

On peut visualiser ce dernier point assez concrètement avec des cartes à jouer, surtout si on utilise des cartes blanches (ou le verso de cartes) pour visualiser l’espace mémoire vide (c.-à-d. l’espace occupé par le programme, mais dans lequel le programme n’a pas encore mémorisé de valeur). Une procédure utilisant beaucoup d’espace mémoire va tout simplement nécessiter plus d’espace sur la table !

Plan du manuel #

Annexes #