Mathématice, intégration des Tice dans l'enseignement des mathématiques  
Sommaire > N°54 - mars 2017 > Le paradigme de la tortue

Le paradigme de la tortue
Moteur de recherche
Mis en ligne le 10 février 2017, par Patrice Debrabant

Deux nouvelles espèces de tortue ont vu le jour dans le bassin de la géométrie dynamique : celle de DGPad et celle de CaRMetal.
Ces tortues évoluent en milieu dynamique et sont elles-mêmes dynamiques. Elles offrent de nouvelles possibilités et illustrent que le concept de tortue, au delà de ses incarnations, est un paradigme de déplacement.
couronne de fleurs polygonales réalisée avec DGPad

Article placé sous licence CC-by-SA : http://creativecommons.org/licenses/by-sa/3.0/fr/legalcode

Présentation générale

Les tortues constituent un ordre de reptiles dont la caractéristique est d’avoir une carapace.
On distingue :
- les tortues terrestres ;
- les tortues dulçaquicoles (d’eau douce) ;
- les tortues marines.

En technique militaire, la tortue est une formation compacte de fantassins dont les boucliers forment une carapace. Cette forme défensive est parfois esquissée par les personnels de l’Education Nationale effarés par un putsch des Généraux de la DGESCO.

Le terme tortue caractérise aussi une personne lente de démarche ou de compréhension. On dira « Quelle tortue, celui-là ! » (mais on évitera de l’écrire dans le bulletin).

En informatique, voici la définition que l’on peut trouver de la tortue (de Education et informatique, janvier-février 1985) : "La tortue est un robot, piloté par le langage Logo, qui se déplace par terre. Pour la manipuler, il suffit d’introduire des cartes (représentant des ordres) dans un boîtier, alors la tortue se déplace et peut laisser des traces de son passage."

En géométrie, la tortue est avant tout un paradigme de déplacement (on avance et/ou on pivote) qui s’oppose au paradigme de déplacement repéré (la téléportation).
Lors de son invention par Seymour Papert dans le cadre du langage Logo, cette dimension paradigmale est déjà présente : ce mode de déplacement, qui servira de medium pour la pratique du Logo, est un modèle cohérent et correspond à la représentation qu’un enfant peut se faire de l’espace à parcourir. Mais la tortue est surtout un substrat pour faire du Logo, et joue aussi le rôle d’ambassadeur du Logo, au risque de lui voler la vedette...

La tortue se voit accolée l’attribut Logo, mais fondamentalement elle ne l’est pas du tout. On peut juste dire que le premier langage dans lequel on a implémenté le paradigme de la tortue est le Logo.
Dans la lignée de cette ancètre, de nouvelles tortues sont apparues, programmées dans un langage proche du Logo (comme GéoTortue) ou dans un langage différent (par exemple la tortue Python).
Ces tortues apportent des raffinements intéressants (multi-tortues, zoom,...), mais implémentent le paradigme de façon identique : la tortue est un objet autonome qui laisse une trace morte (volatile par nature).
C’est encore le cas dans le logiciel Scratch : le lutin est un objet (au sens de la programmation orientée objet) qui a la faculté de se comporter comme une tortue. "Il n’y a pas d’amour, il n’y a que des preuves d’amour" : le lutin de Scratch est une tortue. C’est une tortue qui aime bien se travestir et miauler en TP d’informatique, mais c’est une tortue de type classique. Il n’y a pas d’évolution du point de vue de l’implémentation du paradigme de la tortue.

Trois activités sur le paradigme de la tortue à partir du cycle 3

Ces activités ont été réalisées avec le concours de ma collègue Batoul Saoud pour l’Accompagnement Personnalisé au collège.
Elles sont inspirées de celles réalisées sur GéoTortue par l’IREM Paris-Nord, dont nous apprécions la philosophe générale (on a même repris certaines illustrations).
Mais il nous a semblé judicieux de créer les activités dans un autre langage que le Logo, et ce pour plusieurs raisons :

  • en termes de langages de programmations, le Javascript francisé de CaRMetal me paraît plus pertinent et plus pédagogique que le Logo (ce point de vue n’est pas impartial, je l’avoue...), et la tortue de CaRMetal a l’avantage d’être dynamique et mutante ;
  • la Programmation Visuelle par Blocs régnant sur la Galaxie, le point précédent ne se pose même pas : il fallait une tortue ainsi pilotée.

Nous avons "choisi" d’utiliser Scratch (ou mieux : Snap !) pour commencer car ce logiciel est incontournable et "imprégné" de la même philosophie créative que les activités conçues initialement pour la tortue Logo.
Mais en la circonstance, Scratch présente un manque : il ne permet pas de colorier l’intérieur d’un polygone. [1]
Nous avons donc décidé de procéder en deux phases progressives :

  1. réaliser l’activité au trait avec Scratch ;
  2. réaliser l’activité complète avec DGPad (et une syntaxe Blockly)

Chaque approche présente beaucoup d’intérêt, et les deux se complètent assez bien (avec un degré de difficulté croissant qui permet la différentiation).
On pourra noter qu’avec Scratch on a délibérément évité toute programmation événementielle, car celle-ci a tendance à brouiller le paradigme de la tortue. Cette programmation événementielle est assez simple à comprendre, il nous semble plus opportun de l’apprendre dans un autre cadre (quitte à la réinjecter ensuite dans les activités tortue).
Certains pourront considérer que ces activités sont trop directives et donc contraires à la pédagogie créative. Cet excès de directivité dans les premières séances nous a semblé nécessaire et profitable.

Séance 1 Séance 2 Séance 3
PDF - 250 ko
PDF - 221.2 ko
PDF - 230 ko

A l’époque de l’écriture de cet article, je me suis dit : "Si on se limite à ces tortues, le paradigme présente un retard par rapport à son rival la téléportation : il n’est pas implémenté en géométrie dynamique." [2]
Or, le logiciel CaRMetal donnait la possibilité de construire une telle tortue dynamique en utilisant la malléabilité des expressions dans un script.
C’est ce que j’ai fait dans l’article avant de l’implémenter quelques mois plus tard dans le logiciel. Entretemps, Eric Hackenholz avait implémenté une tortue dynamique dans DGPad.
Il est intéressant selon moi de comparer ces implémentations car elles permettent de comprendre les différences de noyau entre ces logiciels.


la tortue de CaRMetal

Type :
- dynamique
- mutante

Anatomie de l’animal

Dans CaRMetal (contrairement à GeoGebra), un script n’est pas une propriété d’un objet géométrique (d’un objet de CaRMetal). C’est un élément autonome, que l’on peut éventuellement déclencher par une action sur un(des) objet(s) géométrique(s) particulier(s). Par script, on peut créer un objet comme on le ferait via la palette Construction de l’interface.
Mettons-nous à la place du développeur : on est dans un contexte de géométrie dynamique, et on veut construire une tortue « dynamique » au sens où elle pourra accepter des paramètres dynamiques. La première question est : cette tortue, elle part d’où ?
On pourrait donner une position repérée, mais faire partir la tortue d’un point potentiellement libre, c’est ajouter du dynamisme et c’est clairement préférable.

L’instruction AttacherTortue("A") fait partir la tortue du point A et crée la tortue si celle-ci n’existe pas. Cette tortue est un ensemble d’objets de CaRMetal (= des points et des polygones), et on peut noter que l’aspect de la tortue sera (en partie) déterminé par l’aspect par défaut des polygones (c’est voulu, on peut obtenir un contour marqué ou pas). [3]

Exemple 1 :
Lancer CaRMetal.
Créer deux points A et B.
Créer le script suivant :

  1. AttacherTortue("A");
  2. Avancer(1);
  3. AttacherTortue("B");
  4. Avancer(0.5);

Télécharger

Dans l’instruction Avancer, l’unité est l’unité en vigueur dans la fenêtre de travail (que l’on peut matérialiser en affichant le repère).
Lancer ce script.
On obtient ceci :

Dans CaRMetal, il y a une seule tortue, qui papillonne. [4]

Si on le souhaite, on peut masquer la tortue par l’instruction CacherTortue() à la fin du script.
Ce que l’on veut noter ici, c’est que la tortue a créé des objets CaRMetal (deux points et deux segments) qui sont de même nature et qui sont utilisables comme n’importe quel objet CaRMetal.
Les points ne sont pas visibles car leur aspect leur de leur création est un petit point, mais ils sont sélectionables et on peut modifier leurs propriétés dans la barre de propriétés.

Il est fondamental de pouvoir récupérer le nom de ces objets (le point et le segment) dans le script. Ces points étant créés par l’instruction Avancer, celle-ci va renvoyer le nom du point et le nom du segment dans un tableau Javascript de dimension 2 (et créer ces objets "par effet de bord").
Par exemple, on peut écrire ce script :

CarMetal - 1001 octets

On notera que l’instruction Avancer ne doit être effectuée qu’une seule fois, ce qui oblige à utiliser un paramètre intermédiaire si l’on veut récupérer à la fois le nom du point et celui du segment. Si l’on devait récupérer seulement le nom du point, on pourrait se contenter de pointGauche=Avancer(1)[0] ;

Les instructions utilisées sont les instructions habituelles et peuvent être générés (puis ajustées) par les boutons de l’assistant de script à droite, mais l’assistant ne prend pas en charge les instructions tortue pour l’instant (des boutons tortue pourraient être ajoutés sans difficulté). La syntaxe tortue est récapitulée sur cette page ou la même en anglais.

Pour montrer que cette tortue est dynamique, on peut créer un curseur k et remplacer 0.5 par "k" pour le déplacement depuis le point B.

CarMetal - 1.1 ko

La construction est dynamique en k (et en A et B).
Si on supprime le point A, on supprime aussi le tracé depuis A, mais pas le tracé depuis B.

La tortue est mutante car elle s’intègre à un biotope (la construction CaRMetal) indépendant et produit une trace constituée d’objets CaRMetal qui peuvent ensuite être réutilisés dan le biotope.

Pour le fun, on a ajouté un paramètre vitesse (entre 0 et 100, au delà de 100, c’est écrêté), qui consiste à ralentir la tortue de manière inversement proportionnelle. [5] C’est un ralentissement fluide, avec création d’états intermédiaires, contrairement au ralentissement discontinu que l’on trouve très généralement (dans GéoTortue par exemple).
Il suffit d’ajouter après la création de la tortue (ligne 2) VitesseTortue(0.1) ;

CarMetal - 1.2 ko

Sur la copie d’écran ci-dessus, le script n’est pas terminé. On notera que l’instruction Avancer() s’applique jusqu’à son terme (quel que soit le ralentissement) avant l’application de l’instruction suivante : les segments prennent leur apparence finale quand ils sont entièrement tracés.

On peut avancer, mais on peut aussi reculer. Mais c’est encore une façon d’avancer : avec cette nouvelle instruction Reculer(...), on n’est pas plus avancé. On l’est moins.
Cela étant, d’un point de vue anthropomorphique, il est plaisant de pouvoir reculer. [6] Et les scripts tortue ont une dimension anthropomorphique.

Les instructions pour pivoter(tourner) sont :

  • en 2D : TournerGauche() et TournerDroite()
  • en 3D :
    • TournerGauche() et TournerDroite()
    • PivoterGauche() et PivoterDroite()
    • PivoterHaut() et PivoterBas().

L’unité est le degré.
Quand on est dans une figure 2D, on crée une tortue 2D.
Quand on est dans une figure 3D, on crée une tortue 3D.

Intérêts du paradigme de la tortue

Les mordus par la tortue vantent ses vertus pédagogiques, qui permettent de découvrir ceci cela (les angles, les polygones réguliers,...) et bien sûr la programmation (c’était le but au départ).
Eh bien, c’est vrai.
Mais on peut aller plus loin : pour construire un polygone/une ligne brisée (un polyèdre/une pâte brisée dans l’espace), c’est souvent un paradigme plus efficace que la téléportation. Un cas très emblématique est celui du patron repliable d’un solide.

On peut noter qu’un élève de collège appliqué à construire une figure avec les instruments traditionnels se comporte souvent comme une tortue : non seulement il est d’une lenteur désespérante, mais il aime aussi construire selon ce paradigme.
C’est tout à fait justifié dans le cas d’un polygone régulier, dont le protocole de construction par le paradigme de la tortue est plus simple et plus élégant que son alter ego par téléportation.

Le polygone régulier

Le protocole (en langage naturel) pour tracer un polygone régulier à n côtés est

Répéter n fois {
  Avancer(1);
  TournerGauche(180/n);
  }

C’est l’occasion de constater l’absence dans le Javascript enrichi de CaRMetal (le Javascript, pas le concepteur) de la boucle Répéter sans indice de boucle.
Quand on passe en "mode débutant" (Beginner mode) en cochant la case idoine, on pourrait s’attendre à ce que l’assistant génère

Répéter n fois {
...
  }

Mais non : l’assistant génère

pour i allant de 1 à n {
  ...
  }

On a préféré garder une boucle for (adaptée) avec indice.
L’indice est disponible, et on est plus proche du Javascript. La boucle est plus puissante, mais un peu plus compliquée. C’est un choix.

Un script CaRMetal possible est :

n=7;
AttacherTortue("A");
pour i allant de 1 à n {
        Avancer(1);
        TournerGauche(360/n);
}

Remarque : on suppose ici que le point A est déjà construit. Mais ça coûte pas plus cher de le construire par script, il suffit de commencer le script par Point("A") ; (qui crée un point A au hasard, mais dans le scope de la fenêtre).

Si on veut le faire sans le paradigme de la tortue, c’est... PENIBLE.
Oui oui, je vais le faire, mais c’est... PENIBLE.

On peut plus naturellement partir du centre. Un script CaRMetal possible est :

Très bizarrement, l’instruction Intersection (sans s) ne donne pas le bon point (c’est un bug). On utilise donc plutôt Intersections (avec s) qui renvoie la liste des noms de points d’intersection (droite/cercle) séparés par une virgule que l’on transforme en tableau dont on prend la première valeur. C’est... PENIBLE.

Remarque : les sommets sont nommés car lors du lancement du script c’était une préférence pour l’aspect par défaut des points (cette préférence est outre-passée par la tortue, par défaut s’entend).

Quadrilatères particuliers

Construire les quadrilatères particuliers selon le paradigme de la tortue est également intéressant. Cela permet de réinvestir les propriétés des quadrilatères dans un cadre intéressant.
Les "jeux sérieux" qu’Yves Martin propose dans son encyclopédie sur la tortue de DGPad, partie 1 : Généralités - onglet Modifier un quadrilatère sont très intéressant. Et selon moi leur mise en scène la plus pertinente se fait avec une tortue mutante, à savoir celle de CaRMetal (car c’est la seule du genre pour l’instant, sauf ignorance de ma part).

Le plat de Soissons

Comme l’évoque Patrick Raffinat dans son article consacré à l’apprentissage de l’algorithmique, le tracé d’un plat de Soissons est une activité intéressante avec la tortue car son côté spectaculaire la rend attractive.
Dans le même article, il trace cette figure avec le logiciel Sofus [7] et signale que, dans ce cadre, « l’usage de sous-programmes (ici un parallélogramme plein) est quasi-indispensable ». Et c’est lui-même qui crée et met à disposition cette procédure pour l’utilisateur (l’élève ou l’étudiant). Cela crée un micro-monde tout à fait pertinent pour construire le plat de Soissons.

Le plat de Soissons est aussi tracé avec GéoTortue dans une activité classique de l’IREM Paris Nord.
Dans ce cas, on a le choix d’utiliser l’instruction remplir [8] ou de tracer le dessin au trait et de le mettre en couleurs ultérieurement, dans l’interface dédiée.
Cette fois, on est invité à créer une procédure Losange (car de toute façon on va parcourir ces losanges [9]), etc...

Le plat de Soissons est encore tracé avec la tortue de DGPad dans une activité dédiée du site CaRMetal.org.
La méthode proposé correspond à celle pour GéoTortue avec l’instruction remplir, à ceci près que l’implémentation du remplissage est nettement plus agréable.
Par ailleurs, la tortue de DGPad est "hyper dynamique", ce qui permet de rendre dynamiques les point initiaux, les numéros de couleur, et même le nombre de losanges dans un brin (généralisation du plat de Soissons).

Voyons maintenant comment on peut construire (et non pas tracer) le plat de Soissons avec CaRMetal.
Signalons tout de suite que l’on ne pourra pas rendre dynamique le nombre de losanges dans un brin (= sans utiliser une méthode déloyale de masquage) dans la généralisation du plat. Il y aura moins de dynamisme qu’avec la tortue de DGPad.
On va construire un plat de Soissons classique. La construction sera constituée de polygones de CaRMetal. Les éléments dynamiques seront le centre et les couleurs (3x 3 curseurs RVB).

Dans tous les cas, on trace le plat de Soissons en traçant les "brins" dans une boucle :

La grosse différence est que pour les trois tortues précédentes, on parcourt un brin vers la périphérie, on "dépose" les losanges, et on peut ensuite revenir par le même chemin. Alors que pour la tortue CaRMetal on va faire le tour du brin et retenir en passant les noms de tous les points créés.

Puis on créera les losanges avec la CaRCommande Quadrilatère (c’est-à-dire en sortant du paradigme de la tortue) : Quadrilatère("A", p1, p6, p7), etc.

On commence donc par créer 9 curseurs a, b, ..., h entre 0 et 255.
Puis on crée un point A, qui sera le centre dynamique du plat.

Pour simplifier, on va prendre un côté de longueur 1 pour les losanges.
Le script suivant permet de créer un brin :

On modifie pour enregistrer les noms des points dans des variables.

Puis on crée les losanges, et on leur attribue des couleurs dynamiques.

On n’a plus qu’à boucler 8 fois.

CarMetal - 1.5 ko

Patrons de solides

Venons-en maintenant à la 3D et au patron repliable d’un solide.

Commençons par une petite digression concernant l’originalité du traitement de la 3D dans CaRMetal :
- les points 3D peuvent être créés en manipulation directe (on sélectionne l’outil point 3D et on clique : hop, c’est un point 3D. Il est dans le plan frontal passant par O)
- les points 3D sont déplaçables en manipulation directe dans ce même plan frontal.
Cette approche n’existe que dans CaRMetal (sauf ignorance de ma part). Il me semble que c’est regrettable (sauf excès d’auto-satisfaction de ma part).

Mais revenons à notre problème de patron repliable : ce problème est apparu assez tôt après l’arrivée de la 3D. En l’absence de tortue, ce problème semble compliqué, au point que des méthodes qui ne respectaient pas parfaitement la perspective du patron ont parfois été proposées pour CaRMetal. [10]
Dès lors que l’on dispose d’une tortue 3D dynamique et que l’on connaît la valeur des angles dièdres entre les faces du solide, réaliser son patron repliable ne pose pas aucune difficulté si l’on procède selon le paradigme de la tortue.
On va illustrer la méthode sur un (des 11) patron de cube.

- On lance donc CaRMetal, puis on crée une nouvelle figure 3D par le menu Fichier/Nouvelle figure 3D. Si la figure initiale 2D est vide, elle est supprimée automatiquement, et on se retrouve avec une seule figure 3D (un seul onglet).
- On sélectionne l’outil point3D (sélectionné par défaut) puis on clique pour créer un point 3D nommé A.
- Pour un cube, les angles dièdres mesurent 90°. On crée un curseur k à l’aide de l’outil curseur de la palette Contrôles. Ce curseur varie entre 0 et 90°. [11]

On commence par créer une face, et on repère les arêtes sur lesquelles il y a un pliage.

- créer un script patron :

Première idée :

Mais on veut gérer deux arêtes qui n’ont pas le même statut :

Donc on n’utilise pas de boucle de répétition :

Puis on procède récursivement pour chaque nouvelle face. Par exemple, pour la face en bas à droite sur la figure du patron :

Voici la figure avec le script complet :

CarMetal - 4.6 ko

Une fois que les sommets sont construits, on peut agrémenter le patron en utilisant l’interface. Par exemple, on peut colorier les faces en créant des polygones au niveau des faces.

Fractale originale

Pour terminer la partie consacrée à la tortue mutante de CaRMetal, je me suis dit que j’allais créer une fractale originale que voici :

Cet exemple montre ce que peut être un flux de travail avec une tortue mutante.

On part d’une fractale classique, que l’on pourrait obtenir avec n’importe quelle tortue :

CarMetal - 2 ko

Puis on se dit que l’on aimerait arrondir les angles.

Alors à partir de cette fractale construite par script, on crée une macro quartCercle :

Les initiaux sont les trois points en rouge, le seul final est l’arc de cercle en vert.

Les points de la fractale construits par la tortue peuvent aisément être mis dans un tableau Javascript. La question est de savoir quand remplacer les segments entre ces points par le quart de cercle.

Dans le script, on distingue deux types de points et on l’indique visuellement en modifiant l’apparence :

On voit alors qu’il faut faire la substitution quand on a deux (ou plus) points carrés à la suite. Et on voit aussi comment appliquer la macro.
Il ne reste plus qu’à mettre ceci en oeuvre dans un programme tortue. On peut par exemple lever le stylo et masquer tous les points, avant de construire dans une nouvelle boucle les segments et les quarts de cercle voulus (à la fin, il faut gérer le "trou" du début).

  1. function cote(x,n) {
  2. if (n>0) {
  3. p = Avancer(x/3)[0]; Cacher(p);
  4. points.push(p);
  5. forme.push(0);
  6. TournerGauche(90);
  7. cote(x/3,n-1);
  8. TournerDroite(90);
  9. cote(x/3,n-1);
  10. TournerDroite(90);
  11. cote(x/3,n-1);
  12. TournerGauche(90);
  13. p = Avancer(x/3)[0]; Cacher(p);
  14. points.push(p);
  15. forme.push(1);
  16. }
  17. }
  18.  
  19. AttacherTortue("A");
  20. LeverStylo();
  21. VitesseTortue(50);
  22.  
  23. points=[];
  24. forme=[];
  25. segments=[];
  26. pour i allant de 1 à 4 {
  27. cote(1,4);
  28. TournerDroite(90);
  29. }
  30.  
  31. for (i=0; i<points.length; i++){
  32. segments[i]=1;
  33. }
  34.  
  35. nbPtsCarres=0;
  36. for (i=0; i<points.length; i++){
  37. if (forme[i]==1) {
  38. nbPtsCarres++;
  39. }
  40. else {
  41. if ((nbPtsCarres>2)&&(i>1)) {
  42. ExécuterMacro("quartCercle",points[i-2]+","+points[i-1]+","+points[i]);
  43. segments[i]=0;
  44. segments[i-1]=0;
  45. }
  46. nbPtsCarres=0;
  47. }
  48. }
  49.  
  50. if (forme[0]==1) nbPtsCarres++;
  51. else {
  52. if (nbPtsCarres>2) {
  53. ExécuterMacro("quartCercle",points[points.length-2]+","+points[points.length-1]+","+points[0]);
  54.  
  55. segments[points.length-1]=0;
  56. segments[0]=0;
  57. nbPtsCarres=0;
  58. }
  59. }
  60.  
  61. if (forme[1]==1) nbPtsCarres++;
  62. else {
  63. if (nbPtsCarres>2) {
  64. ExécuterMacro("quartCercle",points[points.length-1]+","+points[0]+","+points[1]);
  65. segments[1]=0;
  66. segments[0]=0;
  67. nbPtsCarres=0;
  68. }
  69. }
  70.  
  71. if (segments[0]==1) Segment("A",points[0]);
  72. for (i=1; i<points.length; i++){
  73. if (segments[i]==1) Segment(points[i-1],points[i]);
  74. }

Télécharger

CarMetal - 2.2 ko

la tortue de DGPad

Type :
- dynamique+
- fulgurante

Yves Martin a décrit en détail la tortue de DGPad dans cet article déjà cité, dont la lecture est fortement recommandée. On se limitera ici à une méta-analyse de cette tortue.
On peut noter qu’Yves considère que la tortue de DGPad est une "tortue dynamique" pour plusieurs raisons, dont l’une, nécessaire, est qu’elle a une vitesse infinie. Selon lui, la tortue de DGPad est l’archétype de la tortue dynamique, et sa seule déclinaison (au moment de l’écriture de cet article).
C’est un point (de vocabulaire) sur lequel nous ne sommes pas vraiment d’accord.
Selon moi, la vitesse infinie de la tortue de DGPad relève d’un autre concept, celui de fulgurance. Et la tortue de DGPad est de type dynamique(+) et fulgurante.

La tortue de DGPad est dynamique car elle est dynamiquement liée à ses paramètres.
Elle est fulgurante car elle a une vitesse infinie. Mais qu’est-ce que l’on entend exactement par une « vitesse infinie » ?! Aucun logiciel n’a une vitesse infinie.
En fait, c’est tout le logiciel DGPad que l’on peut qualifier de fulgurant, et en particulier les DGPadScripts et les listes de points. Ces deux structures sont composées d’éléments construits un par un selon un ordre linéaire, mais le logiciel ne livre pas les états intermédiaires de la construction. Il affiche seulement le résultat final (tous les éléments).
En quoi est-ce que cela est fulgurant ? C’est fulgurant parce que si l’on si prend bien, le résultat est beaucoup plus rapide que si l’on affiche les états intermédiaires.

Par ailleurs, si l’on schématise, la tortue de CaRMetal est un script alors que celle de DGPad est une liste de points (donc un objet géométrique de DGPad), ce qui rend possible l’actualisation immédiate de la trace de la tortue lors des modifications des paramètres (dans un script classique, il faut annuler le script et le relancer). Cette caractéristique octroie un dynamisme supplémentaire à la tortue de DGPad, il faut bien le reconnaître (et cela donne raison à Yves contre moi).
On notera par ailleurs que la tortue de DGPad n’est pas mutante (mais elle l’est partiellement et de subtils mécanismes alternatifs permettent de reconquérir une bonne partie du terrain perdu).


notes

[1Des personnes très avisées recommandent plutôt Snap ! que Scratch. Et Snap ! propose un bloc remplir qui permet de colorier un polygone. Mais le fonctionnement de ce bloc n’est pas forcément très convaincant : il s’agit de lever le stylo et de déplacer la tortue pour qu’elle pointe sur l’intérieur du polygone, puis de remplir la zone (avant de revenir à la position initiale). Le remplissage de DGPad ou celui de GéoTortue (dans une moindre mesure) me semble nettement plus satisfaisant. Cela étant, pour cette activité on peut quand-même recommander Snap ! plutôt que Scratch, en particulier pour sa gestion en pop up des blocs personnalisés, qui est plus claire et structurante.

[2Il existe une tortue GeoGebra, mais celle-ci n’est pas dynamique : elle trace une trajectoire comme le faisait la tortue Logo et s’adresse surtout aux nostalgiques. On peut trouver des exemples réalisés par Noël Lambert dans les ressources du site GeoGebra.org

[3En revanche, les couleurs des polygones (carapace , tête et pattes) sont « fixées » lors de la création de la tortue par l’instruction AttacherTortue. Il s’agit de paramètres statiques en java, et donc si successivement 1) on lance un script qui crée la tortue, 2) on modifie les couleurs dans la barre de propriétés, 3) on annule le script, alors on dispose d’une tortue avec des couleurs différentes.

[4C’est l’observation des mœurs de mes collègues d’EPS qui m’en a donné l’idée.

[5Pour une vitesse de 0, le logiciel plante, pour ma plus grande honte. Ce n’est pas ce que j’avais prévu... Envie soudaine de disparaître... Ce sera rectifié dans la prochaine version.

[6On notera à ce sujet que la comptine "Quand j’avance tu recules, ..." dénote une mauvaise compréhension du paradigme de la tortue.

[8dont on n’est pas obligé d’être fan...

[9Cela semble aller de soi, mais ce ne sera pas le cas avec la tortue de CaRMetal

[10Dans GeoGebra, on a maintenant le confort de disposer de ce(s) patron(s) (pour de nombreux solides) sans avoir à les construire. Mais on peut aussi considérer que c’est frustrant de s’en remettre au logiciel.

[11Antibug CaRMetal : la manipulation conjointe de la palette Contrôles et du déplacement 3D peut créer un blocage (bug). Une parade à connaître consiste à enregistrer la figure, puis à la fermer et à la réouvrir.

Réagir à cet article
Vous souhaitez compléter cet article pour un numéro futur, réagir à son contenu, demander des précisions à l'auteur ou au comité de rédaction...
À lire aussi ici
MathémaTICE est un projet
en collaboration avec
Suivre la vie du site Flux RSS 2.0  |  Espace de rédaction  |  Nous contacter  |  Site réalisé avec: SPIP  |  N° ISSN 2109-9197