Lisibilité : Lua VS Axe

[Adriweb]

On en arrive donc à la conclusion (pas très surprenante) que les gens qui ont l'habitude de leur langage favori arrivent à se comprendre entre eux, mais c'est d'autant plus simple avec des langages plus verbeux et où les commentaires peuvent être intégrés facilement.
Rien de nouveau sous le soleil ?

[m@thieu41]

Ben après tu peux te documenter un minimum
Parce qu'on comprends pas un code si on a jamais programmé sans faire un minimum d'effort

Quand même, j'ai appris le TI Basic en cours d'espagnol, crois pas que j'avais internet avec moi

Parce que tu comptes apprendre le lua en cours d'espagnol ? --"
Où l'Axe?

Par exemple, que fais Output(1,1,3) ? Pour toi c'est évident, pour quelqu'un d'autre non.

Cette commande est justement la première que j'ai comprise pendant ces cours d'espagnol. Si on veut être plus précis, c'était Output(1,X,"O".
Je me souviens encore de la parenthèse manquante et du guillemet final présent quand même. Rappel : je n'avais jamais programmé avant. Pourtant, j'ai bien compris que c'était ça qui dessinait le joueur à l'écran car il ne bougeait que selon l'abscisse X et était représenté par un O.

Ok, mais si c'était Output(I,F,G), qu'aurais tu compris? Sachant que naïvement on pourrait penser que les coordonnées se donnent absice puis ordonnée et non l'inverse...

Dans le code d'Adriweb, il est dans le "si touche appuyée" en gros. Et pourquoi, même si je comprends d'une manière ou d'une autre que ça rafraîchit l'écran, pourquoi le rafraîchir après avoir bougé X et Y sans avoir rien redessiné ? Vous me direz "évènementiel, tout se dessine tout seul". Je vous réponds "pas écrit, pas clair".

C'est écrit dans pleins de tuto pour qui sait chercher. Le but n'est pas de démontrer qu'un programme ne peut pas être compris si on fait pas un tuto en commentaire quand même ? --'
Dans ce cas : pourquoi tu ne documentes pas Repeat avant de l'utiliser dans ton code ?

Ben les tutos d'Axe sont quand même assez rares, et pourtant tout le monde s'en sort. Le seul truc pour débutants complets c'est le Documentation.pdf (les autres tutos étant des tutos spécifiques, comme "comment se servir des variables externes une fois qu'on sait déjà faire de l'Axe") inclus dans le zip, qui explique effectivement ce que fait DispGraph, mais en même pas une ligne alors qu'Adriweb en a mangé trois pour me dire ce que qu'était platform.window:invalidate() (une ligne vite fait comme celle de DispGraph et deux qui expliquent pourquoi ce nom à rallonge) et même avec ces trois lignes, je ne sais toujours pas que le rectangle se dessine tout seul. Dans le Documentation.pdf, il est écrit pourquoi la sprite se dessine, c'est parce qu'on l'a demandé avec la commande qui précède le DispGraph.

C'est sensé prouver quoi? La POO ne s'explique pas aussi rapidement que l'utilisation d'une fonction --"

Quand au fait que l'Axe soit moins documenté... Et alors ? C'est quand même un minimum documenté... mais encore une fois qu'est ce que ça prouve ?

Quant à Repeat, inutile de le documenter, c'est un mot anglais
Ok, Répète touche(15) ça veut rien dire, mais en lisant d'autres lignes, tu vois des If et des End qui correspondent, des While et des End qui correspondent, des Repeat et de End qui correspondent, et ayant compris comment les deux premiers fonctionnent, tu comprends le troisième (en tout cas, ça a marché pour moi en Basic, le plus dur ayant été de comprendre pourquoi certains If n'avaient ni Then ni End, surtout avec l'absence d'indentation).

[/quote]Ca se voit que tu connais pas les débutants toi... Sur tout 82 on voit bien que les débutants ne comprennent pas Repeat du premier coup...

[matref]

Vous me faites bien marrer avec vos "ouais mais c'est quoi ce .AA au début du programme ça veut rien dire, et c'est quoi les touches 1, 2, 3, 4 comprends pas agrbjfdbfds". Dites-vous bien que vous avez jamais fait d'Axe si vous dites ça. On ne demandera jamais à quelqu'un d'apprendre l'Axe en lisant un code AVANT d'avoir lu la doc. Jamais.

Le type qui lira le code débutant d'Hayleia (celui qui fait bouger un carré) n'aura peut-être jamais écrit d'Axe avant, mais il aura au moins lu un micro-bout de doc (voire même le tutoriel gracieusement écrit par Quigibo), assez pour connaître l'existence du header des programmes Axe, et il aura aussi sûrement regardé la keymap, également fournie avec le tutoriel.

Après, dans le même genre, un type qui lira un code Nspire Lua aura forcément déjà vu que invalidate() c'est pour rafraîchir l'écran et des trucs comme ça. Personne ne va se lancer dans la lecture d'un langage nouveau (que ce soit l'ASM, le BrainFuck ou le C++) sans faire un minimum de recherche avant, faut rester réaliste.

(edit admin/modération sur la formulation de la phrase - (ya eu des interprétations différentes qui causaient problème...).)
Après, mdr1, d'après des choses que tu as dites que je considère comme faux, j'en déduis que tu n'as jamais fait d'Axe, donc arrête de dire ce qu'on peut ou ne peut pas faire, ce qui est lisible ou pas lisible s'il te plaît. C'est ridicule.

L'Axe est un langage fait pour être programmer sur une calculatrice. Une calculatrice. Une seule. Si tu veux faire des projets z80 à plusieurs, ta seule option est l'ASM. Tout le reste est on-calc, et une galère immense à maintenir à plusieurs. C'est comme ça. Si quelqu'un sortait un compilateur Axe pour PC ça serait vachement plus possible, sauf que c'est pas le cas. Et qui dit projet personnel dit style personnel, c'est inévitable. Mention spéciale à Keoni29 qui a gratté des points d'optimisation pour rien. En effet, aucun des juges ne faisant d'Axe, moi et Hayleia avont tout optimisé comme on a l'habitude, sauf que lui n'en a pas trop fait, et il a un style extrêmement influencé par le C. Les juges programmant presque uniquement sur PC, ça leur a plu, contrairement à nos lignes certes compliquées mais tellement plus optimisées. En plus, des trucs basiques d'optimisation de l'Axe ont été regardées en mode "mmmh kessekça". Exemple, il est de notoriété publique parmi les programmeurs Axe non-débutants que ceci :

Code: Tout sélectionner

:Repeat getKey(15)
:...
:End

Est 1000 fois moins optimisé que ceci :

Code: Tout sélectionner

:While 1
:...
:EndIf getKey(15)

Pourtant le premier est un peu (si peu) plus clair, donc il est préféré des débutants. Venez pas me dire que quoi que ce soit que j'ai écrit là soit une atteinte à la visibilité.

Et non, être illisible n'est pas requis d'un code Axe pour être optimisé. Y'a différents niveaux d'optimisation en Axe. Reprenons un code ultra-simple, ayant une taille compilée de 349 octets :

Code: Tout sélectionner

:.AA
:0→X
:0→Y
:
:Repeat getKey(15)
:ClrDraw
:If getKey(1)
:Y++
:End
:If getKey(2)
:X--
:End
:If getKey(3)
:X++
:End
:If getKey(4)
:Y--
:End
:Rect(X,Y,8,8)
:DispGraph
:End

Maintenant, essayons de l'optimiser selon plusieurs étapes :

• Niveau 1 : les petits "trucs" bien connus de l'Axe. Pour ça, y'a pas d'autres explications que "le compilateur compile mieux comme ça", c'est du par coeur, y'a rien à comprendre. On a maintenant, pour un total de 344 octets :
  

  Code: Tout sélectionner

  :.AA
:0→X
:0→Y
:
:While 1
:If getKey(1)
:Y++
:End
:If getKey(2)
:X--
:End
:If getKey(3)
:X++
:End
:If getKey(4)
:Y--
:End
:Rect(X,Y,8,8)
:DispGraphClrDraw
:EndIf getKey(15)

• Niveau 2 : utiliser les valeurs de retour des fonctions au lieu de les tester. On utilise le fait que getKey(touche) renvoie 1 ou 0 selon l'état de la touche. On a maintenant, pour 324 octets :
  

  Code: Tout sélectionner

  :.AA
:0→X
:0→Y
:
:While 1
:getKey(3)-getKey(2)+X→X
:getKey(1)-getKey(4)+Y→Y
:Rect(X,Y,8,8)
:DispGraphClrDraw
:EndIf getKey(15)

• Niveau 3 : éviter les répétitions inutiles de variables. On a maintenant, pour 318 octets :
  

  Code: Tout sélectionner

  :.AA
:0→X
:0→Y
:
:While 1
:Rect(getKey(3)-getKey(2)+X→X,getKey(1)-getKey(4)+Y→Y,8,8) // mettez des espaces si ça vous amuse
:DispGraphClrDraw
:EndIf getKey(15)

• Niveau 4 : utiliser le registre HL, soit le principe qu'une valeur stockée en mémoire pour être utilisée y reste. On a finalement, pour 312 octets :
  

  Code: Tout sélectionner

  :.AA
:0→X→Y
:
:While 1
:Rect(getKey(3)-getKey(2)+X→X,getKey(1)-getKey(4)+Y→Y,8,)
:DispGraphClrDraw
:EndIf getKey(15)

On est passé de 348 octets pour le code du début à 312 octets pour le dernier, soit un gain de 36 octets, tout en divisant la taille en lignes du programme par 3. Remarquez quelque chose : le code de la fin est-il honnêtement moins lisible que celui du début ? Ai-je fais quoi que ce soit de compliqué ? Vous êtes-vous sentis perdu à un moment donné de l'explication ? Si oui, soit vous êtes d'une mauvaise foi à toute épreuve, soit laissez tomber l'Axe,il n'est pas pour vous (et l'algorithmie au passage). Ce dernier code n'est pas moins lisible et pourtant beaucoup plus optimisé que le premier, dans les deux cas la majorité des octets étant en fait les commandes DispGraph / DispGraphClrDraw et Rect. Ça prouve bien que le code n'est pas obligé d'être illisible pour être optimisé.

Je peux pas donner d'exemple Lua parce que j'en fais pas, mais bien évidemment qu'on peut avoir une démarche similaire (sauf qu'on peut pas comparer les tailles en octets, m'enfin c'est pas très important).

Pour mdr1 qui bitchait tout à l'heure à propos de →→, c'est une commande tout ce qu'il y a de plus banal. Tu lis la doc et pouf, tu trouves la commande, sa description et comment l'utiliser. Si tu l'avais fait, comme n'importe qui l'aurait fait, tu aurais vu que →→ permet de définir une variable ou une constante uniquement si elle n'a pas déjà été définie. C'est exactement comme se demander ce que fait l'opérateur % en Lua, ni plus ni moins, si tu sais pas, tu lis la doc, tu fais quelques essais si besoin est et c'est bon c'est clair. Aucune difficulté d'aucun côté.

Pour les variables, mdr1, sérieux, arrête. Personne n'utilise 50 variables en Axe, et non, ce n'est pas à cause de l'alphabet. SI tu veux vraiment savoir, on peut écrire 13^64 - 37 noms de variables différents en Axe. Alors arrête et va lire une ligne de doc sur l'Axe.


(admin-edit/modéré, un peu trop HS (à force...) + discours pas extrêmement gentil... Merci de se respecter mutuellement.
Je n'allais tout de même pas supprimer tous les posts à partir d'ici puisqu'ils ont représenter un gros boulot à écrire, 'jimagine, mais je l'aurais fait si ces exemples de codes n'étaient pas là.
Allez, stop maintenant, fini les chamailleries)

[Hayleia]

• de toute façon, personne n'utilise 50 variables, en tout cas pas en Axe,

À cause du nombre de lettres dans l'alphabet. ^^

Non, juste que personne n'a besoin de 50 variables.

Si ça existe, tu peux très bien mettre L5+02→°MaVariable n'importe où dans ton code, y compris à la fin pour ne pas nuire à la lisibilité, et tu obtiens une variable qui s'appelle MaVariable avec laquelle tu peux faire MaVariable++ et tout ce que tu veux.

Bon bah voilà, parfait. Tout juste comme en Lua (sauf pour le "++").

Pas comme en Lua puisque moi je peux déclarer à la fin pour ne pas encombrer le début.

J'ai toujours parlé des programmes "normaux" ou "de débutants", c'est juste toi qui a encore inventé quelque chose dans mes paroles en disant que je parlais de programmes optimisés.

Mmh, je vois, c'est toi qui définis les règles du jeu, maintenant.
Je te rappelle que la discussion est née de la liste d'Adriweb caractérisant les langages dans leur globalité et non juste pour les noob.

Toujours faux. Adriweb a dit "conçu pour être illisible", et j'ai répondu "illisible pour les pros mais lisibles pour les noobs", donc puisqu'on débat sur la lisibilité, on parle bien "juste pour les noobs".
Preuve : viewtopic.php?f=33&t=14980&start=30#p168097

Les programmes "normaux" en Lua utilisent tous le "platform.window:invalidate()" dont j'ai parlé plus tôt et qui n'est pas clair selon moi. Déjà, à quoi sert "platform" ? À dire que la fenêtre dont on va parler n'est pas une fenêtre de mon Android ? Inutile. Ça ne fait que rallonger la ligne et embrouiller le lecteur en lui faisant croire qu'il y a des choses à lire. La partie "window" est la seule sur laquelle je n'ai rien à dire. Quant à "invalidate", ça a beau être utilisé dans beaucoup de librairies graphiques, ça reste obscur.

Ce que tu dis est absurde. La plupart des bons langages sépare ainsi de manière événementielle le dessin, ce qui découpe bien le code et le rend bien plus lisible.

Faut l'inventer quand même la ligne qui ne serait pas claire dans ce code.

Encore plus clair en Lua (CF Adriweb).

Faux d'après les nombreuses réponses qui ont suivi.

Code: Tout sélectionner

CeciEstMaVariable =
   LeDébutDuCalcul LaFinDuCalcul

Ok, donc c'est aussi clair que ce que j'ai fait en Axe. Pas moins clair, mais pas plus non plus.

Runer... double flèche... pas des débutants...

Sauf que si, on parle des débutants...

Mdr, on passe au C maintenant. Sauf qu'en Axe, tu as le r, le double r, le degré, la double-flèche etc. on a l'impression de coder en BrainFuck !

Sauf que si ton débat à toi c'est "le code des pros", alors osef de tout ce qu'il y a dans le code, tout le monde comprend.
Personnellement, le →→, je ne sais pas non plus ce qu'il fait et je ne l'ai jamais vu que dans du Runercode.
Après vérification dans le Commands.html, c'est une macro qui dépend des macros précédentes. Mais comme on parle bien depuis le début (sauf toi) de codes de débutants, on peut oublier les macros et les macros qui dépendent de macros.

Quoi quoi quoi ? Tu dis que les commentaires ne servent à rien ? Tout commentaire sur cette affirmation sera également inutile dans ce cas.

Non mais là tu deviens ridicule. Je ne quote pas tous les messages à chaque fois, mais il faut suivre un peu. LES COMMENTAIRES SONT INUTILES POUR MA LIGNE, PAS EN GÉNÉRAL.

"invalidate", que c'est dur à comprendre dis-moi... Tu dis que le débutant pourra comprendre ce code dans sa globalité en laissant de côté les détails (comme les r, degrés et compagnie). Tu te contredis, tu disais tout à l'heure que ton mode d'écriture en Axe RPN était justement plus pratique pour comprendre les choses en profondeur.

Pour moi, dans "invalidate", il n'y a pas écrit "rafraîchir".
Et je n'ai pas dit qu'un débutant comprendra en laissant de côté des détails comme les r, degrés etc, mais qu'il ne les utilise pas et n'a pas à les comprendre. Sérieusement, télécharge la source de TipOver. Des ^^r, il n'y en a que derrière les commandes de dessin et dans l'appel d'une routine. Pour les commandes de dessin, on s'en fiche, ça dessine on comprend quand même ce que fait la commande. Pour l'appel de la routine, on s'en fiche aussi, ça appelle la routine. Qu'on le comprenne ou non n'a aucun rapport avec le ^^r.
Et je ne vois pas en quoi je me contredis avec mon "Axe RPN" là dedans.

[i]Hayleia, tu es en train de complètement modifier la discussion de base. Elle portait sur le fait qu'Adriweb disait que l'Axe est pratiquement fait pour être illisible. À la place, tu dérives le sujet en parlant du survol à l'oeil d'un programme par un débutant qui n'a quasiment jamais programmé ni même appris le langage, ce dont on se fiche ici tous royalement.

Non, comme dit plus haut, la phrase d'origine implique bien les débutants.

Parler du débutant qui va comprendre un programme de 10 lignes comme quoi il permet de déplacer un rectangle, tel n'est pas le sujet ici.

Si même 10 lignes de Lua faisant un truc stupide ne sont pas compréhensibles, on est bien dans le sujet "Lisibilité : Lua vs Ce que tu veux".

Et enfin, nous dire que tu es très bien capable de lire ton propre code ne prouve en aucun cas que l'Axe est plus lisible que le Lua.

Ça c'est Adriweb qui l'a demandé, et au cas où tu n'aurais pas lu, nikitouzz a compris mon code aussi.

Ben après tu peux te documenter un minimum
Parce qu'on comprends pas un code si on a jamais programmé sans faire un minimum d'effort

Quand même, j'ai appris le TI Basic en cours d'espagnol, crois pas que j'avais internet avec moi

Parce que tu comptes apprendre le lua en cours d'espagnol ? --"
Où l'Axe?

J'ai appris l'Axe en cours de maths.

Ok, mais si c'était Output(I,F,G), qu'aurais tu compris? Sachant que naïvement on pourrait penser que les coordonnées se donnent absice puis ordonnée et non l'inverse...

Là je suis d'accord que je n'aurais rien compris.

C'est sensé prouver quoi? La POO ne s'explique pas aussi rapidement que l'utilisation d'une fonction --"

Ben c'est donc bien censé prouver que l'Axe est plus lisible que le Lua si on se pose moins de questions sur une seule ligne (DispGraph vs platform.window:invalidate(), deux lignes qui font la même chose).

Ca se voit que tu connais pas les débutants toi... Sur tout 82 on voit bien que les débutants ne comprennent pas Repeat du premier coup...

La question n'est pas exactement là. C'est pas "en moyenne, combien de temps il leur faut pour comprendre Repeat", mais "en moyenne, combien de temps il leur faut pour comprendre <ce que tu veux en Axe> comparé à <la même chose en Lua> ?"

[matref]

mdr1, juste pour toi :

(15:52:03) Hayleia: mais c'est pas ça le problème, c'est que mdr1 dir que le Runercode est illisible
(15:52:10) Hayleia: sans blague, même pour nous il l'est
(15:52:18) matref: Ouais 'fin faut qu'il comprenne que Runercode != Axe
(15:52:29) matref: Runercode c'est un speedrun de l'Axe
(15:52:55) matref: c'est sûr que si on te sort un speedrun de Super Mario Bros et qu'on te dit "voilà c'est ça le gameplay de base", tu vas le trouver impossible le jeu

Pour faire un code vraiment optimisé en Axe, c'est pas la syntaxe qui va être super compliquée, c'est la logique d'exécution. On est parfaitement capable de dire quoi fait quoi dans un code de Runer112, par contre on va être incapable de dire pourquoi ça marche, parce que ça utilise plusieurs techniques dont des raccourcis d'exécution liés au compilateur Axe, des algorithmes optimisés, et surtout une logique extrêmement recherchée. J'invite tous ceux qui en doutent à lire ce post de Runer112 où il explique comment il a optimisé ma démo 1k Illogic.

Comme nous, vous comprendrez très bien ce qu'il a fait, mais je me demande encore comment ça marche.

[Adriweb]

Sachant qu'on tourne autour du pot en se disant de RTFM pour comprendre les particularités des langages/APIs respectifs (oh quelle surprise), je vais clore ce topic un peu avant 17h (ça laisse le temps de répondre à ceux qui avait commencé une réponse).
A mon avis, il n'y a rien de spécial à rajouter, les avis respectifs ayant été donnés.

Chacun jugera de son ressenti quant à la lisibilité du langage qui l'intéresse, et voilà

Il y a cependant eu des choses intéressantes d'écrites qui pourront servir à d'autres, d'ailleurs.

[Adriweb]

Sujet locké, donc merci de ne pas y répondre (pour ceux qui peuvent encore : modos+)


Edit : le message de nikitouzz disait qu'il trouvait que commencer par l'Axe, plutôt que le Nspire-Lua, était plus simple pour un débutant.


Edit 2 : modération/suppression de certains passages déviant trop du sujet et qui commençaient à tourner mal inutilement. J'aurais pu tout simplement supprimer l'intégralité des posts en question, mais vu les explications intéressantes qu'il y a eu à plusieurs reprises (notamment les exemples de codes etc.), c'était dommages de les faire partir en fumée.). Je rappelle qu'on se doit de rester poli, courtois, etc. Bref, cf. la netiquette - on n'est pas là pour se lancer dans des guerres interminables.