Blackknight a écrit 1237 commentaires

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.

Merci de l'explication, j'avais pas tout compris effectivement et c'est dommage puisque je me suis amusé à commencer une implémentation à l'identique en Ada ;)
Du coup, il vaut mieux comprendre :D

En tout cas, c'est finalement très logique et ça explique bien les paramètres que l'on peut passer.

Normalement, en Ada, il ne me reste que la gestion des options (autre que le simple argc, argv) et l'internationalisation car ce sont des trucs qu je n'ai jamais bidouillé.

D'abord, félicitations pour ce petit soft bien sympa.
Ensuite, j'ai une petite question sûrement idiote mais pourquoi as-tu stocké les timestamps de chaque appui de touche pour ne finalement prendre que la première et la dernière valeur et calculer une moyenne ?
N'était-il pas plus simple de ne garder que le nombre d'appuis et le premier et le dernier horodatage ?
J'ai dû louper un truc :D

contrairement au développeur original dont la lecture est biaisée par le contexte de la création du code.

Ça ne s'applique que lors de la création parce que quand on revient sur du code que l'on a écrit 5 ou 6 ans plus tôt, on se retrouve dans la position de l’œil extérieur et généralement, c'est là qu'on regrette de ne pas avoir été clair