Listing du fichier vss.php
00001 <?php
Pour ne pas voir les numéros de ligne, ajoutez &nl=non à la suite du nom du fichier. |
Retour à la page principale de
(gH)
Listing du fichier vss.php
00001 <?php
00002 # # (gH) -_- vss.php ; TimeStamp (unix) : 18 Juin 2018 vers 17:13
00003 include("std.php") ;
00004 debutPage("GALG : vocabulaire, syntaxe, sémantique","std.css") ;
00005 $GALG = ghRouge("G-ALG") ;
00006 blockquote() ;
00007 debutSection("100%") ;
00008
00009 p() ;
00010 echo s_span(" ".b($GALG)." : ","gros_car") ;
00011 echo s_span(ghRouge("G")."estion","gros_car") ;
00012 echo s_span(" d'".ghRouge("ALG")."orithmes ","gros_car") ;
00013 finp() ;
00014
00015 p() ;
00016 nbsp(25) ;
00017 echo b(s_span(" gilles.hunault@univ-angers.fr","vert plusgros")) ;
00018 finp() ;
00019
00020 $txth1 = "les aventures de Guillemet et Point-virgule" ;
00021 h1(" « $txth1 »","bleuf") ;
00022
00023 $txth2 = "(vocabulaire, syntaxe et sémantique dans $GALG)" ;
00024
00025 h2(s_nbsp(14).$txth2,"bleuf") ;
00026
00027 blockquote() ;
00028
00029 div("gauche") ;
00030 hr("hrgalg") ;
00031 findiv() ;
00032
00033 # préparation des rubriques (l'indice 0 est volontairement vide)
00034
00035 $tableauDesRubriques = array() ;
00036 $idr = 0 ;
00037 $idr++; $tableauDesRubriques[$idr] = "Enseigner un langage informatique comme une langue..." ;
00038 $idr++; $tableauDesRubriques[$idr] = "Oubli d'un guillemet, d'un point-virgule, d'une accolade..." ;
00039 $idr++; $tableauDesRubriques[$idr] = "Mini-anatomie de $GALG" ;
00040
00041 # noubel objet table des matières
00042
00043 $tdmCRLM = new tdm($tableauDesRubriques) ;
00044
00045 # affichage du titre
00046
00047 $tdmCRLM->titre() ;
00048
00049 $tdmCRLM->menu("oui","oui") ;
00050
00051
00052 ##########################################################################################
00053
00054 $tdmCRLM->afficheRubrique("oui") ; # 1. Enseigner un langage informatique comme une langue
00055
00056 ##########################################################################################
00057
00058 blockquote() ;
00059
00060 $urlCun = "https://fr.wikipedia.org/wiki/Cun%C3%A9iforme" ;
00061 $urlApl = "https://fr.wikipedia.org/wiki/APL_(langage)" ;
00062
00063 p("texte") ;
00064 echo "Un langage informatique et une langue écrite partagent beaucoup plus qu'on ne le pense généralement, " ;
00065 echo " sauf pour " ;
00066 echo href($urlApl,"APL") ;
00067 echo " et le ".href($urlCun,"cunéiforme").", bien sûr." ;
00068 finp() ;
00069
00070 # images cote cote égyptien et APL
00071
00072 table() ; # table(1,10,"collapse") ;
00073 tr() ;
00074 td() ;
00075 $img = "cuneiforme.jpg" ;
00076 $url = "http://collections.bm-lyon.fr/MIL_01CTF00101327MG02" ;
00077 p() ;
00078 nbsp(5) ;
00079 echo href($url,img($img,"",400)) ;
00080 finp() ;
00081 fintd() ;
00082 td() ;
00083 $img = "aplSudoku.png" ;
00084 $url = "https://tryapl.org/" ;
00085 p() ;
00086 nbsp(5) ;
00087 echo href($url,img($img,"",400)) ;
00088 finp() ;
00089 fintd() ;
00090 fintr() ;
00091 fintable() ;
00092
00093 p("texte") ;
00094 echo " Enseigner un langage informatique comme une langue doit se faire en tenant compte de ".ghRouge("deux différences majeures")." :" ;
00095 echo " il s'agit d'une langage écrit et le public, déjà un peu agé, sait lire, écrire et utiliser un ordinateur ou une tablette. " ;
00096 echo " La technique d'".ghBleu("immersion")." (voir beaucoup de code court, lire beaucoup de code court, écrire beaucoup de code court) " ;
00097 echo " est adaptée. Par contre au niveau de la grammaire, il faut certainement recourir plus rapidement au ".ghBleu("méta-langage") ;
00098 echo " (instructions, séquentialité...) qu'avec une langue en apprentissage oral pour un public jeune." ;
00099 finp() ;
00100
00101 p("texte") ;
00102 echo " En particulier, il faut utiliser très rapidement les termes précis de la ".b("grammaire")." pour aider les débutants " ;
00103 echo " à prendre du recul sur leur code afin de mieux le maitriser. Il ne faut donc pas hésiter " ;
00104 echo " à parler très tôt " ;
00105 finp() ;
00106
00107 ul() ;
00108
00109 debutli() ; p() ;
00110 echo "du ".ghVert("vocabulaire").", c'est-à-dire des mots possibles et des caractères spéciaux ;" ;
00111 finp() ; finli() ;
00112 debutli() ; p() ;
00113 echo " de la ".ghVert("syntaxe").", donc de l'ordre des mots pour faire des phrases et " ;
00114 echo " des règles de construction des instructions ;" ;
00115 finp() ; finli() ;
00116 debutli() ; p() ;
00117 echo " de la ".ghVert("sémantique").", qui permet d'attribuer un sens aux mots et aux symboles spéciaux." ;
00118 finp() ; finli() ;
00119
00120 finul() ;
00121
00122
00123 p("texte") ;
00124 echo "Le concept de séquentialité doit aussi être fortement souligné. Un enfant de trois ans sait dire " ;
00125 echo b("«moi manger maison papi»")." pour indiquer qu'il voudrait aller manger chez son grand-père, mais avec les " ;
00126 echo " quatre mêmes entités lexicales, il sait aussi dire " ;
00127 echo b("«papi manger maison moi»")." pour indiquer qu'il voudrait que son grand-père vienne manger chez lui " ;
00128 echo " si on admet qu'il s'agit ici aussi d'instructions, c'est-à-dire d'«ordres» à exécuter. " ;
00129 echo " Un adolescent, un jeune adulte sera donc capable de comprendre si on lui demande de faire attention à l'ordre des instructions." ;
00130 finp() ;
00131
00132 p("texte") ;
00133 echo "Une des premières difficultés à utiliser un langage réel pour enseigner l'algorithmique et la programmation " ;
00134 echo " est l'abondance des caractères spéciaux et leur sémantique. " ;
00135 echo " Il y a par exemple les " ;
00136 echo href("http://fr.wikipedia.org/wiki/Sigil_(informatique)","sigils")." " ;
00137 echo ghVert("\$ @ %")." de Perl, " ;
00138 echo " les fameux caractères " ;
00139 echo ghVert("* &")." du C, " ;
00140 echo " les symboles " ;
00141 echo ghVert("<< >>")." du C++, " ;
00142 echo " les notations comme " ;
00143 echo ghVert("%*%")." de R... " ;
00144 finp() ;
00145
00146
00147 p("texte") ;
00148 echo " Les blocs d'instruction, avec leurs symboles apparents { et } mais facultatifs " ;
00149 echo " pour une seule instruction ou avec un seul symbole de début : et le retour d'indentation comme critère de fin en Python " ;
00150 echo " sont très pratiques pour des analyseurs syntaxiques et pour des développeurs confirmés. " ;
00151 echo " Pour une initiation, ce sont des ".b("pièges mortels")." car leur oubli affiche des messages d'erreur pour le " ;
00152 echo " moins ".ghBleu("sybillins")."." ;
00153 finp() ;
00154
00155 p("texte") ;
00156 echo "La palme du caractère le plus ".b("abscons")." revient au point-virgule, tantôt séparateur " ;
00157 echo " tantôt terminateur, avec les conséquences que chacun connait... " ; # détaillées dans la section suivante." ;
00158 finp() ;
00159
00160 p("texte") ;
00161 echo "Pour $GALG, nous avons fait le choix de limiter le nombre de caractères spéciaux à quatre : " ;
00162 echo ghVert(" le dièse #")." pour les commentaires, " ;
00163 echo ghVert(" le guillemet droit \"")." pour délimiter les chaines de caractères, " ;
00164 echo ghVert(" les crochets [ et ]")." pour délimiter les indices de tableau. " ;
00165 echo " Il n'y a pas d'accolade donc pas de problème d'accolade, pas de point-virgule, donc pas de problème de point-virgule. " ;
00166 echo " Et on ne coupe pas les cheveux en quatre pour savoir s'il y en a quatre fois plus : on ne peut pas afficher directement " ;
00167 echo " un guillemet dans une phrase. Tant pis. Maintenant, pour les puristes, les râleurs et les chipoteurs, ".b("chr(34)")." est utilisable dans $GALG..." ;
00168 finp() ;
00169
00170 finblockquote() ;
00171
00172 ##########################################################################################
00173
00174 $tdmCRLM->afficheRubrique("oui") ; # 2. Oubli d'un point-virgule, d'un guillemet, d'une accolade...
00175
00176 ##########################################################################################
00177
00178 blockquote() ;
00179
00180 p("texte") ;
00181 echo " L'oubli d'un élément de syntaxe obligatoire comme un point-virgule, un guillemet ou une accolade " ;
00182 echo " est une ".ghRouge("erreur")." que les langages informatiques détectent en général assez bien, mais parfois ".ghVert("trop tard") ;
00183 echo " et souvent avec ".ghVert("un message peu explicite") ;
00184 echo " comme le tristement célèbre ".b("unexpected end of file")."." ;
00185 finp() ;
00186
00187 p("texte") ;
00188 # echo " Prenons comme premier exemple celui de l'affichage d'un simple \"BONJOUR\"." ;
00189 echo " Prenons comme exemple celui de l'affichage d'un simple \"BONJOUR\"." ;
00190 echo " Le code informatique en PHP peut se réduire à la ligne suivante (sans aucun point-virgule !)" ;
00191 finp() ;
00192
00193 pre_fichier("bonjour1.php","cadrejaune") ;
00194
00195 p("texte") ;
00196 echo " alors qu'en C++, il faudra certainement écrire quelque chose comme" ;
00197 finp() ;
00198
00199 pre_fichier("bonjour1.cpp","cadrebleu") ;
00200
00201
00202 p("texte") ;
00203 echo " On remarquera qu'aucun langage réel (sauf REXX/REGINA) n'impose d'écrire de commentaire en début de programme " ;
00204 echo " alors que tout manuel de programmation indique qu'il faut le faire. Au passage, signalons que $GALG n'accepte pas d'algorithme " ;
00205 echo " sans commentaire au début. " ;
00206 finp() ;
00207
00208 p("texte") ;
00209 echo " Une erreur de débutant(e) consiste à oublier de mettre les guillemets autour d'une chaine, que ce soit les " ;
00210 echo " deux guillemets, celui du début ou celui de la fin. Voici, sans commentaire -- mais les messages en anglais " ;
00211 echo " parlent d'eux-mêmes et plaident contre l'utilisation d'un langage réel, les erreurs détectées par PHP et C++ :" ;
00212 finp() ;
00213
00214 h3("2.1 Oubli des deux guillemets") ;
00215
00216 pre_fichier("bonjour2-php.txt","cadrejaune") ;
00217
00218 pre_fichier("bonjour2-cpp.txt","cadrebleu") ;
00219
00220
00221 h3("2.2 Oubli du guillemet ouvrant") ;
00222
00223 pre_fichier("bonjour3-php.txt","cadrejaune") ;
00224
00225 pre_fichier("bonjour3-cpp.txt","cadrebleu") ;
00226
00227 h3("2.2 Oubli du guillemet fermant") ;
00228
00229 pre_fichier("bonjour4-php.txt","cadrejaune") ;
00230
00231 pre_fichier("bonjour4-cpp.txt","cadrebleu") ;
00232
00233
00234 ################################################################################
00235
00236 /*
00237
00238 ; en trop dans l'include :
00239
00240 bonjour1.cpp:1:21: warning: extra tokens at end of #include directive
00241 #include <iostream> ;
00242 ^
00243 oubli du ; à la fin du namespace
00244
00245 bonjour1.cpp:5:1: error: expected ';' before 'int'
00246 int main() {
00247 ^
00248
00249
00250 */
00251
00252 finblockquote() ;
00253
00254 ##########################################################################################
00255
00256 $tdmCRLM->afficheRubrique("oui") ; # 3. Anatomie du langage de $GALG
00257
00258 ##########################################################################################
00259
00260 blockquote() ;
00261
00262 p("texte") ;
00263 echo " Pour éviter les problèmes de point-virgule et d'accolade, dans $GALG on a tout bonnement supprimé ces symboles." ;
00264 echo " Une instruction commence toujours par un mot clé -- ce qui n'est pas le cas des langages réels. " ;
00265 echo " Il y a les instructions simples qui s'écrivent sur une seule ligne et les instructions composées qui " ;
00266 echo " utilisent obligatoirement plusieurs lignes. " ;
00267 echo " Lorsqu'une instruction doit s'étendre sur plusieurs lignes, " ;
00268 echo " il y a un mot-clé de fin d'instruction, différent suivant l'instruction. " ;
00269 finp() ;
00270
00271 p("texte") ;
00272 echo " La syntaxe des instructions est donc plus \"lourde\" que dans les langages réels car elle est plus détaillée. " ;
00273 echo " Par contre la syntaxe est non ambigue : souvent, dans un langage réel, pour aider l'analyseur syntaxique, les blocs " ;
00274 echo " d'instruction partagent une syntaxe minimale, ce qui ne permet pas au premier coup d'oeil de distinguer une " ;
00275 echo " accolade fermante comme fin de boucle d'une " ;
00276 echo " accolade fermante comme fin de test. " ;
00277 finp() ;
00278
00279 p("texte") ;
00280 echo "$GALG va plus loin encore, en imposant un symbole de commentaire après chaque fin d'instruction composée. " ;
00281 echo " Il en résulte qu'il n'est pas possible d'avoir plusieurs instructions ou plusieurs fins d'instruction sur " ;
00282 echo " ligne, contrairement à des lignes comme } ; } }} fréquentes dans les langages réels. " ;
00283 finp() ;
00284
00285 p("texte") ;
00286 echo " Dans $GALG, les instructions qui doivent tenir sur une ligne sont " ;
00287 echo ghBleu("ECRIRE") ;
00288 echo ", " ;
00289 echo ghBleu("LIRE") ;
00290 echo ", " ;
00291 echo ghBleu("AFFECTER") ;
00292 echo ", " ;
00293 echo ghBleu("APPELER") ;
00294 echo ", " ;
00295 echo ghBleu("RENVOYER") ;
00296 echo ", " ;
00297 echo ghBleu("OUVRIR") ;
00298 echo ", " ;
00299 echo ghBleu("FERMER") ;
00300 echo " et " ;
00301 echo ghBleu("QUITTER") ;
00302 echo "." ;
00303 finp() ;
00304
00305 p("texte") ;
00306 echo " Celles qui doivent s'écrire sur plusieurs lignes sont " ;
00307 echo ghBleu("SI") ;
00308 echo ", " ;
00309 echo ghBleu("TANT_QUE") ;
00310 echo ", " ;
00311 echo ghBleu("POUR") ;
00312 echo ", " ;
00313 echo ghBleu("FONCTION") ;
00314 echo "." ;
00315 finp() ;
00316
00317 p("texte") ;
00318 echo " Leur fin s'écrit toujours de la même façon : " ;
00319 echo ghBleu("FIN_SI") ;
00320 echo ", " ;
00321 echo ghBleu("FIN_TANT_QUE") ;
00322 echo ", " ;
00323 echo ghBleu("FIN_POUR") ;
00324 echo ", " ;
00325 echo ghBleu("FIN_FONCTION") ;
00326 echo "." ;
00327 finp() ;
00328
00329 p("texte") ;
00330 echo " Pour insister sur le fait qu'une instruction est un ordre à donner à la machine, il aurait pu être " ;
00331 echo " intéressant d'utiliser systématiquement un verbe. On aurait alors dû avoir " ;
00332 echo ghBleu("TESTER_SI") ;
00333 echo " au lieu de " ;
00334 echo ghBleu("SI").", " ;
00335 echo ghBleu("ITERER_POUR").", ".ghBleu("ITERER_TANT_QUE") ;
00336 echo " ou " ;
00337 echo ghBleu("BOUCLER_ POUR").", ".ghBleu("BOUCLER_TANT_QUE") ;
00338 echo " au lieu de " ;
00339 echo ghBleu("POUR")." et " ;
00340 echo ghBleu("TANT_QUE").", " ;
00341 echo ghBleu("DEFINIR_FONCTION") ;
00342 echo " au lieu de " ;
00343 echo ghBleu("FONCTION").", mais à l'usage cela s'est révélé peu productif." ;
00344 finp() ;
00345
00346
00347 p("texte") ;
00348 echo " Il serait sans doute intéressant de forcer l'indentation du code. Hélas, cela rajoute beaucoup de " ;
00349 echo " difficultés (quel espacement ou tabulation, quelles règles...) et pour l'instant $GALG n'impose rien " ;
00350 echo " en ce sens. " ;
00351 finp() ;
00352
00353 p("texte") ;
00354 echo " Par contre, pour les noms des variables, $GALG, dans la partie analyse, émet une remarque " ;
00355 echo " lorsque les identificateurs ont moins de 3 caractères, ce qui n'est pas judicieux en général. " ;
00356 echo " Toutefois, dans certains domaines, par exemple lorsqu'on programme des formules de mathématiques " ;
00357 echo " complexes, l'usage est d'utiliser rigoureusement les mêmes variables avec les mêmes " ;
00358 echo " noms. " ;
00359 finp() ;
00360
00361
00362 p("texte") ;
00363 echo "Pour apprécier la lisibilité des algorithmes écrits en $GALG, " ;
00364 echo " on pourra consulter le ".href("gmu.pdf","manuel de l'utilisateur de $GALG")."." ;
00365 finp() ;
00366
00367 finblockquote() ;
00368
00369 ##########################################################################################
00370
00371
00372 pvide() ;
00373 p("pluspetit") ;
00374 echo href("montresource.php?nomfic=vss.php","Code-source de cette page","orange_stim nou")."." ;
00375 finp() ;
00376
00377 ##########################################################################################
00378
00379 finblockquote() ;
00380 finSection() ;
00381 finblockquote() ;
00382 finPage() ;
00383 ?>
Pour ne pas voir les numéros de ligne, ajoutez &nl=non à la suite du nom du fichier.