Dans cet article, mon but est de donner les clés de la création d’exerciseurs avec le logiciel de géométrie dynamique GeoGebra. Je me suis, depuis plusieurs années, spécialisé dans la création de ce genre d’exercices, notamment au sein de la Commission Inter IREM TICE (c2it), dont je suis membre et qui en produit et diffuse un grand nombre (plus de 600 exerciseurs sur la page dédiée du site de la commission). J’ai déjà publié un tutoriel qui balaye quelques possibilités pour créer un tel fichier, il est disponible sur le site de la c2it ainsi que sur mon site. Il donne quelques clés très utiles pour débuter et comprendre les grands principes. Mais je souhaite ici aller bien plus loin en explicitant toutes les étapes pour créer un exerciseur totalement fonctionnel et plus élaboré.

 Préambule

  De quoi parle-t-on ?

Je désigne dans cet article par « exerciseur » un exercice numérique (à faire sur un ordinateur ou une tablette) autocorrectif dont les données (valeurs numériques ou graphiques) sont générées aléatoirement : lorsque l’élève valide une construction ou un calcul, un message apparaît, lui signifiant son succès ou son échec avec une justification plus ou moins détaillée.

  Des exerciseurs pour quoi faire ?

Il s’agit principalement de faire travailler les élèves sur certains automatismes : des tâches plus ou moins élémentaires que les élèves doivent exécuter et réussir de plus en plus rapidement. Cela correspond à l’application de la recommandation 9 du rapport Villani – Torossian (21 mesures pour l’enseignement des mathématiques) :

Automatismes [M12]
Développer les automatismes de calcul à tous les âges par des pratiques rituelles (répétition, calculs mental et intelligent, etc.) pour favoriser la mémorisation et libérer l’esprit des élèves en vue de la résolution de problèmes motivants.

Mais attention de ne pas attribuer plus d’importance que cette acquisition d’automatismes aux exerciseurs : l’enjeu principal, pour nous enseignants, reste bien que les élèves soient capables de les mobiliser lors de la résolution de problèmes. Réussir les exerciseurs n’est qu’une première étape, indispensable, mais loin d’être suffisante. Pour aller plus loin dans cette réflexion, je vous recommande l’article de Benoit Ducange, qui date de 2009, mais qui est toujours d’actualité. J’en cite un passage :

Toutefois, on peut légitimement s’interroger, comme pour tout entrainement répétitif, sur la capacité pour un élève à mobiliser ces connaissances ou compétences techniques dans un autre cadre. Ceci est accentué par trois éléments : un contexte mathématique explicite (je sais que la notion travaillée est le théorème de Thalès), une interface parfois contraignante (il y a des égalités de rapports à compléter alors que je préférerai travailler sur la linéarité d’un tableau), un indice de variation entre les différents exercices réduit (je reproduis une recette sans m’appuyer sur des propriétés).

Mais pour travailler ces automatismes, les exerciseurs restent des outils qui présentent des avantages certains :

• la génération aléatoire des valeurs des énoncées permet une très grande répétitivité (un élève qui refait une série d’exercices aura de nouvelles valeurs) ;
• le travail se fait en autonomie avec une correction immédiate ;
• différenciation facilitée quand il existe des banques d’exerciseurs ;
• La disponibilité : les élèves peuvent faire et refaire ces exercices à la maison pour s’entrainer et s’approprier une notion.

Pour plus de détails sur l’utilisation pédagogique des exerciseurs, je vous recommande, en plus de l’article déjà cité, l’article en deux parties, plus récent, du groupe PION de l’IREM d’Aix-Marseille : ici pour la première partie et là pour la seconde.

  Pourquoi GeoGebra ?

GeoGebra est le plus souvent connu comme un logiciel de géométrie dynamique, couramment utilisé au collège. Mais, ce logiciel gratuit, disponible en ligne et en version bureau, possède bien plus de fonctionnalités et son interface comprend de nombreux paramètres souvent méconnus, mais qui peuvent se révéler très utiles pour introduire de l’interactivité dans un fichier.

Quand j’ai créé mes premiers exerciseurs avec GeoGebra, il y avait peu d’alternatives (ou, du moins, je ne les connaissais pas), la question ne se posait pas vraiment pour le non initié à la programmation que j’étais. Aujourd’hui, il existe des plateformes proposant d’impressionnantes bibliothèques d’exerciseurs. On pensera, évidemment, à l’emblématique Labomep(projet Sésamath), en grande partie développée grâce à MathGraph32 [1], ou à l’excellent MathALÉA du collectif CoopMaths qui sont des outils extrêmement complets. D’autres plateformes permettent, comme Wims, de créer ses propres exercices. Et c’est ce point qui aujourd’hui me fait poursuivre avec GeoGebra : la facilité de créer ses propres exercices avec un outil qui permet aussi facilement les constructions géométriques que le calcul numérique ou littéral. Mais tous ces outils, et il y en a d’autres, ont leurs avantages et inconvénients : GeoGebra est celui sur lequel j’ai été formé initialement, celui sur lequel je me suis beaucoup investi et donc que je connais et maitrise le mieux.

J’ai déjà parlé dans un autre article de l’intérêt que je voyais dans l’utilisation de GeoGebra Classroom, et c’est pour moi un point important : pouvoir suivre en temps réel le travail des élèves. Autre point très important pour moi : la possibilité de choisir le feedback qui sera affiché à l’élève. Cela peut être uniquement le résultat juste, mais il est possible de prendre le temps de programmer une correction détaillée de l’exercice.

  Est-ce si simple de créer un exerciseur ?

Il est certain qu’il est préférable d’être familier avec les fonctionnalités de GeoGebra comme la création d’objets géométriques, texte, champs texte, nombres aléatoires... Il y a plusieurs moyens de réaliser un exerciseur. On peut utiliser seulement des conditions d’affichage, ce qui est assez simple, et c’est que je présente dans mon premier tutoriel, cité précédemment. Utiliser un script d’autovalidation (JavaScript) est utile pour valider une construction géométrique, mais est plus complexe à réaliser. Dans tous les cas, il est possible de faire évoluer un exercice plutôt simple en ajoutant un score, en créant une série, en donnant un feedback plus complet, en donnant une seconde chance à l’élève qui se trompe…

  Avant de se lancer

Généralement, les utilisateurs aguerris de GeoGebra préfèrent travailler avec la version 5 (version bureau) de GeoGebra, téléchargeable ici, et recommandée par GeoGebra pour la création de ressources avancées. Il est toutefois possible de travailler avec la version en ligne. Quoi qu’il en soit, les exerciseurs doivent être utilisés en ligne pour être « sécurisés ». En effet, en local, il n’est pas possible d’empêcher l’accès à la fenêtre « Algèbre » qui contient tous les objets créés. Même si cette fenêtre peut être fermée, elle reste très facilement accessible et son ouverture permettrait la lecture et l’affichage de tous les objets et donc de ceux qui sont volontairement cachés.

Personnellement, je travaille avec GeoGebra 5 en local : toutes les captures d’écran de ce tutoriel sont faites avec cette version.

 Création d’un exerciseur sur les priorités opératoires

Je vais décomposer la création de cet exerciseur en une succession d’étapes : nous commencerons par créer un fichier très simple que chaque étape va ensuite complexifier pour arriver à un exercice abouti et utilisable en classe. Il sera très simple ensuite de l’adapter à toute situation de calcul numérique.

  Étape 1 : affichage conditionnel

Il est assez simple de paramétrer une condition à laquelle un objet s’affiche. L’objet en question peut-être du texte, une image, un objet géométrique ou tout autre objet construit avec GeoGebra.

Par exemple, dans l’appliquette ci-dessous, tant que le calcul est faux, le message « Ce n’est pas la bonne réponse… » est affiché. Il laissera la place au message « Bravo ! » lorsque le résultat sera correct.

Cette appliquette est disponible au téléchargement ici : cliquer sur les trois petits points en haut à droite, puis sur « Infos » puis sur « Télécharger ».

La fenêtre « Algèbre » est volontairement laissée ouverte pour que le lecteur puisse consulter rapidement les objets créés, mais elle ne sera plus visible lorsqu’il s’agira de faire travailler les élèves dessus.
Détaillons les étapes de la création de ce fichier. Commençons par créer tous les objets sans se soucier de ceux que l’on veut afficher ou pas. Ici, il y a :

• les textes de consigne et du calcul à effectuer : « Calculer : » et « 3 × 2 + 5 = » ;
• le nombre « réponseElève » qui sert de variable et qui prend la valeur saisie dans le champ texte. Il faut donc le créer avant le champ texte ;
  Saisir (dans la barre de saisie) « réponseElève = NaN » pour indiquer qu’aucune valeur n’est encore affectée à la variable (« NaN » pour Not A Number).
• Le champ texte qui permet de saisir la réponse ;
  

On n’affiche pas son étiquette et, dans l’onglet « Style » de ses propriétés, on règle sa longueur à 3. Changer sa couleur d’arrière-plan permet de le rendre plus visible.

• les deux textes, de couleurs différentes, qui s’affichent en fonction de la justesse de la réponse.

Il faut ensuite saisir les conditions d’affichage des deux textes qui valident ou pas la réponse :

• Le texte « feedbackFaux » s’affiche si le nombre « réponseElève » est différent 11.
• Le texte « feedbackJuste » s’affiche si le nombre « réponseElève » est égal à 11.
  Pour cela, il faut aller dans les propriétés de ces objets et dans l’onglet « Avancé », saisir la condition d’affichage dans le champ « Condition pour afficher l’objet » :

Pour le texte « Bravo ! », la condition d’affichage à saisir est « réponseElève == 11 ». À noter qu’après validation, le « == » sera automatiquement remplacé par le signe « ≟ ».	Pour le texte « Erreur ! », la condition d’affichage à saisir est « réponseElève != 11 ». À noter qu’après validation, le «  != » sera automatiquement remplacé par un signe « ≠ ».

Nous obtenons ainsi un affichage conditionnel qui fonctionne bien, mais que je me propose d’améliorer : nous pouvons obtenir le même résultat avec un seul texte qui changera en fonction de la valeur de la variable « réponseElève ».

Pour cela, je supprime l’un des deux textes précédents, et édite le second : je le renomme « feedback », supprime la condition d’affichage pour qu’il reste affiché en permanence) et édite le texte (tout cela dans les propriétés de l’objet).

Dans la zone d’édition du texte, il faut insérer un champ vide dans l’onglet « Objets » (le champ apparait sous la forme d’un cadre dans la zone de saisie du texte, comme ci-dessous et il permet d’insérer les noms des variables dont on veut afficher les valeurs, des formules ou, comme dans notre cas, des tests conditionnels). Et il faut y saisir notre texte avec le test conditionnel. Ici : « Si(réponseElève == 11 , « Bravo ! » , « Erreur ! ») ».

Pour les non familiers avec ce genre de test, cela signifie : si la réponse de l’élève est 11, alors le texte affiché est « Bravo », sinon le texte affiché est « Erreur ! ».

Et, si on souhaite conserver deux couleurs différentes pour ces deux textes, il est possible d’utiliser les couleurs dynamiques de l’objet. On les trouve dans l’onglet « Avancé » des propriétés. Le mode RVB proposé ici peut dépendre de variables. Chacune des trois couleurs doit se voir affecter un nombre décimal entre 0 et 1 (la valeur habituelle entre 0 et 256 divisée par 256).

On peut utiliser le test « réponseElève == 11 » (qui est un booléen et qui vaut donc soit 0 soit 1) et son complément « réponseElève != 11 » (on peut également utiliser « 1 - réponseElève == 11 »). Et comme avec GeoGebra on peut multiplier un booléen par un nombre décimal, on en profite :

Lorsque la réponse est juste, le rouge est à 0 et le vert à 0,8 et inversement. Avec une petite pointe de bleu, à faire varier selon vos goûts.

Nous obtenons ici une bonne base de travail, mais qui contient de nombreux défauts que nous allons traiter dans les étapes suivantes.

Cette appliquette est disponible au téléchargement ici.

  Étape 2 : générer un calcul aléatoire

Première chose qui ne correspond pas au cahier des charges : la génération aléatoire du calcul. Pour corriger cela, nous avons besoin de 3 variables que je vais nommer « a », « b », et « c » et qui se verront chacune affecter un nombre aléatoire entre 1 et 10. Pour cela, dans le champ de saisie, taper : « a = AléaEntreBornes(1, 10) » (idem pour « c » et « b »).

Mais il nous faut aussi une variable à laquelle on affectera le résultat du calcul : « résultat ».

Toujours dans le champ de saisie, entrer : « résultat = a*b+c ».

Il faut maintenant modifier le texte « calcul » pour qu’il affiche le calcul à effectuer en fonction des nombres « a », « b » et « c ». On les trouve, dans l’onglet « Objets » lors de l’édition du texte. Il est également possible d’insérer des champs vides et de taper le nom de la variable. Si on aime les raccourcis clavier, c’est rapide : un champ vide est inséré par la combinaison de touches « Alt » + « flèche bas ». Une fois rempli, on sort du champ par la combinaison « Alt » + « flèche droite ».

Il faut maintenant s’attaquer au texte « feedback ». Mais avant cela, nous allons créer un booléen qui va tester si la réponse de l’élève est juste. Dans le champ de saisie, entrer : « correct = réponseElève == résultat » (le booléen « correct » est vrai si la réponse de l’élève est la réponse attendue). Ce n’est pas forcément indispensable pour le moment, mais cela facilitera la suite.

On peut maintenant l’utiliser dans le test conditionnel de notre texte « feedback » qu’il faut éditer :

On peut également utiliser ce booléen dans la définition des couleurs dynamiques de ce même texte : saisir « 0.8 * !correct » pour obtenir le complément de « correct » (là encore, « 1 – correct » fonctionne).

Tout est fonctionnel maintenant et les valeurs aléatoires seront recalculées à chaque ouverture du fichier.

Cette appliquette est disponible au téléchargement ici.

Mais on peut faire mieux : on peut également rendre aléatoire l’ordre des deux calculs proposés (une multiplication et une addition). Pour cela, nous allons utiliser une variable « dé » qui se voit affecter aléatoirement soit la valeur 1 soit la valeur 2 : cela correspondra aux deux situations « a + b * c » et « a * b + c ».

On crée cette variable en saisissant « dé = AléaEntreBornes(1, 2) » dans le champ de saisie. Il faut ensuite modifier deux objets : le texte « calcul » et le nombre « résultat », pour tenir compte des deux possibilités de calcul. Pour éditer ces objets, inutile de se rendre dans leurs propriétés : un double clic sur un objet, dans la fenêtre algèbre, permet son édition rapide.

• Pour le texte, on utilise un champ vide qui contient un test conditionnel sur la valeur de la variable « dé ». Les opérateurs doivent être écrits entre guillemets anglais doubles (comme tous les textes à afficher qui se trouvent dans un champ ainsi placé) :
  

• Pour le nombre résultat, on utilise également un test conditionnel :
  

Voilà pour cette étape : les calculs proposés sont maintenant aléatoires.

Cette appliquette est disponible au téléchargement ici.

  Étape 3 : une correction détaillée

C’est certainement l’étape la plus longue lors de la création d’un exerciseur : la préparation d’une correction détaillée, qui sera bien plus utile que les messages actuels de notre appliquette.

Voici ce que je souhaite obtenir :

Cette appliquette est disponible au téléchargement ici.

La correction sera affichée, que la réponse donnée soit juste ou pas. Dans l’expression initiale, le calcul prioritaire sera souligné. La correction est écrite en blanc avec le résultat final en cyan.

Nous allons donc éditer notre texte « feedback » et, attention, ça se complique :

Je vais expliquer tout cela, point par point.

• Tout d’abord, pour afficher les calculs de façon plus élégante, le texte est déclaré comme étant une « Formule LaTeX », ce qui permettra aussi d’utiliser des commandes LaTeX pour la mise en forme. Cela explique les « $\text{\text{}} $ » au début des deux premières lignes qui ne contiennent que du texte (on peut s’en passer et ajouter des « $\backslash ;$ » pour les espaces entre les mots).
• Je souhaite que la correction soit en blanc : la commande LaTeX « $ \text{\textcolor{couleur}{}} $ » permet de fixer la couleur du texte spécifié.
• Les « $\backslash\backslash$ » à la fin des deux premières lignes signifient un retour à la ligne (LaTeX).
• Sur la troisième ligne, la commande LaTeX « \underline{} » permet de souligner le calcul prioritaire, qui est la multiplication de b par c dans le cas où le dé vaut 1, celle de a pas b sinon.
• Toujours sur la troisième ligne, la commande « Si(dé==1, a ’’+’’) » permet un affichage seulement si la variable « dé » vaut 1. L’utilisation du « sinon » n’est pas obligatoire, mais on obtiendrait le même affichage avec « Si(dé==1, a ’’+’’ , ’’’’) ». Même remarque pour « Si(dé==2, ’’+’’ c) ».
• Les « $\backslash ;$ » en fin des troisième et quatrième lignes ajoutent un espace (LaTeX).
• Sur la quatrième ligne, « (b c) » et « (a b) » sont les produits des deux variables concernées.
• À noter : il n’y a pas de retour à la ligne après les troisième et quatrième lignes (en LaTeX, il faudrait ajouter « $\backslash\backslash$ » pour obtenir un retour à la ligne).

Cette syntaxe peut paraitre impressionnante lorsqu’on n’est pas familier avec LaTeX mais ça vaut le coup de se pencher dessus, car les possibilités offertes sont vraiment nombreuses. Nous avons donc obtenu notre appliquette avec la correction de l’exercice aléatoire comme souhaité.

  Étape 4 : un bouton de validation

Le problème maintenant est que cette correction soit affichée en permanence : il faudrait qu’elle ne le soit que lorsque l’utilisateur (l’élève) valide sa réponse. Et pour qu’il puisse valider sa réponse, nous allons devoir ajouter un bouton de validation.

Mais avant cela, nous allons créer un nouveau booléen : saisir « repValidée = false » dans le champ de saisie. Il nous permettra de savoir si l’élève a validé ou non sa réponse et nous servira de condition d’affichage pour le texte « feedback ».

Nous pouvons maintenant créer le bouton de validation : on utilise l’outil « Bouton » de la barre d’outils.

Sa légende sera « Valider ».

Dans son script, nous allons changer l’état du booléen « repValidée » en le rendant vrai : « SoitValeur(repValidée, true) ».

Nous allons également rendre le champ texte qui contient la réponse non sélectionnable pour que l’élève ne puisse pas modifier sa réponse. La commande qui permet de le faire est « SoitFixé( ChampTexte1, true, false) ». « ChampTexte1 » est le nom de l’objet (ici le nom donné par défaut, je ne l’ai pas renommé). Le premier booléen de la commande indique si l’objet est fixé ou pas (s’il peut être déplacé ou pas) et le second indique si l’objet est sélectionnable (et donc, ici, il ne le sera plus après que le bouton aura été cliqué). Le script du bouton peut à tout moment être édité dans l’onglet « Script » des propriétés et, dans notre cas, dans l’onglet « Par Clic » :

N’oublions pas d’ajouter le booléen « repValidée » comme condition d’affichage de la correction :

Voici ce que nous obtenons alors :

Cette appliquette est disponible au téléchargement ici.

  Étape 5 : enchainer les calculs

Maintenant, nous souhaitons que les élèves puissent s’entrainer non pas sur un seul exercice, mais sur une série d’exercices. Pour obtenir une nouvelle consigne, il suffit de faire recalculer à l’appliquette les quatre nombres aléatoires de l’exercice (« a », « b », « c » et « dé »). La commande « ActualiserConstruction( ) » permet de le faire (tous les nombres aléatoires du fichier sont alors recalculés). Nous allons créer un nouveau bouton « Suivant » dans lequel nous allons saisir cette commande. Et puisqu’il s’agit de travailler sur un nouvel exercice, il faut remettre le booléen « repValidée » à « false » et rendre le champ texte sélectionnable à nouveau. Enfin, la commande « SoitValeur(réponseElève, NaN) » va supprimer la réponse actuelle du champ texte (« NaN » pour Not A Number). Ce qui donne ces quatre lignes dans le script du bouton :

Si on ne souhaite pas que l’élève puisse passer un exercice trop difficile, on peut, par exemple, conditionner l’affichage de ce bouton à l’état du booléen « repValidée » (le bouton « Suivant » n’est montré que lorsqu’une réponse est validée).	De même, le bouton « Valider » n’a plus besoin d’être affiché lorsque la réponse est validée. Il sera visible seulement lorsque l’on passera à l’exercice suivant.

Nous pouvons aussi créer une variable « score » pour pouvoir suivre l’avancement du travail des élèves : dans le champ de saisie, « score = 0 » crée la variable. Ce score sera incrémenté dans le script du bouton « Valider » si la réponse donnée est juste avec la commande « SoitValeur(score, score + correct ) ». On remarque ici que nous additionnons deux variables de natures différentes, ce qui ne dérange pas GeoGebra ! Ici, le booléen « correct » prendra la valeur « 0 » ou « 1 ».

Pour afficher ce score à l’écran, il faut créer le texte ci-contre.

Voici ce que nous obtenons alors :

Cette appliquette est disponible au téléchargement ici.

  Étape 6 : éviter les calculs dans les réponses

On commence à se rapprocher du but, mais un point qui pourrait passer inaperçu est important à corriger. En effet, si un élève tape le calcul proposé dans le champ texte, sa réponse sera considérée comme juste ! Évidemment, nous voulons éviter cela.

Pour cela, nous n’allons plus comparer des valeurs numériques dans le test « correct », mais des textes. Nous allons commencer par changer la nature de l’objet « réponseElève » en le déclarant comme étant un texte. Dans le champ de saisie, rentrer : « réponseElève=«  » ». Cet objet n’apparait plus dans les nombres, mais dans les textes.

Il reste maintenant à changer le test « correct » (double cliquer dessus pour l’éditer) comme ci-dessous :

Nous comparons ainsi le texte « réponseElève » à un texte qui ne contient que le nombre « résultat ».

Nous pouvons aller plus loin en affichant un message lorsque l’élève saisit un calcul. Pour savoir si c’est le cas, nous allons utiliser les codes Unicode des deux opérateurs utilisés dans les exercices : 42 pour « * » et 43 pour « + » et vérifier s’ils sont présents dans la conversion en Unicode de la réponse saisie par l’élève. Commençons par créer ce texte, par exemple : « Ta réponse doit être un nombre entier. Les calculs ne sont pas acceptés. ».

Puis, créons un nouveau booléen « calculPrésent » :

La commande « TexteEnUnicode( réponseElève ) » renvoie une liste qui contient le code Unicode de tous les caractères du texte « réponseElève ». Nous vérifions si 42 ou 43 sont dans cette liste, ce qui sera le cas si la réponse de l’élève contient un des deux caractères « * » ou « + » . Le symbole de l’opérateur logique OU (« ∨ ») s’obtient en saisissant « || » avec les touches « AltGr » et « 6 » (on peut aussi utiliser le petit menu qui s’affiche lorsque l’on clique sur le « α » à l’extrémité droite du champ de saisie).

Nous utilisons ce booléen dans les conditions d’affichage du texte à afficher :

Si un élève saisit un calcul, nous allons lui permettre de répondre à nouveau à l’exercice. Il faut pour cela réaliser deux modifications dans le script bouton « Valider » :

Le booléen « repValidée » prend l’état complémentaire du booléen « calculPrésent » (première ligne). Cela permet de n’afficher ni la correction ni le bouton « Suivant » si un calcul est présent dans la réponse.

À la deuxième ligne, le champ texte reste sélectionnable si un calcul est présent dans la réponse : l’élève peut ainsi modifier celle-ci. Par contre, le champ texte ne sera pas sélectionnable si aucun calcul n’est présent dans la réponse, comme précédemment.

Cette appliquette est disponible au téléchargement ici.

  Étape 7 : résoudre un problème esthétique

Vous l’avez peut-être remarqué, la position du champ texte où l’élève doit donner sa réponse n’est pas toujours bien ajustée par rapport au calcul qui le précède. Cela est dû au fait que le champ texte est fixe alors que la longueur du texte est variable : le texte est plus long lorsque le nombre 10 apparait dans le calcul, comme ci-contre.

Pour pallier ce problème, nous allons lier le champ texte au texte « calcul » qui le précède. En tapant la commande « Coin(calcul, 3) » dans le champ de saisie, on crée un point dans le coin supérieur droit du texte (on obtient les autres coins en replaçant le 3 par 1, 2 ou 4). Le point est nommé « A » si c’est le premier point créé.

Maintenant, dans les propriétés du champ texte, dans l’onglet « Position », indiquer le point « A » comme « Point de départ » (décocher « Position absolue sur l’écran » si cette option est cochée).

Maintenant, le champ texte se décale vers la gauche ou vers la droite suivant la longueur du calcul. Il est possible d’ajuster manuellement sa position.

Il faut penser à ne pas afficher le point « A » (mais ne pas le supprimer).

Voici le résultat :

Cette appliquette est disponible au téléchargement ici.

  Étape 8 : un nombre limité de questions

Nous pouvons également limiter le nombre de questions pour faire travailler les élèves sur des séries de 10 ou 20 questions et obtenir un score qui serait donc sur 10 ou sur 20, par exemple.

Créons un nombre qui contiendra le nombre de questions souhaitées avec la commande « nbQ = 10 » dans le champ de saisie. Un autre nombre va également compter le nombre de questions auxquelles l’élève a répondues : « nbR = 0 ». Ce dernier nombre sera incrémenté à chaque fois que l’élève clique sur le bouton validé, à condition qu’aucun calcul ne soit détecté dans la réponse (car dans ce cas l’élève peut modifier sa réponse). Nous ajoutons pour cela la ligne 4 du script du bouton « Valider » (une fois encore, nous additionnons un nombre avec un booléen) :

Nous pouvons modifier le texte qui affiche le score pour indiquer combien de questions ont été traitées :

Lorsque l’élève valide sa dernière question, sa correction doit être affichée, mais le bouton « Suivant », lui, doit être masqué. Nous modifions sa condition d’affichage : il s’affiche si la réponse est validée et si le nombre de questions auxquelles l’élève a répondues (« nbR ») est différent du nombre de questions à traiter (« nbQ »).

Le ET logique (symbole « ∧ ») s’obtient en saisissant « && ». On peut également le trouver dans le petit menu qui s’affiche lorsque l’on clique sur le « α » à l’extrémité droite du champ de saisie.

Nous pouvons modifier le score affiché pour que ce soit le score final :

Enfin, nous ajoutons un nouveau bouton « Recommencer » qui reprend tout le script du bouton « Suivant » auquel on ajoute une remise à zéro des nombres « nbQ » et « score » (il s’agit de pouvoir recommencer une série complète d’exercices) :

Ce bouton ne s’affiche que lorsque la dernière question est validée, condition à ajouter dans ses conditions d’affichage :

Voici le résultat :

Cette appliquette est disponible au téléchargement ici.

  Étape 9 : finitions avant la mise en ligne

Nous avons maintenant tous les éléments d’un exerciseur parfaitement opérationnel. Une fois que tous les objets sont correctement positionnés, il faut rendre tous les textes non sélectionnables. Le champ texte et les boutons, quant à eux, doivent rester sélectionnables, mais doivent être des objets fixes. Ainsi, les élèves ne s’amuseront pas à tout déplacer sur leur écran.

Dans l’onglet « Avancé » des propriétés des textes, décocher « Sélectionnable ».	Dans l’onglet « Basique » des propriétés des boutons et du champ texte, cocher « Objet fixe ».

Avant de mettre en ligne l’appliquette, il faut penser à fermer la fenêtre « Algèbre ». Penser à renommer tous les objets avec des noms explicites peut être utile lorsque l’on voudra se replonger dedans, par exemple, pour créer un nouvel exerciseur.

Le résultat final devrait ressembler à ça :

Cette appliquette est disponible au téléchargement ici.

 Pour conclure

Tout ce travail peut paraitre complexe pour le néophyte. L’avantage de se lancer dans cette création est qu’il ne sera pas nécessaire de tout recommencer à zéro pour créer un nouvel exerciseur : il suffira de dupliquer cette appliquette et de modifier la consigne et la correction (c’est la partie la plus longue du travail, mais elle peut ne pas être très détaillée). Tout le reste peut être réutilisé, complété et sans doute amélioré, pour tout exerciseur de calcul numérique. Si vous souhaitez aller plus loin, n’hésitez pas à télécharger un exerciseur (tous les fichiers que vous trouvez sur la plateforme GeoGebra sont téléchargeables) qui vous intéresse et à aller regarder dedans comment il est réalisé. C’est comme cela que j’ai appris le plus, en comprenant les travaux des collègues. La brochure de la c2it « Créer avec GeoGebra » ainsi que le manuel GeoGebra sont des ressources très utiles à consulter lorsque l’on recherche une commande, par exemple. Et puis, dans le groupe Facebook « GeoGebra pour les enseignants », quelques collègues experts seront ravis de répondre à toute question sur la réalisation d’un travail sur GeoGebra.