Discussion:Initiation au Lua avec Scribunto/Premières notions

Définition de la notion de variable

Bonjour Utilisateur:Lydie Noria,

Tout d’abord, je vous remercie sincèrement pour votre tuto sur le Lua, il est très didactiques pour les débutants.

Comme vous le savez sûrement déjà, w:fr:utilisateur Hexasoft a écrit w:fr:Projet:Scribunto/Guide également très instructif.

Si je peux me permettre une remarque, dans le paragraphe « Complément sur les variables et paramètres » de cet article, il serait intéressant de rajouter le paragraphe «  Déclaration d'une variable » du Guide ainsi que le paragraphe «  Temporalité des variables ».

Je laisse un mot sur la PdD de w:fr:utilisateur Hexasoft, l'auteur des deux paragraphes wikipédia sus-mentionnés.

Bien cordialement,

--Juanes852 (discussion) 17 mai 2014 à 14:04 (UTC)

Bonjour, je vous remercie de l’intérêt que vous portez à ma petite leçon sur le Lua. Je ne comprends pas trop ce que vous voulez que je rajoute au paragraphe sur les variables. Il ne me semble pas convenable de faire un copier-coller de deux paragraphes d'un guide de Wikipédia. J’ai l'impression que l'essentiel des deux paragraphes que vous me citez du guide est déjà dans le présent chapitre hormis quelques détails non essentiels comme le fait que l’on peut déclarer plusieurs variables d'un coup en les séparant par des virgules. Il faut bien comprendre qu'ici, on n’est pas sur Wikipédia. L'approche n’est pas encyclopédique, mais pédagogique. Je ne cherche pas à faire quelque chose de complet, mais quelque chose de facile à comprendre pour démarrer. La priorité est donnée à l'approche pédagogique. La leçon ne doit donner à l'élève que ce qui lui est utile pour débuter et ne pas se perdre dans les détails. Lorsque cette leçon sera achevée, j'attaquerais, peut-être, une autre leçon qui ira plus loin dans les détails et se basera sur des exemples plus compliqués. Je vous remercie des ajouts que vous avez fait à la leçon. Ne perdez pas de vu que cette leçon s'adresse à des personnes qui n'ont, peut-être, jamais programmé de leur vie. Il ne faut y mettre que ce qui est nécessaire. L'objectif est d'acquérir un niveau qui leur permettra de lire des articles plus détaillés comme w:fr:Projet:Scribunto/Guide. Bien cordialement. --Lydie Noria (discussion) 17 mai 2014 à 15:11 (UTC)

(conflit d'édition)

Hello,

quelques remarques :

• « Et si rien n'est précisé, la variable tirelire est sensée, par défaut, contenir une chaîne de caractères » : non, par défaut une variable (déclarée ou pas) contient nil, qui est un type à lui tout seul. À noter qu'on peut toujours lire une variable, qu'elle soit déclarée ou pas.
• sur la portée d'une variable il est important d'indiquer qu'elle n'est visible que à partir du point où elle est déclarée, et jusqu'à la fin du bloc où la déclaration a lieu. À noter aussi qu'une variable utilisée (par exemple) avant sa déclaration fonctionne. Par défaut si la variable n'a pas été déclarée elle est globale (c'est-à-dire qu'elle existe au niveau du module). C'est important car si je fais "i = 5" puis que je déclare "local i" j'ai, durant le bloc concerné, une variable "i" qui "masque" la variable "i" globale initiale. Elle vaut donc nil et non 5. Par ailleurs utiliser des variables globales (des "vrais" ou en les déclarant au niveau du module) est en général malvenu en termes de programmation.
• pour l'exemple donné oui Lua permet de convertir à la volée, s'il le peut, en nombre (a+b). Mais c’est une approche qu’il ne faut pas encourager car si "a" n’est pas un nombre a+b va échouer avec une erreur. Il vaut mieux convertir "a" en nombre explicitement, via une commande qui nous permettra de vérifier que ça a fonctionné. Par exemple la fonction tonumber() retourne le nombre si le paramètre est convertible, nil sinon. On peut donc faire "nb = tonumber(a)" puis tester : "if (nb == nil) then on-génère-une-erreur".
• ne pas oublier la fonction "type()" qui retourne (sous forme de chaîne) le type du contenu actuel de la variable passée ("string", "number", "table"…).
• sur la temporalité des variables un exemple comme "a = a + 1" est important : ça permet de faire comprendre comme Lua évalue et affecte les valeurs.

N'hésitez-pas à piocher dans les documents que j’ai rédigé ou à me demander des relectures si vous le souhaitez.

Cordialement, Hexasoft (discussion) 17 mai 2014 à 15:22 (UTC)

Je précise pour répondre à Lydie Noria ci-dessus : chacun fait bien sûr ce qu’il veut, et pour ma part je n'interviens pas ici mais sur WP en général.

Toutefois étant programmeur de nombreux langages et également enseignant de la programmation depuis (argl) près de 20 ans je ne que mettre en garde contre des bases trop simplifiées : prendre de mauvaises habitudes au début de l'apprentissage d'un langage est le meilleur moyen de ne jamais le maîtriser correctement. Même si le but n’est pas forcément d'amener tout le monde au rang de développeur émérite il me semble important de ne pas non plus risquer de les conduire au rang de "codeur du dimanche" .

Pour le copier/coller si d'aventure vous voulez reprendre tout ou partie de textes de WP il faut demander un import. Ceci permet de créditer les auteurs initiaux (et donc de respecter le droit d'auteur) : à quoi sert que le contenu des sites wikimedia soit réutilisable si on ne le réutilise pas quand c’est approprié .

À noter que je ne comprends pas le « on n’est pas sur Wikipédia ». Bien sûr les articles de wikipédia n'ont pas la même finalité que le contenu de wikiversity, mais là on parle de pages d'aide, de guides… qui ont bien vocation à apprendre à se servir du langage Lua (enfin, Scribunto, ce n’est pas tout à fait la même chose) et non pas à faire un article encyclopédique.

Cordialement, Hexasoft (discussion) 17 mai 2014 à 15:22 (UTC)

Salut, vous venez de Wikipédia, cela ne fait aucun doute! Je pense que vous déclarez importantes des choses qui ne le sont pas forcément pour des débutants. J'imagine mal quelqu’un qui débute et qui n'a jamais programmé de sa vie, déclarer une variable en plein milieu d'un programme alors que dans tous les exemples de cette leçon les variables sont déclarées en début de fonction ou en début de boucle. Croyez bien que mon but n’est pas de leur cacher l'information. Mais je suis avant tout enseignante et je sais que si l’on donne trop de notions à assimiler en même temps, l'élève aura du mal. C'est comme le fait que les variables contiennent nil par défaut, je vais revoir la question, mais ça m’embête d'ennuyer des débutants avec des notions qui ne sont pas vraiment utile dans un premier temps. Pour ce qui est de tonumber(), j’avais l'intention d’en parler, mais plus loin dans la leçon, toujours pour raison pédagogique (pas introduire trop de notions en même temps). Pareil pour la fonction type() (si j'en parle dans cette leçon, pas sûr!). J'espère que les leçons de la Wikiversité destinées à des débutants ne ressemblent pas aux pages d'aide de Wikipédia. Cette leçon n'a pas pour but de former des programmeurs chevronnés mais de permettre aux utilisateurs qui souhaitent contribuer en faisant des petits modules, d'acquérir des bases qui leur permettront de lire (s'ils le souhaitent) des documents plus complets. Je précise aussi que rien ne s'oppose, sur la Wikiversité, à ce que l’on forme des "codeurs du dimanche". C'est très bien qu’il y ait des gens, comme vous, pour faire des documents très rigoureux et très complets, mais je pense qu’il est bien qu’il y ait aussi des gens, comme moi, qui fassent des leçons, pas rigoureuses et pas complètes, pour permettre à certaines personnes d'acquérir le niveau qui leur permettra de commencer à lire vos documents rigoureux et complets. Qu’est ce qui m'a pris d'aller mettre, sur Wikipédia, un lien vers cette leçon avant qu'elle ne soit finie. Je vais voir débarquer des découpeurs de cheveux en quatre pour me dire (même si je rends service à certaines personnes) que ce que je fais ne suis pas la rigueur instaurée sur Wikipédia. --Lydie Noria (discussion) 17 mai 2014 à 17:57 (UTC)

@ Utilisateur:Lydie Noria. Bien sûr, je ne proposais pas un copier-coller, si vous aviez accepté j'aurais proposé que Hexasoft copie son texte (plus simple que Spécial:import) !

D'avance excusez-moi, mais je pense w:fr:Projet:Scribunto/Guide apporte des éléments très importants et bien détaillés, même pour un débutant (que malheureusement je suis (gêné)). Ainsi, on apprend que le sens de lecture est de droite à gauche, etc.

@ tous. Je trouve très pédagogique d'expliquer que pour le code « a + b » renvoie une erreur si « a » est une chaîne de caractère, ça permet de comprendre par l'exemple l'importance de donner le bon type à la variable. En revanche, plutôt que d'inciter à faire « + 0 » après une variable, il serait àmha plus simple pour le débutant d'introduire le tonumber.

Après, je ne comprends pas encore bien le w:fr:Lua et serais incapable de faire un vrai petit module. Prenez mes remarques comme ce qu’elles sont : des remarques.

En tout cas, Hexasoft et Utilisateur:Lydie Noria, vous tutos m'aident bien, et je vous remercie très sincèrement pour votre travail !

Bien cordialement,

--Juanes852 (discussion) 17 mai 2014 à 16:44 (UTC)

Je ne vois pas l’intérêt de mettre le même texte, mot à mot, sur Wikipédia et ici. Pourquoi ne pas mettre simplement ici un lien vers Wikipédia. Les éléments, que vous dites importants et bien détaillés ne me semblent pas convenir aux débutants non programmeur visés par cette leçon. Si vous souhaitez qu’il y ait, sur la Wikiversité, une leçon plus rigoureuse et plus détaillée que celle-ci, je vous invite vivement à la faire. Voir Aide:Comment créer une leçon. Cordialement. --Lydie Noria (discussion) 17 mai 2014 à 17:57 (UTC)

Je vous prie de bien vouloir m'excuser de vous avoir importuné alors que votre tutoriel n’est pas encore terminé. Je vous remercie beaucoup d’avoir mis sur Wikipédia un lien vers cette page, car à titre personnel j’ai compris beaucoup de choses que je n’avais pas assimilé. Je trouve que vous expliquez très bien les if, les else, les while, les différences entre les string et les number, etc. Non, de grâce, ne regrettez surtout pas de nous avoir informé de l’existence de ce beau tuto. À titre personnel, j'attends la suite, et j'espère ne pas vous avoir découragé avec ces questions de détail…

Bien cordialement

--Juanes852 (discussion) 17 mai 2014 à 19:39 (UTC)

Pas de problèmes. En fait, je me demande si le malentendu ne vient pas du fait que je n'ai pas précisé que cette leçon devrait, une fois finie, avoir une dizaine de chapitres. Par conséquent, il ne faut pas vous inquiéter si vous avez l'impression que le premier chapitre est très incomplet. Il est censé contenir le strict minimum pour aborder ce qui se trouve dans le deuxième chapitre(mise au point d'un module). Il est même possible que j'introduise certaines notions qui ne me paraissent pas primordiales pour les débutants, à l’occasion, dans les exercices. Je n'ai pas un plan précis de ce que sera la leçon une fois finie. J'introduis les notions au fur et à mesure qu’elles me semblent nécessaires ou importantes. N'hésitez pas à me signaler si quelque chose ne vous semble pas clair. Je ne suis pas une experte en Lua, j’ai surtout programmé en langage C. Je me suis mise au Lua uniquement parce que c’est le langage qui a été adopté dans les projets Wikimédia. Mais j’ai encore beaucoup de lacunes. Comme je me suis mise au Lua très récemment, je pense ainsi être plus en mesure de faire une leçon pour les débutants, car je me rends mieux compte de leurs difficultés. Toutes les erreurs que je propose de corriger dans les exercices sont en fait des pièges dans lesquels je suis moi-même tombée. Dès que je me plante, j'en fais un exercice! Dès que j’ai une erreur de script, je complète la liste des erreurs de script du chapitre 2. Ah, si vous avez compris comment marche la console de débogage dont j’ai prévu l'explication à la fin du chapitre 2, n'hésitez pas à intervenir parce qu'en ce qui me concerne, je n'ai pas encore compris comment cela marche ! --Lydie Noria (discussion) 17 mai 2014 à 21:32 (UTC)

@Lydie Noria : moi-même enseignant en programmation, il me semble qu’il faut éviter les éléments qui sont un peu « hors des clous ». Par exemple utiliser a+b pour faire une conversion implicite string→number n’est pas une approche « propre » en terme algorithmique, ne serait-ce que par l'absence de gestion des erreurs. Comme il est difficile de faire passer une mauvaise habitude chez un débutant il me semble important d’éviter ça. Soit on explique de quoi il en retourne, soit on esquive le problème : si aborder ceci est trop osé pour des débutants il vaut mieux choisir un exemple qui n'utilise que des string et ainsi esquiver la question des conversions. Une fois assez avertis ils pourront aborder les éléments plus complexes.

En termes algorithmiques la gestion des types (détection et conversion) me semble justement important : en Lua de nombreuses fonctions dépendent du type, et savoir/convertir des variables est un élément de base, qu’il faut maîtriser.

Tu parles d'une approche essai/erreur. C'est une approche très intéressante, mais quand on cherche soi-même et qu'on fait des erreurs qu'on corrige après recherche. Celui qui suit un tutoriel ne « cherche » pas réellement, il ne me semble pas qu’il s'approprie réellement le problème.

Après ce n'est que mon avis, chaque enseignant ayant son approche.

Cordialement, Hexasoft (discussion) 18 mai 2014 à 16:57 (UTC)

Je vais réfléchir au problème. Je pensais consacrer la totalité d'un chapitre (probablement le chapitre 5) à l'étude des petites fonctions préprogrammées fréquemment utilisées comme tonumber() ou tostring(). Le fait d’avoir introduit une autre façon de faire m'a permis dans un premier temps d'économiser ces fonctions et aussi de mettre en évidence certaines particularités du langage qui le différencie des autres langages. Je vais voir si je peux faire autrement, mais cela casse mon approche pédagogique. Je n'ai pas l'impression que les élèves aient le temps de prendre des mauvaises habitudes en trois chapitres surtout qu'au chapitre 5, je vais insister lourdement pour qu’ils fassent autrement et je pense même réécrire certaines des fonctions qui n'étaient pas correctement écrites. Je vais réfléchir au problème pour voir si je peux faire autrement, mais je ne vois pas a priori comment sans compliquer l'approche pédagogique et perdre sur d'autres points. Bien cordialement. --Lydie Noria (discussion) 18 mai 2014 à 17:37 (UTC)

De mon point de vue, on apprend d’abord les conjugaisons avant les exceptions ou les verbes irréguliers. Utiliser des « astuces » (comme la conversion automatique de type selon le contenu) est pratique mais n'est valable que si l’on comprend que c’est une exception (justement). Comme en C − puisque tu connais ce langage − où on peut utiliser les cast implicites pour changer de type, mais il faut bien comprendre ce que ça fait car sinon le débutant moyen ne comprendra pas pourquoi int i=3; float v; v=i/2;" lui donne 1 et non 1.5… Ni pourquoi "v=i/2.;" donne soudain le bon résultat.

Comme je disais je comprends la volonté de ne pas embrouiller le débutant avec des considérations trop complexes pour le chapitre en cours. Mais il me semble plus sûr d'esquiver la difficulté (en proposant un exercice qui ne butte pas sur un cas tordu) plutôt que de risquer de faire apprendre une erreur algorithmique : comme on dit les règles c’est ce qu'on doit apprendre avant de pouvoir les oublier.

Pour ce qui est de mon expérience d'enseignant de la programmation, je pense qu'hélas les élèves ont le temps de prendre de mauvaises habitudes en trois chapitres… Il leur faut même parfois moins. Des fois ils arrivent même avec.

Cordialement, Hexasoft (discussion) 18 mai 2014 à 19:31 (UTC)

J’ai beau réfléchir, je reste sceptique. Pourquoi le Lua offre-t-il certaines possibilités s'il n’est pas correct de les utiliser ? --Lydie Noria (discussion) 18 mai 2014 à 20:20 (UTC)

Il n’est pas question de correct ou pas. La base de la programmation en langage impératif est simple. Les extensions / facilités des langages sont des choses qui sont « en plus » et qu’il est hasardeux de considérer comme des bases, ne serait-ce que parce qu’ils font appels à de l'implicite et que le débutant ne comprend que rarement les tenants et aboutissants de l'implicite. Apprendre un langage informatique est comme apprendre une langue : on apprend d’abord les règles avant d'apprendre les exceptions.

C'est comme en C on apprend d’abord le if/else et seulement ensuite l'opérateur ternaire (par exemple), qui simplifie certaines écritures mais ne doit pas remplacer la compréhension d'une structure de contrôle de base comme le if.

Jouer avec les opérations implicites des opérateurs (par exemple le "+" de Lua selon le contenu des variables) est pratique quand on comprend ce qui se passe derrière. Mais, par exemple, quel débutant utilisant ça sans comprendre ce qu’il y a derrière saura pourquoi son code Lua ne marche pas sur son ordinateur alors qu’il marche sur WP, simplement parce qu’il utilise "1.3" comme « texte converti en nombre automatiquement » mais que sa machine étant configurée en français seul "1,3" (avec une virgule et pas un point comme en anglais) sera reconnu ?

Encore une fois pour moi il est plus important en tant qu'enseignant de la programmation qu'un élève ait des bases propres quitte à ce qu’il ne maîtrise pas tous les raccourcis d'un langage plutôt qu’il utilise des raccourcis (qui ne sont pas obligatoires) sans comprendre ce qui se passe dans les coulisses et tombe ensuite dans des a priori faux dans le contexte utilisé. Et en général maîtriser ces coulisses impose de connaître les bases.

Sans compter que Lua est très "classique" et un code "de base" est compréhensible par tout le monde, alors qu'un code utilisant des raccourcis le sera moins facilement.

Après tu fais bien comme tu veux, ce n'est que mon avis. Si tu n'y adhères pas ce n’est pas grave, il n'y a pas qu'une seule façon d'enseigner la programmation. Cordialement, Hexasoft (discussion) 18 mai 2014 à 20:52 (UTC)

J’ai fait un gros effort pour introduire la fonction tonumber dans le premier chapitre de façon à ne pas écrire des instructions dans le style a = frame.args[1] + 0 mais je suis désolée, je ne me fais pas du tout à l’idée d'écrire des instructions dans le style compte = tonumber(a) + tonumber(b) alors que compte = a + b marche bien. Cette leçon est destinée à rassurer les contributeurs non informaticiens de l'un des projets wikimédia devant l'arrivée du Lua. Elle n'a nullement l'intention de former des programmeurs professionnels. Amicalement. --Lydie Noria (discussion) 19 mai 2014 à 09:35 (UTC)

(décalage )

oui, c’est vrai que mettre 'tonumber()' partout peut être lourd. Ceci dit en général le premier travail d'un module est de récupérer puis de valider ses paramètres (les paramètres nécessaires sont-ils présents, ont-il un contenu adapté par rapport à mes besoins…). On trouve alors en général des débuts de fonctions de la forme vérification-de-présence + vérification-de-contenu + éventuellement faire-une-erreur.

Sur l'exemple du poids (args[1] > 45) on aurait un début du genre : "local poids = tonumber(frame.args[1])", suivi de quelque chose du genre "if (poids == nil) then return 'Erreur : vous devez indiquer un poids !' end". Ainsi si lors de l'appel il n'y a pas de paramètre 1, ou si celui-ci n’est pas un nombre, poids vaudra 'nil'. Le test n’est pas obligatoire mais c’est toujours plus agréable d’avoir un message explicite qu'un "Script error" . C'est d'ailleurs la solution que tu as retenu dans l'exemple "balance()" (à part le test d'erreur).

De plus il est déconseillé pour des raisons de performance d'accéder trop souvent à la table des paramètres quand ça n’est pas nécessaire (pour des raisons qui dépassent largement le cadre de cette leçon). Ainsi dans un exemple comme "p.traduit(frame)" il est plus efficace de faire "jour = frame.args[1]" puis de comparer "jour" avec "Lundi", "Mardi"… (et accessoirement plus rapide à écrire car "jour" contient 4 lettres alors que "frame.args[1]" en contient 13 ).

Une remarque sur le contenu de la page :

« À noter toutefois que si a ou b ne contient pas quelque chose qui puisse être converti en nombre, alors la variable compte ne sera plus affecter (contiendra "nil" comme on l'a vu plus haut) » (en parlant de l'opération "compte = a + b") : ceci n’est pas correct. Si la conversion implicite échoue Lua génère une erreur. Ainsi si a="toto" l'opération "compte = a + b" se soldera par un "Script error" (au contraire - justement - de tonumber() qui retourne nil si la conversion est impossible). C'est la seule possibilité pour tester un problème que l'exécution plante.

Cordialement, Hexasoft (discussion) 19 mai 2014 à 10:35 (UTC)

Je suis d'accord, mais ça me parait trop fastidieux pour un pauvre petit contributeur wikimédia non informaticien qui ne cherche pas à devenir professionnel. Mais bon, pour tenir compte de tes suggestions, je te promet de consacrer vers la fin de la leçon un chapitre où il sera question de gestion des erreurs et éventuellement de rapidité d'exécution. --Lydie Noria (discussion) 19 mai 2014 à 11:15 (UTC)

Il est clair que la gestion des erreurs n’est pas le plus important au départ . La rapidité d'exécution est annexe, je ne l'ai indiqué que parce que les concepteurs de Scribunto insistent là-dessus. Mais celui qui écrit "local poids = tonumber(frame.args[1])" ne se fatigue pas beaucoup plus que celui qui écrit "local poids = frame.args[1] + 0" et a toutes les clés en main pour faire de la gestion d'erreur plus tard . Hexasoft (discussion) 19 mai 2014 à 12:17 (UTC)

Premières notions (m) ?

Pourquoi y a-t-il un 'm' entre parenthèse dans le titre? -- Fred Regent (discussion) 11 juin 2017 à 08:28 (UTC)

C'est en rapport avec une étude sur la visibilité de la leçon par les moteurs de recherche. Le (m) disparaîtra début octobre 2017. — Lydie Noria (discussion) 11 juin 2017 à 09:03 (UTC)