Blackknight a écrit 1244 commentaires

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

Super, bravo et merci

Alors pour le coup, c'est un publi-communiqué ?
Tant qu'on n'a pas vu le code source et la licence, on a donc un journal noté à plus de 40 pour exposer de la pub !!

Y a que moi que ça choque de voir ça sur LinuxFr ?

beaucoup de programmeurs sont fâchés avec ces concepts difficiles mais doivent faire face au quotidien à des difficultés qui viennent justement de ce manque de compréhension fine des concepts

Oui alors bon, on va quand même être plus circonspect, on (les informaticiens) a beaucoup d'autres problèmes techniques à résoudre dans la majeure partie des cas avant d'en arriver à se poser des questions d'analyse numérique :D

PS: Je me suis permis une petite correction de conjugaison sur la citation, "la grande majorité" se trouvant entre parenthèses, j'espère que tu ne m'en voudras pas :D

Alors oui, je suis bien d'accord avec ton explication mais le but de mon exemple était juste de montrer qu'en utilisant la bonne techno, ici un type à virgule fixe, on répond au problème d'origine… Ton exemple montre qu'on ne répond pas à tout avec.

Le tout, c'est de le savoir :)

with Ada.Text_io; use Ada.Text_Io;

procedure Test_Real is
   type mon_real is delta 0.1 digits 3 range 0.0..10.0;

begin
   Put_line (mon_real'Image(2.0 - 1.8 - 0.2));
end Test_Real;

Et voilà, c'était pas compliqué :D

Bon, ok, c'est pas des vrais float, c'est de la virgule fixe

GlusterFS est performant lorsqu'il gère peu de très gros fichiers, du genre des fichiers de VM. Et il est mauvais lorsqu'il doit gérer une multitude de petits fichiers et répertoires.

Un peu hors sujet, mais typiquement, avec CodaFS, c'est plutôt l'inverse vu que les fichiers sont rapatriés dans le cache ce qui peut prendre un temps non négligeable.

Pour être précis : dans la mesure du possible, nous essayons de porter nos changements à la FSF (que ce soit pour le front end GNAT, ou nos modifications dans le middle/back end de GCC) de manière régulière tout au long de l’année, pas seulement vers juin.

Merci de la précision Pierre-Marie, ça doit être une légende urbaine qui a la peau dure :D

Y a de ça mais c'est aussi plus que seulement le compilateur.
En fait, dans GNAT Pro, ce qui coûte n'est finalement pas le compilateur en lui-même mais tout ce qui va autour, à savoir, le support technique notamment pour les certifications, les outils développés spécifiquement pour la suite GNAT Pro et les runtimes exotiques.
Pour avoir une petite idée de ce que cela couvre, voici le tableau comparatif.

En fait, à l'origine, GNAT était développé par l'université de New York.
Après la sortie et la validation du compilateur, licencié sous GPL, les auteurs ont fondé deux sociétés AdaCore à New York et ACT Europe à Paris.
Si au début, le compilateur vivait sa vie en dehors de Gcc, il fait maintenant partie intégrante et AdaCore, fusionné depuis 2012 avec ACT Europe, reverse ses développements tous les ans dans le code de Gcc, généralement vers juin.
Il existe donc plusieurs versions:

• FSF GNAT, sous GPL3+ avec une exclusion pour le Runtime
• GNAT Pro, la version "commerciale" d'AdaCore avec support
• GNAT GPL, la version GPL d'AdaCore qui est généralement une version Pro avec un an de retard et sans support téléchargeable sous forme binaire depuis le site Libre

Au passage, depuis plusieurs mois, AdaCore dispose maintenant d'un compte Github sur lequel on retrouve les versions de développement des différents outils développés par leurs soins.

Ah ouais, j'ai tellement voulu mettre de liens dans le journal que finalement, j'ai oublié le plus important !
Dommage que je ne puisse plus modifier le journal.

En tout cas, un grand MERCI :)

Il n'y a rien à dénoncer, il faut juste savoir garder un œil critique.
On n'a jamais vu un langage percer uniquement en le comparant aux autres.
Que quelqu'un recode Mr. Boom en Rust et montre les avantages et inconvénients comme cela a été fait dans le journal sur Gnirehtet, c'est beaucoup plus constructif que de dire que coder en C c'est nul.

Ok, du moment qu'on a le droit de critique le C et le C++, et autant qu'on veut (du moment que c'est justifié).

Et Rust aussi

Parce que bon, Rust n'existe pas que pour le plaisir.

Comme beaucoup d'autres langages, rien de nouveau sous le soleil.

Au moins, il y a quand même un truc super positif qui ressort de tout ça, c'est qu'avec tout ce qu'il y a à ré-écrire, les développeurs Rust ont du boulot pour au moins 15 ans :D

Après, c’est sur que si ta référence de qualité pour le code c’est du brainfuck…

J'ai juste pas voulu taper sur Python après l'exemple sur Ansible :)

on s'éloigne d'UML qui contient plusieurs centaines de concepts, c'est trop pour comprendre toutes les subtilités.

Tout à fait d'accord. Personnellement, je trouve aussi qu'il y a trop de choses dans UML mais avec les diagrammes de classes, de séquences et use-cases, tu documentes déjà pas mal.
Après,un diagramme de déploiement ne fait pas de mal :D

Pas forcément. La mode est de décrire l'architecture

Je ne voulais pas forcément parler d'AADL et autres joyeusetés, ça aurait filer trop de boutons à certains ;)

Faudrait arrêter aussi de chier des logiciels aussi gros.

Heu, comment dire, briques simples => communication entre briques => validation d'interfaces => documents d'interfaces. Je ne suis pas sûr que cela simplifie

Il y a des cas où la complexité du projet fait que non, tu ne t'amuses pas à découper en micro-services.
L'exemple C++ dont je parlais est un système de contrôle-commande qui pilote des automates de plus bas niveau alors comme tu gères la cohérence et la gestion d'un système complet interagissant avec d'autres systèmes, tu ne peux pas découper.

Je pense à l'exemple Ansible vs Saltstack.

C'est vrai que vu qu'Ansible est codé en Python, il vaut mieux faire des petits trucs parce que c'est pas la compilation qui va t'aider à t'y retrouver en cas de refactoring.
Et puis, dans certains systèmes, le message tutu has no attribute fera beaucoup moins rire les utilisateurs.

Ça reste un diagramme alors sauf s'il est écrit des annotations en cyrillique, oui, j'ai l'espoir, voire la prétention, d'en comprendre nettement plus qu'un code écrit en Brainfuck par un obscur codeur qui a décidé qu'il ne documenterait rien car son code est, de fait, auto-documenté.

dans l'informatique on fait exactement la même chose sauf que les documents de conception sont les fichiers sources !

Ok, je te file un code en Ada83 de plusieurs dizaines de milliers de lignes et je te dis, voilà le doc de conception, tu as deux heures pour m'expliquer ce que tu as compris… Et encore, avec toi, j'ai bon espoir, tu fais du C++ :)