Blackknight a écrit 1240 commentaires

Bravo pour avoir été jusqu'au bout du portage :-)

Merci.
C'était important pour moi d'aller au bout car cela m'a forcé à apprendre à utiliser de nouvelles bibliothèques.

Est-ce que cela signifie qu'il faut recompiler le programme pour avoir une autre langue ?

Je ne suis pas encore un expert de ZanyBlue mais tel que je l'ai utilisé, les données texte sont embarquées dans le programme.
Du coup, oui, il faut recompiler le programme pour avoir une nouvelle langue. Mais comme les interfaces ne changent pas et que gprbuild gère ça assez correctement, je pense que cela ne recompilera pas grand chose.

Sinon, si je trouve un autre moyen plus dynamique, je le noterai ici bien que ce journal finisse par disparaître dans les flots des suivants ;)

Ce n'est pas si souvent qu'il y a des journaux techniques sur LinuxFr

Et finalement, ceux-ci sont moins bien notés que les journaux moins techniques (cf. on m'a coupé la fibre, journal intéressant au demeurant) alros que finalement, on parle de logiciel libre.

Finalement, j'ai pris la fin du programme à bras-le-corps en ajoutant l'internationalisation via ZanyBlue, chose que je n'avais jamais faite.

Comme je n'allais pas faire un deuxième journal pour ça, je préfère faire un commentaire ce qui permettra aux seuls intéressés d'être au courant :)

Comment ça marche

Comme souvent en Ada, on préfère la compilation à la gestion au runtime.
Du coup, le point d'entrée pour l'internationalisation, c'est le fichier de properties qui contient les clés à insérer dans les zones de texte.

Par exemple:

displayHelp=Affiche ce message d''aide
resetTime=r\u00E8gle le temps en secondes pour mettre le calcul \u00E0 z\u00E9ro. La valeur par d\u00E9faut est de 5 secondes
sampleSize=r\u00E8gle le nombre d''\u00E9chantillons n\u00E9cessaires au calcul du tempo, la valeur par d\u00E9faut est 1
precision=r\u00E8gle la pr\u00E9cision en d\u00E9cimales de l''affichage du tempo, la valeur par d\u00E9faut est 5 et le max est {0,integer}
prologue=Version Ada de taptempo.

La syntaxe de ce fichier de propriétés est tout ce qu'il y a de plus standard pour qui en a déjà écrit en Java.
La seule chose vraiment notable vient de la ligne

precision=r\u00E8gle la pr\u00E9cision en d\u00E9cimales de l''affichage du tempo, la valeur par d\u00E9faut est 5 et le max est {0,integer}

Elle permet juste de préciser que l'on insérera une donnée dynamique, {0, mais qu'elle sera de type entière, integer}.

Pourquoi faire cela ? Car ZanyBlue vient avec un compilateur de fichier de propriétés qui permet de générer du code Ada et donc de typer les différents accesseurs.

Cela permet donc d'appeler notre substitution via, par exemple dans options.adb,

Format_resetTime

ou pour la précision

Format_precision (+Precision'Last)

Le code généré fournit donc des fonctions permettant de formater une chaine à partir d'une clé mais elle fournit aussi des procédures se substituant aux entrées-sorties classiques d'Ada.
Ainsi, l'affichage du premier et du dernier message s'appellent tout simplement via

Print_hitKey;
Print_byeBye;

Ces appels possèdent un paramètre optionnel With_NL permettant de préciser si l'on doit retourner à la ligne ensuite.

Print_tempo (With_NL => False);

Voilà, au final, c'était quasiment bête comme chou ;)

Comme d'habitude, c'est là

Super intéressant et bien documenté, félicitations !!

Je m'en vais regarder de suite le code pour encore mieux comprendre tes explications.

Je continuerais à utiliser des types raffinés

Je ne peux que te suivre sur ce terrain, ça fait partie de la sécurité et apporte, à mon avis, un côté documentation que l'on oublie souvent.

Vraiment un grand bravo !

il y a 2 print, au lieu d'un seul, j'ai l'impression

C'est le debug dont tu parles, je pense.
Sinon, le programme C++, ainsi que le Perl, affiche une première fois pour expliquer le fonctionnement puis demande une nouvelle fois entrée quand il n'y a qu'un seul élément dans la file.

Il demande un ctl-d au lieu de 'q'.

Ça, c'est juste une boulette de texte, 'q' fonctionne

Pour moi, c'est correct ;)

Oui, c'est vrai, je n'ai aucun droit d'empêcher la liberté d'expression, on est en démocratie :)
J'ai d'ailleurs pertinenté ton commentaire pour cette raison.

Du coup, j'en profite pour vous proposer un portage quick and dirty de MS W0rd en bash :D

#! /bin/bash
while read -p "W0rd : enter a entence CTRL+D for save and quit) : " sentence ; do
    echo $sentence >> w0rds.doc
done

Tant qu'il y a la gestion des options et un comportement identique à la version C++… :)

C'est dans la lignée des deux précédents.

Pour l'instant, il n'y a que la version Perl, la version Rust et, sans vouloir me lancer de fleurs, la mienne qui respectent un tant soit peu la version d'origine

Je vais encore faire mon chieur mais pour quasiment les mêmes raisons que les portages Python et Javascript, ce n'est pas un portage de l'application d'origine.

En plus, personnellement, j'ai passé plus de temps que dix minutes pour coder l'application en respectant l'implémentation d'origine et nettement plus de temps que dix minutes à écrire le journal.
Il aurait été très facile de faire un code quick and dirty comme celui qui sort sur les derniers journaux. Nul besoin de se prendre la tête à intégrer des libs pour la gestion des options, de prendre soin de découper le projet en unités logiques…

On est donc très loin de l'idée de mon journal dont le but était didactique en montrant ET expliquant une implémentation identique dans un autre langage.

Je pense que j'aurai passé plus de temps à tenter de le faire s’exécuter

Franchement, ça se compile comme un charme sur une Ubuntu 17.10 et je pense qu'il n'y a aucune différence sur les autres distributions.

et à comprendre son fonctionnement,

C'était pourtant là toute la beauté du geste, comprendre ce qui est fait dans un langage pour réussir à le réécrire dans ton langage préféré et montrer ainsi les avantages et inconvénients de chacun.

que de re-coder "qqchose de similaire"

Du coup, similaire, pas identique donc ce n'est pas un portage

Qui plus est, le programme ne fonctionne pas de la même façon.
Il ne permet pas de paramétrer la taille de la file, le temps de timeout avant de recommencer le calcul et la précision de l'affichage.

En clair, il en manque.

Je pense que tu devrais faire tourner la version C++ d'origine car ton programme ne fonctionne pas de la même façon.
Du coup, on ne peut pas vraiment dire que c'est un portage, c'est plutôt un approchant.

Et le C date de 1972. Passé de mode ? Je ne crois pas, non.

Et c'est des fois dommage quand on voit ce que l'on essaye de lui faire faire.

Le langage Ada a évolué aussi depuis ses débuts. C'est un langage concurrent et orienté objet. C'est pas suranné comme concepts, ça.

T'inquiètes, tu prêches un converti et connaisseur mais je passe quand même pour un hurluberlu à faire de l'évangélisation Ada.

En tout cas, la note même de ce journal montre que ce n'est pas si recherché que ça comme langage au moins sur LinuxFr.

Effectivement, le GC introduit un comportement non déterministe et du coup, difficilement quantifiable.

Merci pour l'explication.
D'ailleurs, je préfère la version verbeuse, je la trouve plus lisible ;)

En tout cas, fais un journal, on verra la cote de chaque langage à la note de celui-ci :)
Pour l'instant, c'est C++ qui gagne mais je ne doute pas que vu la popularité actuelle de Rust, tu marques des points.

Je pense qu'au même titre que les versions C++, Rust ou Ada, la précision en prend un coup dès que la machine, virtuelle ou non, est trop occupée.

En plus, les IO sont, comme un terminal, sujettes à la pose de verrous.

Puis Ada a été créé en 1980

Ce qui explique que ce soit largement passé de mode

c'est un peu verbeux, mais c'est pas ésotérique non plus

Heureusement, les IDE modernes permettent la completion.

Sinon, je suppose que je n'ai pas trop le choix, je devrai écrire un journal sur mon port en Rust :p

Exactement et personnellement, je l'attends avec impatience :)
Et surtout n'hésites pas à mettre plein d'explications parce que les macros et les map, ça reste souvent cryptique pour moi :D

Notamment

reader
                .next()
                .unwrap_or(Ok("q".into()))
                .map_err(|e| format!("{}", e))
                .map(|s| s != "q")

Mais c'est parce que je ne suis pas câblé fonctionnel ;)

Oui. Ainsi, la compilation du code suivant

procedure Test_Bornes is
   type Precision is range 1 .. 5;

   ma_petite_precision : Precision := 0;
   ma_grosse_precision : Precision := 6;
begin
   null;
end Test_Bornes;

renvoie le message suivant

test_bornes.adb:4:39: warning: value not in range of type "Precision" defined at line 2
test_bornes.adb:4:39: warning: "Constraint_Error" will be raised at run time
test_bornes.adb:5:39: warning: value not in range of type "Precision" defined at line 2
test_bornes.adb:5:39: warning: "Constraint_Error" will be raised at run time

Et à l'exécution, comme prévu et prévenu

raised CONSTRAINT_ERROR : test_bornes.adb:4 range check failed

Merci mais là, mon ego en a pour la journée à s'en remettre :D

Pas d'info de version (balo pour les évolutions futures).

Ah bah, tiens, il me semblait qu'il y avait un petit truc qui manquait dans mon code, jesuis bon pour une mise à jour :)
Merci

du coup je n'arrive pas à comprendre où est le code qui permet de mettre par exemple Sample_Size à 1 si celui-ci est 0.
Une erreur est-elle lancée à la place ?

Lors de la saisie d'une valeur hors plage, le runtime Ada lance une exception de type CONSTRAINT_ERROR qu'il est tout à fait possible de catcher.
Ici, il n'est de toutes façons pas possible de saisir, en statique, 0 pour la précision ou le timeout, le compilateur annoncera la levée d'exception dans un warning ces derniers étant des types dont la première valeur est 1.

Dans le cas de ce programme, le filtrage des valeurs incorrectes est remonté à la gestion des options. Ainsi, le code suivant fournit tout ce qu'il faut pour gérer les valeurs hors plage :

procedure Prepare_Options(Parser : out Argument_Parser) Is
   begin
      -- Options creation
      Parser.Add_Option(Make_Boolean_Option (False), "help", 'h', Usage =>
              "display this help message");
      Parser.Add_Option(Options.Precision_Option.Make_Option, Precision_Option_Name, 'p', Usage =>
              "set the decimal precision of the tempo display, default is 5 and max is " &
              Precision'Image (Precision'Last));
      Parser.Add_Option(Make_Positive_Option (5), Reset_Time_Option_Name, 'r', Usage =>
              "set the time in second to reset the computation. default is 5 seconds");
      Parser.Add_Option(Make_Positive_Option (1), Sample_Size_Option_Name, 's', Usage =>
              "set the number of samples needed to compute the tempo, default is 1 sample");
      Parser.Set_Prologue ("An Ada version of taptempo.");
end Prepare_Options;

Dans le cas simple du type Positive, c'est l'appel à Make_Positive_Option qui gère tout seul, enfin dans la lib Parse_Args, les valeurs hors-plage.
C'est rendu possible par le fait que les types embarquent leur bornes (par exemple Precision'Last retourne la dernière valeur valide du type Precision.

Bon, j'ai oublié de dire que je n'ai pas fait la partie internationalisation, histoire de vous fournir rapidement un truc à vous mettre sous la dent ;)

Du coup, entre l'absence d'internationalisation et de licence dans chaque fichier, il manque forcément quelques lignes dans les stats qui suivent

Version 1

 cloc .
      11 text files.
      10 unique files.
       4 files ignored.

github.com/AlDanial/cloc v 1.70  T=0.06 s (127.7 files/s, 3957.3 lines/s)
-------------------------------------------------------------------------------
Language                     files          blank        comment           code
-------------------------------------------------------------------------------
Ada                              5             39             13            168
Markdown                         3              9              0             19
-------------------------------------------------------------------------------
SUM:                             8             48             13            187
-------------------------------------------------------------------------------

Version 2

cloc .
      11 text files.
      10 unique files.
       4 files ignored.

github.com/AlDanial/cloc v 1.70  T=0.05 s (155.1 files/s, 4244.9 lines/s)
-------------------------------------------------------------------------------
Language                     files          blank        comment           code
-------------------------------------------------------------------------------
Ada                              5             34              9            148
Markdown                         3              9              0             19
-------------------------------------------------------------------------------
SUM:                             8             43              9            167
-------------------------------------------------------------------------------

Bon, le gain est pas énorme :D

Et voilà, c'est fait :)

Bien sûr et ça devrait faire l'objet d'un journal ici-même ;)
Au départ, ce sera une implémentation directe de ton code et après, je regarderai pour mettre ça à la sauce Ada.