Blackknight a écrit 1244 commentaires

Cool ! Je l'attendais avec impatience ce journal :)

Sur le plan technique, je reste toujours dubitatif sur la notation

Some(r) => r.map(|s| s != "q")

avec son |s| qui donne l'impression d'une variable sortie ex nihilo mais je commence à comprendre un peu mieux suite au commentaire de Kantien… Même si c'est pas encore cristal clear :D

D'autre part, dans

let (first, last) = (self.hits.front().unwrap(), self.hits.back().unwrap());
        let elapsed_time = last.duration_since(*first);

Le fait que first et last ne soient pas déclarés avec un type me dérange toujours même si la ligne d'après me fait comprendre qu'il s'agit d'un pointeur vers un temps. Du coup, je trouve que ça limite la visibilité et que si on se retrouvait avec un tel code à l'autre bout du programme, ce serait plus difficile à comprendre.

Gloabalement, ce n'est pas non plus totalement incompréhensible pour un dino comme moi qui est resté bloqué sur du procédural/objet :D

Encore merci

Bravo, ça faisait quelques jours que tu en parlais mais alors là, chapeau bas !!!!

Cette version, même si elle n'intègre pas tout, est impressionnante.

Alors oui, on va dire que j'ai deux discours mais clairement, là, faire l'internationalisation et la gestion d'options en BrainFuck serait vraiment trop demandé :D

Merci pour l'explication.

Il va vraiment falloir que je soigne mon aversion pour la syntaxe d'Ocaml parce que d'une part, tu as fait l'effort d'installer Gnat donc je peux bien faire l'effort aussi et d'autre part, j'ai vraiment l'impression de passer à coté de tout un pan de l'informatique en négligeant la partie fonctionnelle :D

Ou alors, je suis finalement trop vieux et je ne peux plus m'adapter ;)

ravi de voir au passage qu'il y a des développeurs ADA qui comprennent l'encapsulation ;-)

C'est le côté autoritaire, limite autoritariste, du langage qui finit par prendre le dessus, on ne laisse pas d'accès à n'importe qui ;)
D'ailleurs je me rends compte que je fais la même chose en C/C++ et Java en collant des accolades partout pour limiter les portées :D

Certes mais là, tu t'éloignes trop du concept original :D

L'utilisateur a un minimum besoin d'information ;)

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