Gof a écrit 2224 commentaires

Il faut utiliser un compilateur récent qui donne des erreurs correcte. Comme clang. Même GCC 4.8 a fait beaucoup de progrès à ce niveau.
Et puis les bons IDE te présentent les erreurs correctement.

j'ai toujours autant de mal à comprendre les templates dès qu'ils sont un peu subtils comme ici

Eugh ? qu'est-ce qu'il y a de subtile ? Ici on a affaire à tout ce qu'il y a de plus basic en matière de template. Pas de spécialisation partielle ou de lookup compliqués dans ces examples.

À la limite, le seul petit truc un peu curieux est l'utilisation du Curiously Recurring Template Pattern.

Bref, je ne te met pas 8/10 :-)

struct Base {
  virtual void helloWorld() const;
};

struct Derived1 : Base {
  virtual void helloWold(); // Ooops, j'ai oublié le const. Et ça compile sans problème.
      /* Bon, le test échoue. Combien de temps va-t-il me falloir pour trouver pourquoi ma fonction n'est pas apellée */
};

struct Derived2 : Base {
  void helloWorld() override;
// error: ‘void Derived2::helloWorld()’ marked override, but does not override
   /* Une erreur de compile, 5 secondes pour la corriger. */
};

Très pratique aussi quand on fait du refactoring et que on renomme ou change les argument de helloWorld,
dans ce cas, on a des erreur de compile sur le code qui n'a pas encore été mis à jour (et c'est bien).

Un des problème de RTTI est que il grossi la taille du binaire,
RTTI rajoute plein d'informations pour toutes les classes (même celles pour lesquelles on a pas besoin de RTTI)

C'est pourquoi pas mal de projets compilent leur code avec -fno-rtti pour réduire la taille du binaire.

Ça veux dire pas de typeid, pas de dynamic_cast, pas d'exceptions.

Non, rien à voir. le type de retour dans ce cas là serait l'équivalent du type de retour de ta fonction virtuelle.

L'interrêt ici est plutot de séparé le code et les données.

Exemple fréquent dans un compilateur: tu as une classe de base (Statement) et des classe dérivée (IfStatement et ForStatement)

Ensuite tu veux écrire des passe d'optimisation, tu pourrais aoir quelque chose comme ça:

// Statement.h
class Statement { 
  /*... */
  virtual void optimizeConstantPropagation() = 0;
  virtual void optimizeDeadCode() = 0;
};
// IfStatement.h
class IfStatement : Statement {
  /* ... */
  virtual void optimizeDeadCode() {
     if (condition->isConstant()) { /*..remove one branch of the if .. */  }
     // recurse
     condition->optimizeDeadCode();
     thenBranch->optimizeDeadCode();
     elseBranch->optimizeDeadCode();
  }
};

On voit deux problème:
1. la partie 'recurse' devra être répété dans toutes les passes d'optimisation.
2. Si je veux créé une nouvelle passe d'optimisation, je dois rajouter une fonction dans toute les classes. Alors que justement, les passes d'optimisations devraient être modulaire et contenue dans un seul fichier.

Le visiteur pattern permet de résoudre ces deux problèmes.

Il utilise déjà C++11 (quand il écrit override)

D'ailleurs, question style: est-ce que rajouter 'virtual' en plus de 'override' n'est pas un peu redondant. Personnellement, je n'écris pas virtual quand j'override.

Je ne pense pas que le code template pourrait être simplifié. Peut-être que le typedef aurait pu être remplacé par sa nouvelle forme (prétendue plus cohérente)

using return_type = RetTy;

Au nom de quoi ai-je le droit de me rebeller contre la peine de mort, le cannibalisme ou le nazisme? Si c'est «juste mon propre sentiment» ai-je le droit d'inviter les autres dans rebellion?

Au nom de ta morale et de tes valeurs personnelles.

La même chose qui permet à quelqu'un d'autre de se rebeller contre ceux qui ne payent pas leur taxes, contre les prostituées, contre ceux qui consomment de la drogue ou contre ceux qui ne croient pas en la même divinité.

Bref, différents individus croient différentes choses. Ce qui prouve la non-existence d'un droit « naturel » (avec lequel tout le monde serait d'accord).

(Et non, tout le monde n'est pas d'accord que tuer est le mal absolu. Sinon il n'y aurait pas de meurtrier et la peine de mort n'existerait pas)

V8 […] dont la vélocité a été la raison principale de son incorporation à Qt.

Pas vraiment… Avant V8, JavascriptCore (de webkit) était utilisé. Les deux moteurs ont de bonnes performances. Mais JavascriptCore ne maintiens pas d'API public et sa raison d'être est en temps que moteur pour webkit. V8 par contre dispose d'une API stable et est conçus pour être embqué dans différents projets. Mettre à jour JavascriptCore dans QtScript représente un travail considérable puisque les API changes completement entre chaque version. V8 était donc vu comme plus facile à maintenir.

Mais ce moteur est trop orienté navigateur

Pas vraiment orienté navigateur, il est utilisé par d'autre projets, notamment Node.js.
Par contre, il est orienté ECMAScript standard, et donc n'est pas optimisé pour les extensions QML.

Ça va remonter.

Je pensais qu'asm.js permettait des optimisations qui marchaient sur tous les navigateurs.

Si c'était le cas, il n'y aurais pas besoin d'asm.js.

rajouter des |0 ou autre pour annoter des types est une astuce qui existait déjà avant asm.js, depuis que V8 fait de la détection de type.

asm.js consiste à implémenter un compilateur spécial qui reconnait un dialecte spécial de javascript.

Quelqu'un d'autre aurais pu faire la même chose. mais si ils prennent d'autre convention alors asm.js est inutile.
Par exemple, a|0 est choisis par asm.js pour spécifier un entier, mais ils auraient pu prendre ~~a ou a&0xffffffff.
Ils ont aussi ajouté une fonction "imul" dans leur stdlib. Quelqu'un d'autre aurait pu choisir "integer_multiplication" comme nom.

Si dans du code asm.js on commet une seule erreur et utilise quelque chose qui n'est pas valide asm.js, alors le compilateur asm.js n'est pas utilisé et le compilateur javascript normal est utilisé.

Bref, asm.js est un nouveau langage.

En minant un bloc.

Un bloc contiens le hash du bloc précédent, une liste de transactions, et une « Nounce ».

Le but des mineur est de trouver Nounce tel que le hash du bloc soit inférieur à une certaine valeur appelée la difficulté. La difficulté est calculée de tel sorte que un bloc soit miné en moyenne toute les 10 minutes.

Une des transaction de la liste est autorisée à verser 25 nouveaux bitcoins au mineur.

Qu'est-ce qui empèche le mineur de verser 100 nouveau bitcoins ou d'ajouter des operations fraudleuse dans la liste ?
C'est le fait que tout les autres mineur vont vérifier la validité du bloc. Si une des transactions ne passe pas les tests de validités, les autres mineurs ne prendrons pas en compte ce bloc dans la chaine.

Dart permet aussi de compiler vers javascript et est donc tout autant retro-compatible.

Paypal aussi se permet d'annuler les transfers.

Lis mon commentaire : avec bitcoin, même en acceptant le transfer instantanément, tu as déjà plus de sécurité.
Les 10-60 minutes à attendre c'est pour être vraiment sûr.

La crypthographie.

Les même principes qui empêche de lire les mail chiffré si on est pas le destinataire, ou de falsifier une signature électronique.

La preuve exacte est assez technique. Je t'invite à lire la doc, ce n'est pas facilement explicable dans un commentaire.
En gros, il faut disposer de la clef privée pour signer une transaction, ce qui t'empêche d'utiliser les bitcoin des autres. Les transactions sont sauvegardées dans la blockchain et vérifiées par les mineurs pour t'empêcher de dépenser plusieurs fois les même bitcoins. Les mineurs créent de nouveau bitcoins en utilisant leur CPU pour calculer des hashes. 3600 bitcoins sont créé par jour, répartis entre les mineurs proportionellement aux nombres de hashes résolus.

De plus, le bitcoin n'est pas adapté pour effectuer des paiements rapides (temps de validation des transactions entre 10 et 60 min)

10 minutes c'est pas grand chose comparé à la journée nécessaire pour les payement bancaire.

En fait, le temps de validation dépends de la confiance que tu as en celui qui paye.
Pour les petites sommes, ce n'est pas un problème d'accepter le payement une fois que la transaction est émise. (instantanément)

Un arnaqueur pourrait ne pas payer si il arrive à faire accepter au réseau une transaction contradictoire avant que la transaction légitime ne soit acceptée. Pas facile de faire ça sans que le vendeur ne s'en rende compte. Une méthode pourrait être qu'il ait assez de puissance de calcul pour miner lui même le prochain bloc.

Une fois que la transaction est validée dans un bloc par un mineur (environ 10 minutes), la transaction peut être considérer comme confirmée et irréversible. Il est tout de même recommander d'attendre encore quelque blocs juste au cas où l'arnaqueur aurait vraiment beaucoup de puissance de calcul et aurrait pu miner lui même plein de blocs à partir d'un fork. Mais c'est peu probable.

Avec VISA par contre, on a jamais vraiment de confirmation. La transaction peux encore être annulée des semaines après si le titulaire de la carte le demande. Reste au vendeur de prouver qu'il a bien vérifier l'identité du client (bonne chance).

Pareil avec dart par exemple, puisque dart peut être transformé en javascript pour les browser qui ne le supportent pas en natif.

À lire aussi cet article qui parle en mal de asm.js:
http://mrale.ph/blog/2013/03/28/why-asmjs-bothers-me.html

En gros, essayer de rendre performant un pseudo-subset de javascript serait sous optimal comparé à d'autre alternative qui serait de remplacer javascript par un langage plus performant sur les navigateurs.

Pour le SIMD, Clang est capable de comprendre les intrinsics de GCC, et LLVM est aussi capable de vectoriser le code.
Emscripten doit alors trouver un moyen de transformer le bytecode LLVM en javascript.
J'imagine que pour le moment il doit dé-vectoriser. (ou ne pas passer les flags de vectorisation à LLVM)
Mais il serait peut-être possible pour asm.js de re-vectoriser le code JS dé-vectorisé.
(Javascript n'a pas de type vectoriel, mais asm.js pourait détecter que huit entiers côte à côte forment en fait un vecteur)

Pour le multi-thread ça me parait bien plus compliqué puisque javascript est simple thread. (Les web worker n'ont pas de mémoire partagée je pense)

En effet, chaque transaction doit être incluse dans la blockchain. Cette chaine fait déjà presque 10Go et doit être téléchargée entièrement pour pouvoir effectuer des opérations.

En plus, les blocs on une taille maximum (dans l'implémentation actuelle) qui limite le nombre de transaction à environ 10 transactions par secondes.
(à titre de comparaison, VISA gère 2000 transaction par secondes) https://en.bitcoin.it/wiki/Scalability

Cela dit, il est possible de faire évoluer le protocole pour ne pas nécessiter de garder toute la blockchain, mais seulement un snapshot.

Aux enfants adoptés, ça enlève un père ou une mère selon le cas.

Est-ce que tu peux détailler ?
Il me semble que quand on adopte un enfant, avant il n'a ni père ni mère.
Et après adoption il a deux parents. D'après mes calculs, ça ajoute deux pères ou mères.
Est-ce moi qui fait une erreur de calcul ?

Pourquoi remettre à demain ce qui peut être remis au surlendemain ?

Il n'y a rien de magique en fait.

On est d'accord.
Mais ici on parle de donner une introduction à la programmation a des élève du lycée en 2 heures par semaine. Pas de former des programmeurs profesionels.

Pas le temps donc d'apprendre un langage qui a tout de même une courbe d'apprentissage moins adaptée.

La surcharge des opérateurs, les conversions implicites et les constructeurs de recopie empêchent d'évaluer à l'œil nu la complexité d'un code

Cet argument est bidon:

• On ne peux pas surcharger les opérateurs pour les type de base.
• Mon IDE m'affiche dans une couleur différente les operateurs qui sont overloadés.
• Et puis, même en C tu ne peux pas évaluer facilement la complexité puisque tu dois de toute façon connaître la complexité de toute test opérations. Et tu peux avoir des macro partout.

Exemple: Comment sais tu la complexité de ARRAY_SIZE dans le code suivant?

for (i = 0 ; i  < ARRAY_SIZE(objects_array); ++i) {
  matrix_mul_vetor(&tmp1, &objects_array[i].m1 , &objects_array[i].v1);
  matrix_mul_vetor(&tmp2, &objects_array[i].m2 , &objects_array[i].v2);
  matrix_add(&tmp3, &tmp1, &tmp2);
  matrix_add(&objects_array[i].state, &objects_array[i].state, &tmp3);
}

Perso, je préfère l'équivalent en C++ .
Quand tu connais les types des variable en jeux (que mon IDE me donne dans un tooltip), tu peux tout aussi facilement connaître la complexité.

for (auto &it : objects_array)
  it.state += it.m1 * it.v1 + it.m2 * it v2; 

(Et qui, grâce aux expression template, peux aussi être un ordre de grandeur plus rapide)

---

l'existence de ces fonctionnalités viole le principe d'encapsulation.

Je comprends pas.

Comme par exemple, la gestion de la mémoire?

Tu ne dois pas vraiment gerrer la mémoire en C++. Merci aux fonctions comme les destructeur, RAII, smart_pointer, …

L'écriture des destructeurs, des constructeurs de copie, de l'opération d'affectation,

Dans la pluspart des cas, tu peux être satisfait de ceux par défaut

dès que tu écris le mot class tu dois te payer trois pages de saisie […]
De plus, seuls les programmeurs les plus expérimentés sont capables d'utiliser à bon escient la programmation objet […]

Tu peux utiliser C++ sans faire de POO.

Par contre, dés que tu dois faire de la POO en C, alors là, je ne te parle pas des pages de saisies de macro bizarre que tu te tape (regarde GTK….. )

Le second graphe et mon second commentaire dans https://linuxfr.org/news/concours-de-programmation-codingame-le-26-mars-2013 .

En gros, le C++ est un langage qui a tous les avantages de performance et tout aussi proche de la machine que C, mais est cependant un langage de plus haut niveau qui permet de se préoccuper plus du sur le programme en lui même que sur des éléments de bas niveau.

Certes, La Glib aide un peu. Mais tu dois quand même faire beaucoup de micro-management de mémoire. Appeler sois même tout les destructeurs, faire des cast dans tout les sens, et écrire des tonnes de « boilerplate ».

Le C++ t'épargne tous ça.

Le C++ et le C sont très différents. Il ne faut pas les mettre dans la même catégorie de langages.