Code-source


00001     <?php     

00002     #   # (gH)   -_-  aif.php  ;  TimeStamp (unix) : 15 Avril 2017 vers 20:58     

00003     include("std.php") ;     

00004     debutPage("G-ALG : pourquoi G-ALG ? (gH)","std.css") ;     

00005     $GALG = ghRouge("G-ALG") ;     

00006     blockquote() ;     

00007     debutSection("80%") ;     

00008          

00009     p() ;     

00010      echo s_span("&nbsp;&nbsp;&nbsp;".b($GALG)."&nbsp;:&nbsp;","gros_car") ;     

00011      echo s_span(ghRouge("G")."estion","gros_car") ;     

00012      echo s_span("&nbsp;d'".ghRouge("ALG")."orithmes&nbsp;","gros_car") ;     

00013     finp() ;     

00014          

00015     p() ;     

00016     nbsp(25) ;     

00017     echo b(s_span("&nbsp;gilles.hunault@univ-angers.fr","vert plusgros")) ;     

00018     finp() ;     

00019          

00020     p() ;     

00021      echo s_span("&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;pourquoi $GALG&nbsp;?","bleuf gros_car") ;     

00022     finp() ;     

00023          

00024     blockquote() ;     

00025          

00026     div("gauche") ;     

00027     hr("hrgalg") ;     

00028     findiv() ;     

00029          

00030     #  préparation des rubriques (l'indice 0 est volontairement vide)     

00031          

00032     $tableauDesRubriques = array() ;     

00033     $idr = 0 ;     

00034     $idr++; $tableauDesRubriques[$idr] = "Nécessité d'un langage algorithmique" ;     

00035     $idr++; $tableauDesRubriques[$idr] = "Choix d'un langage algorithmique" ;     

00036     $idr++; $tableauDesRubriques[$idr] = "Multiplicité et qualité des solutions en algorithmique" ;     

00037     $idr++; $tableauDesRubriques[$idr] = "Extensions naturelles" ;     

00038     $idr++; $tableauDesRubriques[$idr] = "Comment enseigner le développement informatique, la programmation et l'algorithmique&nbsp;?" ;     

00039          

00040     # noubel objet table des matières     

00041          

00042     $tdmCRLM = new tdm($tableauDesRubriques) ;     

00043          

00044     # affichage du titre     

00045          

00046     $tdmCRLM->titre() ;     

00047          

00048     $tdmCRLM->menu("oui","oui") ;     

00049          

00050          

00051     ##########################################################################################     

00052          

00053     $tdmCRLM->afficheRubrique("oui") ; # 1. Nécessité d'un langage algorithmique     

00054          

00055     ##########################################################################################     

00056          

00057     blockquote() ;     

00058          

00059     p("texte") ;     

00060     echo "Tout programme met en oeuvre une ".ghRouge("méthode").", des ".ghRouge("idées").", \n" ;     

00061     echo "ce qui signifie que tout programme repose sur un algorithme, qu'il soit implicitement présent dans \n" ;     

00062     echo "les neurones du programmeur ou explicitement transcrit sous forme de texte dans un fichier. Dès lors qu'il existe, \n" ;     

00063     echo "pourquoi ne pas l'écrire rigoureuseument&nbsp;? La traduction de l'algorithme en programme, \n" ;     

00064     echo "traduction non pas mécanique mais fine, adaptée aux finesses \n" ;     

00065     echo "(ou aux roueries) du langage, voire du système d'exploitation, en sera facilitée. \n" ;     

00066     #echo "voire reléguée à d'autres programmeuses ou programmeurs, notamment à des programmes de traduction qui assureront une \n" ;     

00067     #echo "première version exécutable que les spécialistes du langage pourront optimiser, peaufiner. \n" ;     

00068     finp() ;     

00069          

00070     p("texte") ;     

00071     echo "Un langage algorithmique est donc, selon nous, ".ghRouge("obligatoire").", à la fois pour s'affranchir de la machine, des langages \n" ;     

00072     echo "de programmation et pour formaliser le travail à accomplir, pour spécifier l'enchainement des actions, \n" ;     

00073     echo "nommer les variables... ou pour discuter de la méthode, vérifier qu'on traite bien tous les cas.\n" ;     

00074     finp() ;     

00075          

00076     p("texte") ;     

00077     echo "Lorsqu'on veut enseigner le développement informatique " ;     

00078     echo " -- ce qui est beaucoup plus vaste que d'enseigner juste la programmation dans un langage donné -- " ;     

00079     echo " la première étape est d'expliciter comment on passe du problème posé à une solution, voire à plusieurs solutions. " ;     

00080     echo " Il ne s'agit pas de montrer, laissons ce soin à la philosophie, comment penser mais bien " ;     

00081     echo " comment raisonner comme un ordinateur et " ;     

00082     echo b("décrire et tester les actions à enchainer pour obtenir un résultat donné") ;     

00083     echo " avec un niveau de détail correspondant à celui des instructions élémentaires de l'algorithmique." ;     

00084     finp() ;     

00085          

00086     p("texte") ;     

00087     echo " Si on veut en plus utiliser un langage algorithmique dans le but d'".ghVert("enseigner la programmation").", il faut un langage clair, " ;     

00088     echo " facilement compréhensible par des débutants, qualités que n'ont pas les langages réels. Pour dialoguer " ;     

00089     echo ghVert("entre humains").", il faut un langage humain simplifié. Or les langages comme C, C++, Perl, Python, R... n'ont pas été conçus pour cela." ;     

00090     echo " Pour dialoguer ".ghVert("entre français").", il faut un langage en français simplifié. " ;     

00091     echo " Là encore, C, C++, Perl, Python, R... ne répondent pas à cette attente. " ;     

00092     finp() ;     

00093          

00094     p("texte") ;     

00095     echo ghBleu("Ecrire un algorithme est un travail structuré, réfléchi.") ;     

00096     echo " Le langage algorithmique doit obéir à des règles strictes de vocabulaire, de syntaxe et de sémantique. \n" ;     

00097     echo " Le risque à trop formaliser, à trop imposer, est de définir un langage algorithmique \n" ;     

00098     echo " trop proche d'un langage de programmation, voire de confondre le langage algorithmique \n" ;     

00099     echo " avec un langage de programmation francisé, perdant à la fois souplesse, concision et lisibilité. \n" ;     

00100     echo " On pourra consulter à ce sujet la page ".href("vss.php","&laquo;les aventures de Guillemet et Point-virgule&raquo;","grouge").".\n" ;     

00101     finp() ;     

00102          

00103     finblockquote() ;     

00104          

00105     ##########################################################################################     

00106          

00107     $tdmCRLM->afficheRubrique("oui") ; # 2. Choix d'un langage algorithmique     

00108          

00109     ##########################################################################################     

00110          

00111     blockquote() ;     

00112          

00113     p("texte") ;     

00114     echo "Que doit donc contenir un langage algorithmique simple, souple mais complet&nbsp;? " ;     

00115     echo " Certainement pas toute l'algorithmique, mais ".ghVert("le noyau \"dur\" de l'algorithmique impérative fondamentale").", " ;     

00116     echo " c'est-à-dire la partie commune à la plupart des langages comme C, Java, Javascript, Pascal, Perl, Php, Python, Rexx, R, Ruby... " ;     

00117     echo " Il doit donc permettre l'écriture de commentaires, réaliser des affectations, des tests et des boucles, " ;     

00118     echo " utiliser des tableaux, disposer d'un mécanisme de définition et d'appel de sous-programmes. ".b("Pas plus")."." ;     

00119     finp() ;     

00120          

00121     p("texte") ;     

00122     echo "Un tel langage -- et il ne pourra pas servir d'introduction pour des langages \"spéciaux\" comme " ;     

00123     echo " APL, Lisp, Prolog ou Sql -- ne doit donc pas utiliser de pointeurs, ni des structures de données trop " ;     

00124     echo " compliquées car ces éléments ne font pas partie du \"coeur\" de l'algorithmique impérative fondamentale. " ;     

00125     echo " Au contraire, la notion simple de tableau \"naturel\" avec des indices qui commencent à 1 est importante et doit &ecirc;tre suffisante à ce titre " ;     

00126     echo " car elle est pédagogique, intuitive&nbsp;: quand on compte sur ses doigts, on commence à 1... " ;     

00127     echo " De m&ecirc;me, la notion de ".ghRouge("sous-programme")." doit pouvoir tout masquer ".ghRouge("avec une syntaxe unifiante").". Vouloir exposer l'indirection " ;     

00128     echo " doit pouvoir s'écrire avec une fonction ".b("pointeur(x)").", désigner le fils gauche de l'élement courant dans un arbre binaire " ;     

00129     echo " peut se formaliser via ".b("filsGauche(arbreBin,eltCour)")." s'il faut vraiment introduire ces notions... " ;     

00130     finp() ;     

00131          

00132     p("texte") ;     

00133     echo "A nos yeux, apprendre à écrire des algorithmes c'est ".ghBleu("s'astreindre à une grande rigueur, une grande précision").". " ;     

00134     echo " C'est aussi compléter le code écrit par " ;     

00135     echo ghBleu(" une analyse de l'exhaustivité")." de la solution et avec ".ghBleu("une vérification via autant de tests que nécessaires").". " ;     

00136     #echo " C'est aussi découvrir (ou s'entrainer) à l'exhaustivité. " ;     

00137     echo " Si on doit comparer 3 valeurs, combien d'étudiant(e)s " ;     

00138     echo " savent combien de cas il faut envisager, par exemple en supposant les valeurs distinctes&nbsp;?" ;     

00139     echo " Ce n'est pas un langage algorithmique ou un langage réel de programmation qui donne la réponse parce qu'il s'agit d'un " ;     

00140     echo " problème d'analyse combinatoire. Mais seul un langage algorithmique permet de ne pas se focaliser " ;     

00141     echo " sur le typage et les nombreuses relations d'ordre sous-jacentes aux types. " ;     

00142     echo " Seul un ".href("validalg.php","système de validation","nou gvert")." qui connait tous les cas possibles et qui vérifie l'exactitude du code pour chaque cas " ;     

00143     echo ghVert(" garantit la qualité de l'algorithme")."." ;     

00144     finp() ;     

00145          

00146     p("texte") ;     

00147     echo "C'est pourquoi nous proposons le système pédagogique $GALG " ;     

00148     echo " avec son le langage nommé ".b("GALG")." qui n'est ni original ni ésotérique&nbsp;: il doit juste &ecirc;tre vu " ;     

00149     echo " comme une formalisation de l'intersection de la plupart des instructions impératives. Sa ressemblance avec tous les langages " ;     

00150     echo " existants via l'instruction ".b("SI")." pour un test, l'instruction ".b("POUR")." pour une boucle à nombre déterminé d'itérations ".em("etc.")." est voulue et le " ;     

00151     echo " rend facile à apprendre et à traduire. " ;     

00152     finp() ;     

00153          

00154     p("texte") ;     

00155     echo " Par contre, son point fort, et il ne pas transiger sur ce point, est qu'il est ".ghRouge("écrit en français")." " ;     

00156     echo " et que les messages d'erreurs, cohérents et succints, sont ".ghRouge("aussi écrits en français").". " ;     

00157     echo " Il n'y a pas en $GALG de ".b(em("&laquo;unexpected end of file&raquo;"))." quand il manque un guillemet mais bien un message parlant d'une erreur de guillemet." ;     

00158     finp() ;     

00159          

00160     p("texte") ;     

00161     echo " Nombre d'enseignants de mathématiques ne se rendent pas toujours compte de la difficulté à mémoriser la règle des signes quand on a " ;     

00162     echo " une dizaine d'années. De m&ecirc;me, nombre d'enseignants en informatique, au bout de plusieurs années d'utilisation des " ;     

00163     echo " langages classiques, ne se rendent pas compte que les étudiants ont déjà du mal à choisir le type d'instruction (test en ".b("SI")  ;     

00164     echo " ou boucle ".b("TANT QUE")."&nbsp;?). Alors leur demander d'écrire directement ".em(b("IF"))." ou ".em(b("WHILE"))." est très compliqué. " ;     

00165     echo " La m&ecirc;me remarque s'applique à la syntaxe \"".ghRouge("évidente")."\" des expressions parenthésées " ;     

00166     echo " et des combinaisons logiques avec des ".b("ET")." et des ".b("OU") ;     

00167     echo " quand on les pratique depuis une décennie mais qui est  " ;     

00168     echo " en fait ".ghRouge("incompréhensible")." quand on débute, sans parler des symboles " ;     

00169     echo b("!&amp;|^").", ".b("[")." ou ".b("{")." que les étudiants n'ont jamais utilisé sur le clavier " ;     

00170     echo " et du point-virgule dont on ne sait jamais si c'est un séparateur ou un terminateur..." ;     

00171     finp() ;     

00172          

00173     p("texte") ;     

00174     echo " Pour vous rendre compte de la difficulté à faire deux choses en m&ecirc;me temps, vous pouvez essayer de comprendre pourquoi, en ".ghvert("APL") ;     

00175     echo " le code " ;     

00176     finp() ;     

00177          

00178     p("cadrebleu demiLargeur") ;     

00179     nbsp(5) ;     

00180     echo b("+/V&divide;&rho;V&nbsp;&larr;&nbsp;?&nbsp;10&nbsp;&rho;50") ;     

00181     finp() ;     

00182          

00183     p("texte") ;     

00184     echo " s'optimise en " ;     

00185     finp() ;     

00186          

00187     p("cadrejaune demiLargeur") ;     

00188     nbsp(5) ;     

00189     echo b("(+/V)&divide;&rho;V&nbsp;&larr;&nbsp;?&nbsp;10&nbsp;&rho;50") ;     

00190     finp() ;     

00191          

00192     p("texte") ;     

00193     echo " tout en écrivant ce code à l'aide du site ".href("https://tryapl.org/","TryAPL")." sachant que le schéma du clavier est " ;     

00194     echo href("clavierApl.png","ci-dessous")."... " ;     

00195     finp() ;     

00196          

00197     p() ;     

00198     $img = "clavierApl.png" ;     

00199     nbsp(5) ;     

00200     echo href($img,img($img,"",800)) ;     

00201     finp() ;     

00202          

00203     p("texte") ;     

00204     echo " De m&ecirc;me, si, en tant que programmeur ".ghRouge("R")." expérimenté, on peut écrire les yeux fermés et sans y penser une " ;     

00205     echo " expression comme " ;     

00206     finp() ;     

00207          

00208     pre_fichier("expr1.txt","cadre") ;     

00209          

00210     p("texte") ;     

00211     echo "il est clair qu'en initiation cela se révélera catastrophique et qu'il faut sans doute détailler la génération des indices, " ;     

00212     echo " le formatage des nombres entiers, la concaténation, et donc, écrire, de façon progressive, pour obtenir " ;     

00213     echo " le m&ecirc;me résultat, les instructions qui suivent&nbsp;:" ;     

00214     finp() ;     

00215          

00216     pre_fichier("expr2.txt","cadrebleu") ;     

00217          

00218     p("texte") ;     

00219     echo "Voici ce que cela produit sur un exemple avec les deux codes&nbsp;:" ;     

00220     finp() ;     

00221          

00222     pre_fichier("expr3.txt","cadrejaune") ;     

00223          

00224     p("texte") ;     

00225     echo " On consultera la page ".href("vss.php","VSS","gbleuf")." concernant les choix retenus dans $GALG " ;     

00226     echo " pour avoir un langage simple et lisible." ;     

00227     finp() ;     

00228          

00229     finblockquote() ;     

00230          

00231     ##########################################################################################     

00232          

00233     $tdmCRLM->afficheRubrique("oui") ; # 3. Multiplicité et qualité des solutions en algorithmique     

00234          

00235     ##########################################################################################     

00236          

00237     blockquote() ;     

00238          

00239     p("texte") ;     

00240     echo " Contrairement aux mathématiques, où par exemple l'équation ".b("x+1=0")." n'admet qu'une seule solution ".b("x=-1").", " ;     

00241     echo " il y a toujours une multiplicité de solutions et d'écritures en algorithmique. " ;     

00242     echo " Ainsi pour garder une copie de la variable ".b("NBE").", on peut utiliser une variable nommée ".b("sauveNBE") ;     

00243     echo " ou la nommer ".b("NBE_copie").". " ;     

00244     echo " De m&ecirc;me, l'instruction" ;     

00245     finp() ;     

00246          

00247     pre_fichier("si1.txt","cadre") ;     

00248          

00249     p("texte") ;     

00250     echo " est strictement équivalente à l'instruction " ;     

00251     finp() ;     

00252          

00253     pre_fichier("si2.txt","cadre") ;     

00254          

00255     p("texte") ;     

00256     echo " pour les cas usuels." ;     

00257     finp() ;     

00258          

00259     p("texte") ;     

00260     echo " Il nous semble qu'enseigner l'algorithmique, c'est-à-dire ".ghRouge("la résolution informatisée de problèmes au sens large").", doit inclure " ;     

00261     echo " cette réflexion. Ainsi, \"la\" bonne solution élémentaire au problème " ;     

00262     echo  b(s_span(em("&laquo;comment trouver le plus petit et le plus grand élément d'une liste (au sens usuel du terme) de valeurs&nbsp;?&raquo;"),"bleu")) ;     

00263     echo " est bien s&ucirc;r ".b(s_span(em("&laquo;trier la liste par ordre croissant&raquo;"),"vert"))." car le premier élément est alors le plus petit et " ;     

00264     echo " le dernier est le plus grand. Une solution avec parcours explicite de la liste est souvent ce qui est demandé par les enseignants, mais " ;     

00265     echo " ce n'est pas la solution la plus immédiate, au niveau conceptuel. " ;     

00266     finp() ;     

00267          

00268     p("texte") ;     

00269     echo "C'est pourquoi le langage algorithmique doit permettre toutes les solutions. Il n'est pas difficile d'imaginer une " ;     

00270     echo " fonction nommée ".b("TRI")." m&ecirc;me si elle est sans doute difficile à écrire si le tri est multi-critères. " ;     

00271     echo " Qu'un \"vrai\" langage donné dispose d'une telle fonction et qu'on sache bien l'utiliser " ;     

00272     echo " (penser par exemple à la difficulté de faire comprendre la transformée schwarzienne en ".ghRouge("Perl").") est un autre problème. " ;     

00273     finp() ;     

00274          

00275     p("texte") ;     

00276     echo "Selon nous, faire chercher plusieurs solutions et en discuter les avantages et les inconvénients " ;     

00277     echo " doit faire très rapidement partie de l'enseignement de l'algorithmique impérative fondamentale car " ;     

00278     echo " cela développe le sens de l'analyse, de la recherche et de la comparaison de solutions. " ; #(pas propre, pas clair ?)" ;     

00279     # prépare au développement " ; echo " informatique.     

00280     echo " Le langage $GALG sert \"juste\" à formaliser ces solutions." ;     

00281     finp() ;     

00282          

00283     p("texte") ;     

00284     echo ghBleu(" Comment tester alors et valider un algorithme&nbsp;?")." La réponse qui s'impose sans doute (pour une fois, soyons modeste&nbsp;!) est " ;     

00285     echo " de passer par un ".b("cahier des charges très précis").". " ;     

00286     echo " Cela signifie notamment qu'il faut nommer les variables à utiliser, fixer parfois les règles du jeu, " ;     

00287     echo " en interdisant (pas de boucle POUR...), " ;     

00288     echo " ou en imposant (on utilisera la fonction SOMME()...), " ;     

00289     echo " afin de guider les apprenant(e)s là où on veut qu'ils ou elles aillent dans la résolution pour que l'ordinateur soit en mesure de vérifier le code." ;     

00290     echo " On pourra consulter les exercices dans ".href("Catalogue/","notre catalogue","gvert nou") ;     

00291     echo " pour avoir une idée de ce que cela implique comme travail de travail pour l'enseignant. " ;     

00292     finp() ;     

00293          

00294     p("texte") ;     

00295     echo " Heureusement pour les enseignant(e)s, tout ne peut pas &ecirc;tre testé, validé. Ainsi la qualité des commentaires, leur adéquation " ;     

00296     echo " avec le code ne sont pas validables, que ce soit dans notre système pédagogique ou via n'importe quel ordinateur parce que cela  " ;     

00297     echo " demande de comprendre la langue écrite, ce qui va bien au-delà d'une vérification d'une égalité de contenus de variables. " ;     

00298     finp() ;     

00299          

00300     finblockquote() ;     

00301          

00302     ##########################################################################################     

00303          

00304     $tdmCRLM->afficheRubrique("oui") ; # 4. Extensions naturelles     

00305          

00306     ##########################################################################################     

00307          

00308     blockquote() ;     

00309          

00310     p("texte") ;     

00311     echo " Il est clair pour nous qu'au-delà de l'algorithmique élémentaire, il y a non pas une algorithmique avancée mais des algorithmiques avancées. " ;     

00312     echo " Selon l'enseignant(e), une fois les bases posées du socle commun, on peut envisager&nbsp;:" ;     

00313     finp() ;     

00314          

00315     ul() ;     

00316          

00317       debutli() ; p("texte") ;     

00318         echo " d'approfondir l'écriture de sous-programmes, fonctions et procédures, puis présenter la récursivité, la complexité, les fonctions anonymes, le passage " ;     

00319         echo " de paramètres par nom plut&ocirc;t que par position, la notion d'évènement et de ".em("call-back") ;     

00320         echo "&nbsp;;" ;     

00321       finp() ; finli() ;     

00322          

00323       debutli() ; p("texte") ;     

00324         echo " d'introduire l'utilisation (et la ré-implémentation&nbsp;?) des structures de données comme les piles, les files, les queues, les arbres, les graphes" ;     

00325         echo "&nbsp;;" ;     

00326       finp() ; finli() ;     

00327          

00328       debutli() ; p("texte") ;     

00329         echo " de se focaliser sur la résolution de problèmes via l'utilisation de bibliothèques de sous-programmes données&nbsp;: " ;     

00330         echo " sur le site ".href("https://www.rdocumentation.org/trends","rdocumentation").", on accède à " ;     

00331         echo " plus de 2 millions de fonctions ".ghRouge("R")." réparties dans plus de 15&nbsp;000 \"packages\", comme " ;     

00332         echo " les fonctions ".ghBleu("read.xls()").", ".ghBleu("connectedComponents()")." ou ".ghBleu("longestCommonSubsequence()")." à titre d'exemple " ;     

00333         echo " qui sont sans doute utiles -- mais difficiles à ".b("bien")." ré-implémenter&nbsp;;" ;     

00334         echo " sur le site ".href("https://pypi.org/","pypi")." on trouve plus d'un millions de fichiers répartis sur " ;     

00335         echo " plus de 130&nbsp;000 projets ".ghRouge("Python") ;     

00336         echo "&nbsp;;" ;     

00337       finp() ; finli() ;     

00338          

00339       debutli() ; p("texte") ;     

00340         echo " d'insister le traitement de chaines de caractères, les dates et leurs fonctions, les expressions régulières, les conversions, les encodages et l'écriture multilingue" ;     

00341         echo "&nbsp;;" ;     

00342       finp() ; finli() ;     

00343          

00344       debutli() ; p("texte") ;     

00345         echo " d'introduction le typage, la représentation en machine, l'indirection, les pointeurs, les tables de hachage, le cryptage" ;     

00346         echo "&nbsp;;" ;     

00347       finp() ; finli() ;     

00348          

00349       debutli() ; p("texte") ;     

00350         echo " de présenter la programmation fonctionnelle, la programmation logique, la programmation littérale..." ;     

00351       finp() ; finli() ;     

00352          

00353     finul() ;     

00354          

00355          

00356     p("texte") ;     

00357     echo "Le langage de $GALG n'a pas pour vocation d'aller aussi loin. Il sert de premier langage, " ;     

00358     echo " comme les premiers livres de l'enfance. " ;     

00359     finp() ;     

00360          

00361     p("texte") ;     

00362     echo " Au-delà, il faut passer au choix ".b("difficile")." du langage réel et de la traduction " ;     

00363     echo " de l'algorithme dans ce langage, choix souvent escamoté par les enseignants. Ainsi, pour passer de plusieurs fichiers formatés en " ;     

00364     echo " prénom, nom comme " ;     

00365     finp() ;     

00366          

00367     pre_fichier("ids1.txt","cadre") ;     

00368          

00369     p("texte") ;     

00370     echo " aux fichiers formatés avec le nom en premier, comme " ;     

00371     finp() ;     

00372          

00373     pre_fichier("ids2.txt","cadre") ;     

00374          

00375     p("texte") ;     

00376     echo " combien d'enseignants d'informatique prennent le temps et font l'effort d'expliquer que le langage ".b("AWK")." est le plus adapté " ;     

00377     echo " et que ".b("C").", ".b("C++")." ou ".b("Java").", ".b("Perl").", ".b("Python")."...  ne sont pas les bienvenus ici, sauf à titre d'exercice&nbsp;? " ;     

00378     finp() ;     

00379          

00380     finblockquote() ;     

00381          

00382     ##########################################################################################     

00383          

00384     $tdmCRLM->afficheRubrique("oui") ; # 5. Comment enseigner le développement informatique, la programmation et l'algorithmique ?     

00385          

00386     ##########################################################################################     

00387          

00388     blockquote() ;     

00389          

00390     p("texte") ;     

00391     echo "Un(e) mathématicien(ne) qui utilise ".ghRouge("Maple").", " ;     

00392     echo " un(e) biologiste confrontée à ".ghRouge("R")." pour des statistiques élémentaires, " ;     

00393     echo " un(e) physicien(ne) mettant au point un script ".ghRouge("Scilab").", " ;     

00394     echo " un développeur Web avec ses programmes ".ghRouge("Php")." et ".ghRouge("Javascript").", " ;     

00395     echo " un(e) bioinformaticien(ne) qui interface du code ".ghRouge("Python")." et ".ghRouge("Perl") ;     

00396     echo " n'ont pas besoin de pointeurs, de ".ghRouge("Java")." ou de ".ghRouge("C++").". " ;     

00397     echo " Et ce qu'ils/elles font est aussi \"noble\" qu'un programme d'optimisation ou d'intelligence artificielle." ;     

00398     echo " Selon nous, enseigner l'algorithmique doit tenir compte de l'ensemble des langages et de leur " ;     

00399     echo " quasi-intersection minimale. " ;     

00400     finp() ;     

00401          

00402     p("texte") ;     

00403     echo "Le plus important, dans un premier temps, est de montrer comment réfléchir à un problème, ";     

00404     echo " comment trouver au moins une solution \"à la main\", comment la décrire pour pouvoir la coder. " ;     

00405     echo " C'est pourquoi ".ghBleu("dire la méthode à utiliser")." est une étape importante, plus proche de la rédaction " ;     

00406     echo " littéraire que du codage en assembleur. Si on rédigeait bien la méthode, les ordinateurs seraient " ;     

00407     echo " capables de programmer d'eux-m&ecirc;mes la solution, un peu comme en ".ghRouge("Prolog") ;     

00408     echo " quand on sait comment rédiger ses connaissances déclaratives. ";     

00409     echo " Décrire la méthode en termes de parcours, d'énumérations, de tests..." ;     

00410     echo " permet de mettre du recul, d'avoir presque un regard ".em("extradiégétique")." sur le problème à résoudre. " ;     

00411     finp() ;     

00412          

00413     p("texte") ;     

00414     echo "Dans un second temps, ".ghBleu("l'entrainement à lire des algorithmes")." plut&ocirc;t que d'écrire des algorithmes " ;     

00415     echo " nous parait souvent sous-estimé. Que font les enfants au CP&nbsp;? Ils commencent par lire des phrases avant " ;     

00416     echo " d'en écrire. Pour l'algorithmique, cela devrait &ecirc;tre pareil. " ;     

00417     echo ghBleu(" Demander à un(e) étudiant(e) de dérouler un algorithme ligne par ligne")." est bien plus formateur qu'on ne le croit " ;     

00418     echo " au premier abord. " ;     

00419     finp() ;     

00420          

00421     p("texte") ;     

00422     echo " Ensuite, ".ghBleu("faire modifier des algorithmes")." est aussi très important. Par exemple donner un algorithme qui " ;     

00423     echo " trouve la première occurrence du maximum et le faire modifier pour qu'il en trouve la dernière occurrence révèle " ;     

00424     echo " le soin et la précision qu'il faut apporter à la fois à l'algorithme et à sa documentation. Demander à trouver \"la\" position " ;     

00425     echo " du maximum se révèle &ecirc;tre un problème mal posé quand le maximum est présent plusieurs fois et qu'on résoud \"à la main\" ce problème." ;     

00426     finp() ;     

00427          

00428     p("texte") ;     

00429     echo ghBleu("Tester la robustesse d'un algorithme et son exhaustivité")." est la troisième étape. Il ne faut pas la négliger, car le risque est de fournir une solution partielle, " ;     

00430     echo " qui ne fonctionnera que dans des cas particuliers, ou pas pour tous les cas. Ouvrir un fichier pour le lire sans avoir vérifié qu'il existe, c'est manquer de " ;     

00431     echo " bon sens et ni l'algorithmique ni un langage particulier ne peuvent régler ce problème. " ;     

00432     echo " De m&ecirc;me, dans une conversion pouce/cm tester juste si l'unité est \"pouce\" est incomplet car \"pouce".ghRouge("s")."\" est sans doute " ;     

00433     echo "  acceptable aussi." ;     

00434     finp() ;     

00435          

00436     p("texte") ;     

00437     echo "L'enseignement de l'algorithmique doit donc passer par des ".ghRouge("exemples variés").", à lire d'abord, puis à modifier et à " ;     

00438     echo " écrire, enfin. " ;     

00439     finp() ;     

00440          

00441     p("texte") ;     

00442     echo ghVert("Réussir des exercices")." &laquo;".em("courts et naifs")."&raquo; met l'apprenant(e) en confiance, le rassure et le " ;     

00443     echo " gratifie (merci à la neuropyschologie pour son concept de récompense immédiate). " ;     

00444     echo " Encore faut-il disposer d'un ".ghVert("système de validation")." plus que de vérification, ce que nous fournissent pas les cours classiques  " ;     

00445     echo " et ".em("a fortiori")." les langages réels. Heureusement, $GALG est là pour valider..." ;     

00446     echo " Nous vous encourageons à regarder les premiers " ;     

00447     echo " exercices de notre catalogue, dans les différents modes et dans les différentes rubriques pour vous convaincre que " ;     

00448     echo " l'objectif visé n'est pas l'algorithmique en tant que telle mais bien la mise en confiance et la lecture de la syntaxe." ;     

00449     finp() ;     

00450          

00451     p() ;     

00452     echo b("Exemples&nbsp;:") ;     

00453     finp() ;     

00454          

00455     ul() ;     

00456       debutli() ; p() ;     

00457         echo href("Catalogue/listeJustesAmodifier.php#tdm1","les bonbons") ;     

00458         echo "&nbsp;: on pourra vérifier ".href("Interface/","dans l'interface")." que l'exécution de l'analyse affiche le bon résultat mais que la validation donne un score de 0&nbsp;%." ;     

00459       finp() ; finli() ;     

00460       debutli() ; p() ;     

00461         echo href("Catalogue/listeIncorrects.php#tdm1","calcul du périmètre") ;     

00462         echo "&nbsp;: attention, il n'y a pas d'affichage (et c'est voulu)." ;     

00463       finp() ; finli() ;     

00464       debutli() ; p() ;     

00465         echo href("Catalogue/alg-factur.php#tdm1","calcul du prix hors taxe") ;     

00466         echo " sachant le prix unitaire et le nombre d'articles..." ;     

00467       finp() ; finli() ;     

00468     finul() ;     

00469          

00470     p("texte") ;     

00471     echo ghBleu("Raffiner et optimiser un algorithme")." est souvent la dernière étape avant ".ghBleu("le passage à la traduction")." dans un langage existant de programmation." ;     

00472     echo " Cette traduction n'est d'ailleurs pas une mince affaire. Il est bien s&ucirc;r possible de traduire mot à mot, et c'est ce que permet \$"."GALG " ;     

00473     echo " mais ce n'est souvent pas une bonne traduction car chaque langage a ses spécificités. Ainsi, permuter le contenu des variables " ;     

00474     echo b("\$a")." et ".b("\$b")." en ".ghRouge("PHP") ;     

00475     echo " s'écrit \"anti-naturellement\" " ;     

00476     finp() ;     

00477          

00478     pre_fichier("permvar.php","cadre") ;     

00479          

00480     p("texte") ;     

00481     echo " Aucun cours d'algorithmique, aucun langage algorithmique, aucun dictionnaire de langages ne peut prétendre enseigner cette traduction, " ;     

00482     echo " pas plus qu'expliquer pourquoi l'expression française ".em("un bol de café")." se traduit en anglais par ".em("a cup of tea")." quand on ne connait pas les usages..." ;     

00483     echo " Enseigner la programmation en ".ghRouge("APL").", ".ghRouge("C").", ".ghRouge("Java").", ".ghRouge("CAML").", ".ghRouge("Javascript")."..." ;     

00484     echo " requiert de parler des spécificités du langage sous-jacent (absence de mots, présence de pointeurs, style fonctionnel, utilisation d'évènements...) " ;     

00485     echo " m&ecirc;me si le \"coeur\" du langage fait appel aux m&ecirc;mes concepts fondamentaux de variables, d'instructions, de boucles, de fonctions..." ;     

00486     finp() ;     

00487          

00488     p("texte") ;     

00489     echo " Donc $GALG ne peut et doit &ecirc;tre qu'une étape, importante, certes, mais non suffisante pour enseigner le développement. " ;     

00490     echo " Par contre, ce qu'il apporte, c'est une syntaxe précise avec la possibilité de vérification, de traduction élémentaire, voire d'exécution pour " ;     

00491     echo " savoir si la solution trouvée fonctionne..." ;     

00492     echo " Et les ".href("Catalogue/","exercices du catalogue")." fournissent une panoplie d'exercices à résoudre, pour s'entrainer. " ;     

00493     echo " De plus quand ils ont un modèle de validation, on est assuré que les tests garantissent la robustesse et l'exhaustivité du code." ;     

00494     finp() ;     

00495          

00496     p("texte") ;     

00497     echo "On trouvera plus d'explications sur le mécanisme de validation des algorithmes ".href("validalg.php","ici")."." ;     

00498     finp() ;     

00499          

00500     p("texte") ;     

00501     echo " A l'heure (2018) où l'algorithmique et la programmation commencent à &ecirc;tre systématiquement enseignées au lycée,  " ;     

00502     echo " à l'aide de ".b("Python")." notamment, via des interfaces comme ".href("http://www.xm1math.net/algobox/","AlgoBox") ;     

00503     echo " il est bon de rappeler qu'aucun langage, qu'aucune interface ne peut imposer " ;     

00504     echo " toutes les ".ghRouge("bonnes pratiques")." telles que&nbsp;:" ;     

00505     finp() ;     

00506          

00507     ul() ;     

00508          

00509     debutli() ; p() ;     

00510     echo "écrire des commentaires intra et extradiégétiques&nbsp;;" ;     

00511     finp() ; finli() ;     

00512          

00513     debutli() ; p() ;     

00514     echo "initialiser les variables (quand on doit les déclarer)&nbsp;;" ;     

00515     finp() ; finli() ;     

00516          

00517     debutli() ; p() ;     

00518     echo "indenter le code&nbsp;;" ;     

00519     finp() ; finli() ;     

00520          

00521     debutli() ; p() ;     

00522     echo "mettre les fins de structure sur des lignes séparées&nbsp;;" ;     

00523     finp() ; finli() ;     

00524          

00525     debutli() ; p() ;     

00526     echo "décomposer les actions à réaliser&nbsp;;" ;     

00527     finp() ; finli() ;     

00528          

00529     debutli() ; p() ;     

00530     echo "factoriser du code similaire&nbsp;;" ;     

00531     finp() ; finli() ;     

00532          

00533     debutli() ; p() ;     

00534     echo "afficher la date, l'heure, savoir calculer une durée entre deux dates     

00535     (pour prouver qu'un algorithme est plus rapide qu'un autre)&nbsp;;" ;     

00536     finp() ; finli() ;     

00537          

00538     debutli() ; p() ;     

00539     echo "résoudre \"à la main\" le problème, quitte à simplifier des étapes." ;     

00540     finp() ; finli() ;     

00541          

00542     finul() ;     

00543          

00544          

00545     p("texte") ;     

00546     echo " C'est pourquoi $GALG n'est pas qu'un langage, mais aussi un ensemble ".ghVert("d'exercices et de contraintes").", comme " ;     

00547     echo " pour le problème ".href("pmg.php","PMG")." ou l'interface de l'exercice ".href("Algorithmique/perimetre.php","périmètre").". " ;     

00548     echo " De plus la partie ".b("Analyse")." d'un algorithme ouvre le champ libre à tout type de contrainte pour induire la qualité du code. " ;     

00549     echo " Nous reproduisons ici un exemple d'une telle analyse&nbsp;:" ;     

00550     finp() ;     

00551          

00552     pre_fichier("aif-analyse.txt","cadrebleu") ;     

00553          

00554     p("texte") ;     

00555     echo "On trouvera dans le document ".href("Manuel/galg-vpl.pdf","galg-vpl.pdf"). " et sur la page " ;     

00556     echo href("galg-vpl.php") ;     

00557     echo " quelques éléments sur l'intégration de $GALG dans ".em("Moodle") ;     

00558     echo " à l'aide du plugin ".href("https://moodle.org/plugins/mod_vpl","VPL").". " ;     

00559     finp() ;     

00560          

00561     finblockquote() ;     

00562          

00563     ##########################################################################################     

00564          

00565          

00566     pvide() ;     

00567     p("pluspetit") ;     

00568     echo href("montresource.php?nomfic=aif.php","Code-source de cette page","orange_stim nou")."." ;     

00569     finp() ;     

00570          

00571     ##########################################################################################     

00572          

00573     finblockquote() ;     

00574     finSection() ;     

00575     finblockquote() ;     

00576     finPage() ;     

00577     ?>
Pour ne pas voir les numéros de ligne, ajoutez &nl=non à la suite du nom du fichier.
Listing du fichier aif.php
