Batchyx a écrit 1261 commentaires

Y a quelque chose de rapide dans l'embarqué ?

Je mise sur moins de 6 mois avant de voir cette fonctionnalité enlevée.

Cela implique que ton ssh autorise l'authentification par mot de passe pour ce compte et que ce compte possède un mot de passe.

Je me retrouve souvent à devoir faire la même chose (pour des raisons différentes), et pour l'instant, le seul contournement que j'ai, c'est de faire c'est un équivalent de sudo cp $XAUTHORITY ~user2/.Xauthority , et en tant qu'user2, un export XAUTHORITY=~/.Xauthority
Il faut juste régler les permissions du ~user2/.Xauthority une seule fois en 600 pour éviter que le pirate se serve de ta session X pour devenir root ;)

Mais c'est vrai que ça n'est pas idéal du tout.

Quasiment aucun téléphone ne supporte l'IPv6 ? Vraiment ? Ils ont foutu quoi depuis toutes ces années ?

Je me souviens de mon vieux P800 (sorti en 2002 !) et de son panneau de configuration moche (OS UIQ2 basé sur Symbian) qui permettait déjà à l'époque de configurer l'IPv6 sur le GPRS.

Non, ce n'est pas le droit d'écouter/visionner que tu à (ça fait partie de la copie), mais le droit d'interpréter l'œuvre.

C'est pas comme si on ne parlait que de ça dans ce thread.

Si tu as besoin de protéger l'affectation

Non, ça ne sert à rien. Si tu protège l'affectation newNode->... par un CAS, ça veut dire que tu connais sa valeur précédente, et que tu souhaite vérifier qu'un thread concurrent ne l'a pas modifié en même temps que toi. Ce qui n'arrivera pas tant que t'aura pas inséré le nœud.

Soit node→next=A. [...] node→next devient B. [...] Affectation de node→next à newNode.

Ce n'est pas qu'une affectation, c'est un Compare And Swap. Donc c'est "Affectation de node->next à newNode et node->next->prev à newNode si node->next vaut A et node->next->prev vaut node sinon rien faire et indiquer l'echec" (dans notre cas, on peut récupérer A à partir de newNode->next, si on ne l'a pas stocké dans une autre variable temporaire)

Donc dans ton cas le CAS échoue, la modification concurrente est détéctée, et on refait les affectations depuis le début. Heureusement, parce que sinon les CAS ne serviraient strictement à rien si ça n'étaient que des affectations.

Voila du code si t'en a envie :

do {
   NodeType* old_node_next = node->next;
   NodeType* old_node_next_prev = node->next->prev;
   newNode->next = old_node_next;
   newNode->prev = old_node_next_prev;
// en supposant que __sync_bool_compare_and_swap2 existe.
} while ( faise == __sync_bool_compare_and_swap2(&node->next, old_node_next, newNode,
                                                 &node->next->prev, old_node_next_prev, newNode));

Tu ne "protège" pas l'affectation de newNode->next, puisque tu te fiche de sa valeur précédente (surtout si tu sait qu'elle est initialisée à NULL). Tu refait juste cette affectation si ton CAS sur node->next et node->next->prev échoue. Tu n'a besoin de protéger que deux affectations au final.

C'est dans le cas de la mémoire transactionnelle que tu doit protéger les quatre opérations.

Justement, git annex ne stocke pas les vielles versions des fichiers. Il ne stockera dans l'historique que des identifiants de version de fichiers (ou des hash, selon le backend choisi)

git annex est prévu pour gérer des grandes quantités de fichiers, et stocker l'historique de 10 Go de données ça n'est pas une bonne idée. Mais si tu a envie de stocker l'historique de certains fichiers, alors tu peux avoir dans une même repo tes fichiers sans historique gérés avec git annex et tes fichiers avec historique gérés par le bon vieux git des grands mères.

Pour ça, un bon petit gestionnaire de version avec quelques plugins et c'est réglé.

Personnellement, j'utilise git-annex. C'est pas idéal (remplacer tout les fichiers par des liens symboliques ...) mais ça me suffit.

Je me souviens d'une question de code sur un panneau de stationnement interdit tourné à 90° peint sur une planche de bois amovible : il fallait le respecter quand même.

Je vois pas en quoi ce cas ferait exception.

En général, je roule à environ 10 km/h de plus que la vitesse moyenne des automobilistes.
C'est-à-dire que tu roules à 100km/h alors que c'est limité à 90 ? Intéressant.

Non, Ça veut dire qu'il roule à 120 km/h, parce que dans ce cas la, les automobilistes n'ont que deux choix : rouler à 110 km/h ou se faire coller au cul et être ainsi en danger.

Pour le scoped_ptr, j'ai rien à redire, mais pour le fait qu'une fonction renvoie un simple A* alloué sur le tas, j'appelle ça une future fuite mémoire ou un futur bug, il y a aura bien un moment ou toi ou quelqu'un d'autre oubliera que cette fonction alloue un objet, ou quelqu'un qui ira modifier ta fonction pour retourner des choses qui ne sont pas alloués.
Moi-même j'ai tendance à supposer que tout les A* sont des pointeurs vers des choses qui ne t'appartiennent pas.

Je vois pas à quoi ça sert d'avoir des pointeurs intelligents si c'est pour se retrouver avec le même genre de problèmes que lorsqu'on en avais pas.

Et puis quoi encore ? Il se passe quoi si je fait un factory->createMonObjet() tout cours ? Ça fait des fuites ?

Dans ce cas la, il faut que createMonObjet utilise std::unique_ptr (voire même le std::auto_ptr de notre bon vieux c++03). Après tu remplacera ton scoped_ptr par un unique_ptr (ou alors tu garde ton scoped_ptr mais tu release le unique_ptr).

En C++ on ne s'amuse pas a faire de l'allocation dynamique à la main. std::vector<A> remplace aisément un char[A] (std::vector est forcement contigu, merci le standard).

Par contre, cet exemple avec les scoped_ptr est plus parlant :

std::scoped_ptr<A> a;
try {
    // si je met un A a; ici, il dépassera pas le try.
    a.reset(new A(arguments));
} catch (ZOmgException& e) {
    // oups
}
if (a->cavapas())
    a.reset(new A(arguments_qui_vont_mieux));

Si tu veux parler de nouvelles fonctionnalités, alors parlons en de mes préférées :

• Pointeurs intelligents (ceux de Boost).
  

  {
      std::scoped_ptr<monobjet> e(new monobjet);
      
      if (pas_content())
          return;
  
      faire_des_autres_trucs(e);
      if (vraiment_pas_content())
          throw PasContentException();
  
      return;
  }
  

  
  e sera automatiquement détruit si on sort de la paire d'accolade. Il n'y a plus aucune raison d'utiliser delete, et on va éliminer quasiment tout les leaks avec ça. Existe aussi en version avec transfert de propriété (unique_ptr, pour remplacer auto_ptr) et en version avec un compteur de référence (shared_ptr)
  Et après vous comprendrez pourquoi les C++eux vous disent qu'ils n'ont pas besoin de GC.

• Initialisation de membres dans une classe
  

  class A{
      int i = 42;
  };
  

  
  i prendra comme valeur 42 par défaut, sauf si redéfini par un constructeur.

• Utilisation de classes locales comme classe template :
  

  void oh_une_func(std::vector<int>& i) {
      class compare_last_decimal {
          operator () (int a, int b) {
              return (a%10) < (a%10);
          }
      };
      std::sort(i.begin(), i.end(), compare_last_decimal());
  }
  

• Move semantics :
  

  std::vector<int> ma_fonction();
  ...
  std::vector<int> mon_resultat = ma_fonction();
  

  
  Avant, ce code pouvait impliquer une copie du vecteur. Maintenant, ça n'est qu'une affectation de pointeur. En gros, il y a un constructeur A::A(A&& old) et un opérateur d'affectation A& A::operator=(A&& old) qui peut être utilisé quand on sait que "old" va être prochainement détruit.

• Suppressions et définitions par défaut :
  

  class A{
      A() = default;
      A(int i);
      A(const A& ) = delete;
      A(A&&) = delete;
  };
  

  
  Le constructeur par défaut sera synthétisé automatiquement (ça fera une erreur si ça échoue, pas comme avant) et sans avoir à le faire à la main si on en défini un autre.
  La construction par copie est supprimée (elle est automatique sinon) tout comme la construction par déplacement.

Pour moi, les index de boucles montrent plutôt que le langage manque de structure de boucle permettant vraiment d'itérer sur des tableaux/listes pour faire autre chose que bêtement parcourir les valeurs. Moi j'ai envie de pouvoir modifier, revenir en arrière ou supprimer l'élément actuel ou en ajouter un autre avant ou après, de refaire un tour de boucle sur l'élément actuel, sur le précédent ou d'en sauter un.

À chaque fois que je doit transformer une belle boucle foreach en un for ou while avec des variables de boucles qui ne représentent rien, je trouve ça dommage. C'est pas avec des conventions de codages stupides comme "i,j,k interdit" qu'on rend des variables de boucles jolies.

Une bonne variable de boucle est une variable de boucle morte.

Il n'y a pas besoin de systemd pour utiliser les "cgroups, kms et les autres".
Après, refaire le système d'init, je suis pas contre, mais si pour une fois Lennart pouvait nous sortir un projet bien conçu et bien fait comme il faut, en séparant la table de la choucroute et en rendant le truc compréhensible, modulaire et adaptable au souhait de tout les administrateurs, même ceux qui ne sont pas d'accord avec lui, moi je veux bien.

La théorie c'est bien ... Mais en attendant, je reçois toujours des mails de paypal avec mon nom entier dedans, même si je n'ai fait que payer en indiquant spécifiquement ne pas vouloir créer un compte ...

Les pages man sont exactement ça : des descriptions générales avec les détails à portée de vue. Surtout pour de la programmation système ou pour faire des shellscripts, les pages man ne sont pas suffisantes pour débuter, et ne fournissent pas toutes les information nécessaires (sauf si on utilise les pages man des spécifications posix, et encore).

Les pages de man vont t'expliquer ce que fait pipe(), fork(), exec() et wait(), mais pas comment les utiliser pour lancer des processus en parallèle. Pareil pour les shellscripts qui vont pas t'expliquer comment lire plusieurs fichiers dans un ordre aléatoire.

Et pour les fonctions avec plein de paramètres, généralement, il y a plein de structures ou de types opaques dedans. Donc c'est pas simplement en autocomplêtant ta fonction que t'aura les bons paramètres.

Et comment tu crois qu'il fait le programmeur C pour "savoir ce qu'il fait" ? Il demande à son autocomplêteur de code peut-être ? Ou alors tu crois qu'il connaît tout par cœur ?

Indice : Ça commence par "man" et ça fini par un nom de fonction.

Moi pour avoir une page de man de la fonction sous le curseur, je tape « K ».

Et quand tu à besoin de regarder le source de la fonction ... c'est mauvais signe.

En même temps c'est normal que les pages de man ne soient pas adaptés aux autocomplete-monkeys, puisque l'organisation même de ces pages de man montre à quel point leurs auteur considèrent que l'utilisateur d'une fonction doit savoir parfaitement ce qu'il fait et à quoi il doit s'attendre lorsqu'il utilise la fonction, c'est à dire toute la philosophie inverse de "merci pour les arguments on se revoit si ça plante".

Parce que dans la librairie C, contrairement à la librairie Java, les fonctions avec le moins d'argument ne sont pas les plus simples. Il suffit de regarder fork(), daemon() et exit/_exit().

Je vois pas en quoi les pages de man sont incompatibles avec tout ce que tu raconte. On peut très bien intégrer les pages de man dans les IDE (et ceux qui sont digne de ce nom le font) ou dans les systèmes d'aide hypertexte (KDE 3 le fait très bien, j'ai pas regardé le 4 mais il doit le faire aussi).