grim7reaper a écrit 132 commentaires

Un entier c’est pas censé wrapper. Par contre un type modulaire oui.
La différence existe en Ada, et plus ou moins en C (overflow sur unsigned ça wrap, overflow sur int c’est un UB).

Il y a quand même des cas ou cela marche, on dirait

Oui mais:

• il faut utiliser une convention d’appel particulière (fastcc pour LLVM), et ça semble avoir un impact sur les perf’ et provoquer des changements d’ABI ("it turns into callee-restore when you enable the -tailcallopt flag")
• ça pose problème pour avoir une destruction déterministe des objets (objets au sens large, pas sens OO)

On pourrait aussi regretter que Rust wrap en cas d’overflow (et va donc silencieusement produire de mauvais résultats) au lieu de trap ou un truc du genre. Ce qui est dommage pour un langage qui se veut safe. Et c’est un peu pour les même raisons :

The reason that Rust provides wrapping integers is that so far, the costs of a better semantics — both in terms of runtime overhead and in terms of implementation effort for the Rust team — exceed the perceived benefits.

Source

Mais j'ai été déçu d'apprendre qu'ils ne pourront jamais de faire de transformation automatique appel récursif vers une boucle

C’est pas faute d’avoir essayé (les dev’ de Rust étaient aussi favorable à cette optimisation), mais il y avait plus d’inconvénients que d’avantages.

Many of us have lisp and ML backgrounds and would quite like them. Their absence is heartache and sadness, not arrived-at lightly.
[…]
I'm sorry to be saying all this, and it is with a heavy heart, but we tried and did not find a way to make the tradeoffs associated with them sum up to an argument for inclusion in rust.

Tu as un exemple ?

html5ever, une bibliothèque développée en Rust mais utilisable en C nativement.

Y’a pas besoin de boilerplate genre caml_startup, CAMLlocal3, …

Oui, depuis GDB 7.0 y'a des pretty-printer en Python pour la STL (et tu peux ajouter les tiens pour tes propres types).

Poste supprimé (j'ai oublié de rafraîchir avant de poster, ce que je voulais écrire a déjà été écrit)

Tu ne parles pas du petit programme qui permet de traduire les définitions de pointeurs en anglais, c'est un exercice du K&R qui aurait toute sa place dans ton article!

Tu veux dire qu’il n’en parle pas comme dans cette phrase dans la section « Liens divers » :

cdecl : un outil en ligne de commande (pour Linux, BSD, MacOS X) permettant de traduire les déclarations dans les deux sens (anglais ⇒ C, C ⇒ anglais) ;

Il n'y a pas de fonction supprimer ?

Inutile.
Pour ceux qui l’ont vu passer dans leur RSS, il était toujours accessible via le cache Google.

Il faudrait penser à une section spéciale, ou un tag spécial, pour mettre à l'honneur ce genre de dépêche de haute qualitai, et regrouper les regrouper dans des collections à thème estampillées "le meilleur des contributeurs de linuxfr"

Tu veux dire comme « Vous pourrez suivre cette série grâce au tag gamedev. »

c'est aussi le cas des EFLs (je n'ai plus en tête le nom exacte de la lib).

C'est Edje, et ce n'est pas du JSON (mais cela y ressemble, je te l'accorde).

Je suis un peu surpris pour la notion d'adressage qui serait plus susceptible à une « mauvaise » fonction de hachage

Pour citer Wikipédia :

Open addressing schemes also put more stringent requirements on the hash function: besides distributing the keys more uniformly over the buckets, the function must also minimize the clustering of hash values that are consecutive in the probe order. Using separate chaining, the only concern is that too many objects map to the same hash value; whether they are adjacent or nearby is completely irrelevant.

Je vais revenir là dessus avec un exemple.

Le clustering dont tu parles va aussi arriver avec un hachage ouvert (sous forme de liste chaînée)

Non.
Dans le hachage ouvert, seules les collisions ont un impact sur les performances (il n’y a pas de phénomène de clustering car chaque bucket est « indépendant »).

Un exemple valant un long discours : soit une fonction de hachage H et une fonction de sondage linéaire (la plus sensible au phénomène de clustering) on pourrait avoir l’exécution suivante :

• H("foo") = 0
  • hachage ouvert : (0) est libre, pas de collision => insertion en (0)
  • adressage ouvert : (0) est libre, pas de collision => insertion en (0)
• H("bar") = 1
  • hachage ouvert : (1) est libre, pas de collision => insertion en (1)
  • adressage ouvert : (1) est libre, pas de collision => insertion (1)
• H("baz") = 1
  • hachage ouvert : collision => chaînage en (1)
  • adressage ouvert : collision => insertion en (2) (sondage linéaire)
• H("qux") = 2
  • hachage ouvert : (2) est libre, pas de collision => insertion en (2)
  • adressage ouvert : collision (due au clustering induit par la sondage linéaire) => insertion en (3)

On voit que à cause du sondage on crée des collisions artificielles, c’est le phénomène de clustering (qui est donc inexistant en hachage ouvert).

On voit aussi que plus le facteur de charge va augmenter, plus les performances vont se dégrader (c’est aussi le cas avec le hachage ouvert, mais le phénomène est moins rapide).

Enfin, on note que dans le cas où tous les buckets sont utilisés, l’algo’ d’insertion de l’adressage ouvert va échouer.

au moins dans le cas de l'adressage ouvert, il me semblait qu'on bénéficiait au minimum d'une allocation mémoire contiguë garantie.

Oui, l’adressage ouvert peut offrir une meilleur localité spatiale c’est vrai. Mais il faut bien choisir la fonction de sondage pour avoir un équilibre entre localité et clustering.

Mais quand la capacité de ma table à adressage ouvert approche le taux de remplissage fatidique, je dois alors doubler la taille, et re-hacher tous les éléments (qui était l'argument que j'avançais au post précédent). Du coup mes éléments sont potentiellement dispersés à nouveau dans ma table. Et je ne comprends pas bien en quoi c'est pire qu'avec le hachage ouvert (donc avec listes chaînées).

Le hachage ouvert est plus tolérant au l’élévation du facteur de charge.

la technique de la liste chaînée était utilisée, plutôt que le hachage ouvert

L’utilisation de listes chaînées c’est du hachage ouvert (!= d’adressage ouvert).

avec une table + liste chaînée, on dépend « bien plus » d'une bonne fonction de hachage

Au contraire, avec un adressage ouvert on dépend encore plus de la qualité de la fonction de hachage car en plus d’avoir une bonne distribution (pour éviter les collisions) il faut éviter le clustering.

Contrairement à valgrind qui lance le programme dans une machine virtuelle

Valgrind ne lance pas le programme dans une VM.
Il désassemble l’exécutable, instrumente le code, le réassemble et l’exécute. Tout ça à la volée, d’où le fait qu’il y ai un ralentissement important en général.

C’est très bien expliqué dans le papier Valgrind: A Framework for Heavyweight Dynamic Binary Instrumentation.

Par contre, il semble qu'il y ait un manque critique de lib pour gérer correctement les IHM sous ce langage.

Vraiment ?
Pourtant il y a

• GTKAda
• QtAda
• wxAda (mais il semble un peu vieux)
• plusieurs SDL (dont celui-ci)
• un SDL 2 en cours (pas encore utilisable apparemment), plus le mien ça ferait 2.

Je crois qu’il y a aussi des trucs pour OpenGL.

Par contre rien pour les EFL (j’ai commencé un bout de truc là-dessus) en effet.
Et rien pour SFML (en même temps, autant faire un binding sur du C c’est trivial, surtout en Ada, autant en C++ avec le mangling non standard c’est chiant).

Il y a aussi le fait que gnat soit infernal à utiliser. Ce truc est le pire IDE que j'aie tenté d'utiliser sérieusement… GUI bordélique à souhait, on sait même pas ou aller pour compiler un nouveau projet. Bref.

GNAT c’est le compilateur.
Là tu dois parler de l’IDE (GNAT Programming Studio).
Je n’ai rien à dire dessus, je ne l’ai jamais utilisé…

Je ne parlerait pas du tuto qui présuppose un nombre élevé de trucs. Ca reste de la doc de gnou, dans le genre bestial on fait difficilement mieux (avis personnel).

Quel tuto ?

Et je n'ai pas trouvé grand chose (rien en fait, mais j'avoue que pour m'initier à un nouveau langage, j'aurait préféré un outil qui en fasse un maximum à ma place, pour commencer gentiment. Donc pas plus cherché que ça) au sujet de compiler en ligne de commande, non plus ( pourtant, ça me suffit amplement, compte tenu du fait que mon système utilisateur est un vrai IDE pour c++ en tant que tel, à condition de savoir taper 3-4 commandes ).

Ha bon ?
Pourtant c’est super simple. En général, il suffit d’une commande.
Genre pour un Hello World :

    with Ada.Text_IO;

    procedure Hello is
    begin
      Ada.Text_IO.Put_Line ("Hello, world!");
    end Hello;

Tu écris ça dans un fichier appelé "hello.adb", ensuite tu tapes

    gnatmake hello.adb

Et tu as un exécutable hello.
Pour un programme un peu plus compliqué, tu peux écrire un fichier de projet (un exemple ici, la doc’ est là) que tu passes à gnatmake (genre hello.gpr)

    gnatmake -Phello

Tu as une introduction ici.

Et quand tu as des projets plus complexes (multi-language, disons C et Ada), tu peux passer le fichier de projet à grpbuild (la doc’ est là) qui se chargera de compiler et lier ensemble tout ce beau monde)

Le concurrent de la SDL, la SFML, ne supporte certainement pas l'ADA, et personne ne semble s'y être mis ( logique, SFML est déjà peu utilisée en C++, alors porter pour ADA… ).

SFML me semble pas mal utilisé en C++ (bon j’ai pas de stats là-dessus, juste une impression).
Le souci de la SFML c’est que c’est du C++ et donc plus chiant de faire un binding (name mangling qui change d’un compilo’ à l’autre entre autres…).

Et pour finir, il semble que, comme C++, ADA n'ait pas de lib pour créer des GUI, ou plutôt pas de "lib mainstream" (mais pour un langage si peu connu… pas surprenant ).

Si, voir plus haut.

PS: si t'as des document expliquant comment faire un vrai hello world, en ligne de commande, pas à pas, expliquant la syntaxe et les paradigmes du langage plutôt que des trucs aussi inutiles que la description de l'API des fonctions standard ( pour lesquelles un lien vers un document les expliquant de façon technique me suffit. Je ne suis peut-être pas un maître du dev, mais je suis un dev malgré tout, lire de la doc d'API me fait pas peur. )

Pour le Hello World, je remet ce lien.

Pour les particularités du langages il y a les gems qui sont parfois très intéressantes. Il y aussi le livre Ada Distilled: An Introduction to Ada Programming for Experienced Computer Programmers qui est disponible gratuitement en PDF ici par exemple.

Y’a aussi un tuto’ sur openclassrooms mais je ne sais pas ce qu’il vaut.

Pour les références (standard entre autres), tout est là

Faire moins consommateur que le Bluetooth en emission, cela parait difficile.

ZigBee ?

Mais pourquoi il n'est pas simplement livré avec des réglages sensés dès le premier démarrage ?

Parce que personne n’a la même définition de ce qu’est un « réglage sensé ».

En l'état c'est plus un framework qui a besoin d'un front-end qu'un logiciel fini.

Pour l’utiliser régulièrement, je ne partage pas cet avis. Pour moi c’est bien un logiciel fini. Minimaliste, certes mais c’est bien ce qu’on (du moins, ce que je) lui demande.

llpp et zathura utilisent mupdf en tant que lib pour le rendu.

zathura peut utiliser mupdf ou poppler, les deux étant des plugins (donc pas de choix par défaut).

et je crois que sous IronPython il n'y a pas de Gil non plus (https://wiki.python.org/moin/IronPython).

Oui, tout comme IronRuby.
Ou encore Jruby et Jython (étant basé sur la JVM ils font du vrai multithreading évidemment).

Mais je dois déjà terminer mon apprentissage de Haskell (qui ne me servira probablement jamais dans un environnement professionnel…).

Si tu restes en France oui évidemment…
Sinon, Haskell est utilisé dans le monde pro’(y’a une une petite liste ici)
J’ai déjà vu passer plusieurs offres d’ailleurs.

Oui, c’est exact.

int foo (plop_t * plop){};
...
foo(&plip);

Là c’est un pointeur passé par valeur, pas du passage par référence.
Le C n’a pas de passage par référence. Mais on peut le simuler via les pointeurs.

C’est d‘ailleurs ce que dit l’article Wikipédia

The same effect can be emulated in languages like C by passing a pointer (not to be confused with call-by-reference)
[…]
Even among languages that don't exactly support call-by-reference, many, including C and ML, support explicit references (objects that refer to other objects), such as pointers (objects representing the memory addresses of other objects), and these can be used to effect or simulate call-by-reference (but with the complication that a function's caller must explicitly generate the reference to supply as an argument).

Mais ça reste une émulation du mécanisme, le résultat est le même que du passage par référence, mais ça reste du passage par valeur.

Cela reste tordu.

Je suis d‘accord. D’où le fait que cette méprise soit répandue.
Je viens de tomber, via Wikipédia, sur un terme qui semblerait plus approprié : call-by-sharing.

Dans les fait, tu peux faire une transmission par valeur ou par référence en C++, alors qu'en Java tu ne manipules que des références.

Oui, en Java tu n’as pas le choix. Tu ne manipules que des références (sauf types primitifs il me semble), mais au final tout est passé par valeur.

L'article raconte à peu prêt n'importe quoi.

Ha ?
Objectivement, j‘ai quand même l’impression que c’est toi qui raconte nawak…

Le passage par valeur implique une copie dans des registres.

Qu’est ce que les registres viennent foutre dans la définition de pass-by-value.
Source ? Ou c’est une définition de derrière les fagots ?

Java ne fait pas de copie à chaque appel de méthode sur un objet, et heureusement !
si, Java fait une copie : il copie la référence.
Il passe la référence par valeur. Il ne passe pas par référence. Nuance…

Dans l‘exemple que tu cites, aDog est une référence sur un objet Dog (car Java manipule des références sur les objets, il est ainsi fait).
Quand tu appelles la fonction foo, c’est bien une copie de aDog qui est envoyé, pas une référence sur aDog.
J‘appelle foo(aDog), la fonction reçoit la valeur (une copie) de aDog => passage par valeur.

En revanche en C++, si j’ai une fonction :

void foo(Dog& d)

Quand je l’appelle

Dog aDog;
foo(aDog);

Je ne passe pas une copie de aDog, mais son adresse.
J‘appelle foo(aDog), la fonction reçoit l’adresse de aDog => passage par référence.

Que les valeurs que Java passe soit des références sur un truc ne change pas le fait que sémantiquement c’est un passage par valeur, pas un passage par référence comme il existe en C++ par exemple (j’appelle avec A, la fonction reçoit une référence sur A).

Des langages comme Java ou OCaml passent tout par référence.

Non.
Java passe tout par valeur..
Pour OCaml, je n’en sais rien par contre.

Je ne suis pas sûr de comprendre ce que tu entends par try/catch de bas niveau, mais si c‘est au sujet de la vérification des accès au tableau (ce qui peut lever une exception), c’est juste parce que le code utilise la méthode at au lieu de l‘opérateur []

Par contre niveau disposition des claviers ce n'est pas toujours évident. Même si les noms de fichiers peuvent être complétés en ligne de commande par la touche TAB, ce n'est pas forcément le cas dans un éditeur de texte ou navigateur de fichiers graphique.

C’est pour cela que l’on a inventé les méthodes d’entrée…