Reprise du message précédent :

 
Demande à Nraynaud, il va t'usiner ça au laser

T'as demandé à cette boite ? https://www.google.co.uk/search?q=%22PPL324-1%22
La ref ne se trouve pas dans le PDF mais ils ont peut-être des vieux stocks.

https://www.google.fr/search?q=milliput
C'est très solide une fois sec (bien plus que du plastique), ça se travaille comme de la pâte à modeler et une fois sec ça se ponce / peint très bien...
 
...mais ça reste du rafistolage. :- /

tout d'un coup je me dis qu'il pourrait modeler ses pierres comme celles qui ont servi pour les pyramides, formes qui s'emboîtent les unes dans les autres et qui résistent aux tremblements de terre et tout, comme c'est si bien expliqué dans ces théories du complot

en allemagne aussi ils aiment bien les virements  
 

 
Dans la sphère privée une CB est rattaché à un porteur
Tu perds ce lien dans le cadre d'une entreprise . Ou plutot le porteur n'est pas vraiment celui qui à fait l'achat

 
Ha oui, j'ai refait une charnière de rétroviseur de bagnole avec ça il y a bien 6 ans maintenant, et ça tient toujours    Bon, c'était moche, mais une fois remis dans la coque ça ne se voit pas

Belgique également.
 
Les virements c'est bien quand l'interface web de la banque permet de le faire facilement et c'est de toute manière largement supérieur aux chèques. Mais bon c'est quand même plus chiant à implémenter qu'une intégration avec un payment processor

Les CB virtuelles peuvent fixer ce problème non? Le compte est pas associé à l'acheteur, mais les métadonnées de CBV peuvent l'être, et tu peux implémenter n'importe quel flux de validation pour obtenir une CBV.

 
C'est exactement ce qui va me faire chier d'ici quelques semaines je pense.

vous pensez que c'est possible avec gitolite de n'autoriser que la suppression des branches préalablement mergées dans une autre branche ?
 
ça me semble être le worflow classique on crée une branche, on dévellope, on merge, puis on supprime.
Autoriser à supprimer une branche non mergée est dangereux, supprimer une branche mergée dans une autre est sans danger !

 
Ils en sont où les belges avec la cb d'ailleurs ?  

 
Ils attendent une décision de leur gouvernement.

 
Mais pour la compta et l'audit ce qui compte c'est ce que l'entreprise paye, quand et à qui, pas que ce soit José ou Martine qui l'ai fait au nom de l'entreprise non ?
 
Savoir qui l'a fait dans l'entreprise c'est plutôt un problème de gestion/surveillance des employés.

 
En compta public tu as deux niveaux de contrôles

• le contrôle de légalité, qui vérifie que tu as les € pour commander et que tu as le droit ( marché public, délibération,...) Ce contrôle est fait avant de payer les factures
• le contrôle d'opportunité qui est fait de temps en temps par la cours des comptes qui se pose la question de l’intérêt de la dépense. Il est fait des années après, tu ne peux pas te contenter d'un simple reçu de CB , il te faut précisément qui l'a demandé, qui l'a validé, qui l'a payé.  

Le titulaire de la CB n'a pas envie d'assumer le rôle pour josé ou martine.
 
En plus nous n'avons aucun fonds, nous demandons au payeur départemental de verser de l'argent à un tiers après qu'il ai fait son contrôle . La CB zappe cet étape. Cette séparation des rôles empêche de taper directement dans la caisse.

Bis repetita, mais les CBV permettraient de garder tout ça sans perdre les avantages d'une CB non? Seul le contrôleur peut demander une CBV et ne le fait qu'après son contrôle, et l'acte de demande/génération de la CBV peut contenir toutes les infos nécessaires à la cour des comptes.

Les CBV ne sont pas généralisée amha, parce déjà les banques facturent déjà salées sur les normales quand t'es une entreprise, alors une virtuelle... mais aussi se pose la question du remboursement sur les commandes annulées, qui peut être épineuse.

J'y ai pensé mais, de une j'en ai pas, de 2 j'ai pas le modèle 3D de la pièce et de 3 je sais pas si c'est résistant

J'espère bien recevoir la pièce sous huitaine, grâce aux photos

Han ça n'apparaissait pas sur google.fr Merci

Je pensais à acheter un truc comme ça dans une gsa du coin pour modeler la pièce.

Cool

Cartes à puce depuis 1999.

 
C'est pas un process de réservation des ressources dont tu as besoin ?
 
Genre un pauvre calendrier partagé avec "Bob va utilisé l'environnement Int, qui pointe sur la BD trucmuche en Int aussi, et sur le WS machin en version 4.3 , de jeudi à vendredi fin de journée "

je valide

 
Euh non.
On n'a aucun visibilité sur le taf des uns et des autres alors qu'on est que 4. Les réunions régulières ne tiennent pas ( "tu comprends, j'ai trop de taf il faut la décaler cette semaine" toutes les semaines) , les décisions plus globales/stratégiques sont réajustées dès le lendemain.  A chaque retour de vacances il faut partir à la pêche aux infos pour savoir si il y a des choses qui ont changé et quels projets ont bougés.
 
Je pense donc que trouver un gestionnaire de tache partagé qui s'intègre de manière indolore ou presque est une bonne première étape. Je compte sur l'effet panoptyque /affichage publique pour qu'il soit tenu
 
J'hésite entre un tableau global (mais forcement imprécis)  et un par projet (mais qui ne permet pas de vue globale)

Pas dans l'immédiat, mais avec le combo années de concubinage et pas de gamin, la pression je la ressens
 
 
Tu t'es pas marié toi, pour toucher une prime et des jours de congé ?

Je viens d'acheter le dernier Humble Bundle, pour ceux qui n'envisagent pas de le prendre j'ai 3 clés de Risk of Rain à offrir.

 
Mais support de visa/mastercard enfin partout ?

http://www.w3.org/TR/html5/  hop

HALP CLANG !
 
J'ai un bout de code C++ erroné. Ca peut se simplifier ainsi: variable flottante non initialisée dans la stack:

#include <iostream>
#include <algorithm>
void foo() {
  double x;
  std::cout << std::min(4.0, x) << std::endl; // affiche une valeur toute pourrite, genre un denormal
}

 
Je n'ai bien entendu aucun warning (même avec g++4.9 avec -Wall -Wextra -Wunitialized). J'ai pas non plus d'erreur avec valgrind ou avec l'Address-Sanitizer.  
 
Ce sujet a déjà été débattu un peu partout, y compris sur reddit, et une certaine masklinn suggère d'utiliser le static analyzer, chose que je fais:

> clang++ --analyze error.cpp
In file included from error.cpp:1:
In file included from /usr/bin/../lib/gcc/x86_64-linux-gnu/4.8/../../../../include/c++/4.8/iostream:39:
In file included from /usr/bin/../lib/gcc/x86_64-linux-gnu/4.8/../../../../include/c++/4.8/ostream:38:
In file included from /usr/bin/../lib/gcc/x86_64-linux-gnu/4.8/../../../../include/c++/4.8/ios:40:
In file included from /usr/bin/../lib/gcc/x86_64-linux-gnu/4.8/../../../../include/c++/4.8/bits/char_traits.h:39:
/usr/bin/../lib/gcc/x86_64-linux-gnu/4.8/../../../../include/c++/4.8/bits/stl_algobase.h:198:15: warning:
      The left operand of '<' is a garbage value
      if (__b < __a)
          ~~~ ^
1 warning generated.

Et là, on voit bien 2 problèmes:
1. Ca ne me donne aucune idée de la chaîne d'appels qui cause ça. Si je remplace l'appel à std::min par une fonction template locale, j'ai bien un message plus sympa:

 
2. Ca n'apparaît pas non plus dans le résultat de scan-build (parce que faut être réaliste, en fait j'utilise scan-build pour vérifier tout mon bordel).
 
 
Question: je fais comment pour qu'il soit un peu plus gentil avec moi avec le bordel dans la STL ?

Bon, je me donne un début de réponse:

> clang++ --analyze -Xanalyzer -analyzer-output=text error.cpp
  
In file included from error.cpp:1:
In file included from /usr/lib/gcc/x86_64-linux-gnu/4.8/../../../../include/c++/4.8/algorithm:61:
/usr/lib/gcc/x86_64-linux-gnu/4.8/../../../../include/c++/4.8/bits/stl_algobase.h:198:15: warning:
      The left operand of '<' is a garbage value
      if (__b < __a)
              ^
error.cpp:4:2: note: 'x' declared without an initial value
 double x;
 ^~~~~~~~
error.cpp:5:27: note: Passing value via 2nd parameter '__b'
 std::min(4.0,x);
              ^
error.cpp:5:14: note: Calling 'min'
 std::min(4.0,x);
      ^~~~~~~~~~~~~~~
/usr/lib/gcc/x86_64-linux-gnu/4.8/../../../../include/c++/4.8/bits/stl_algobase.h:198:15: note:
      The left operand of '<' is a garbage value
      if (__b < __a)
          ~~~ ^
1 warning generated.

 
Et bah voilà.

#include <iostream>
#include <algorithm>
void foo() {
  double x;
  std::cout << std::min(4.0, x) << std::endl; // affiche une valeur toute pourrite, genre un denormal
}

> clang++ --analyze error.cpp
In file included from error.cpp:1:
In file included from /usr/bin/../lib/gcc/x86_64-linux-gnu/4.8/../../../../include/c++/4.8/iostream:39:
In file included from /usr/bin/../lib/gcc/x86_64-linux-gnu/4.8/../../../../include/c++/4.8/ostream:38:
In file included from /usr/bin/../lib/gcc/x86_64-linux-gnu/4.8/../../../../include/c++/4.8/ios:40:
In file included from /usr/bin/../lib/gcc/x86_64-linux-gnu/4.8/../../../../include/c++/4.8/bits/char_traits.h:39:
/usr/bin/../lib/gcc/x86_64-linux-gnu/4.8/../../../../include/c++/4.8/bits/stl_algobase.h:198:15: warning:
      The left operand of '<' is a garbage value
      if (__b < __a)
          ~~~ ^
1 warning generated.

 
Je pensais que c'était le "#pragma GCC system_headers" qui planquait le warning, mais en fait non.
 
Les std::min sont définis comme prenant des const refs (rapport au coût de la copie et que ça date d'avant les move semantics, mais pour un double c'est idiot).
 
Dès qu'il y a des références en jeu, le -Wuninitialized ne fonctionne plus, même si elles sont const,
probablement parce que tu peux pas prouver que la fonction appelée va lire dans la référence.
 
Je vois pas trop d'autre solution que de définir des surcharges de std::min qui prennent des valeurs simples,
mais du coup faut inclure le code dans les fichiers concernés (manuel ) ou l'inclure de force dans l'invocation au compilo,
et dans ce cas std::min sera présent pour certains types même quand t'aura pas inclus l'header idoine

Une des options que je retiens, c'est effectivement d'instrumenter le code avant de lancer l'analyze. Genre: faire un gros search&replace dans mon code de std::min vers std_min, avec une injection d'une implémentation naïve en haut du fichier.  
 
En particulier, j'ai aussi besoin d'instrumenter un peu le code avant de l'analyzer, pour détecter ce genre de code-à-problèmes:

#include <cmath>
double x = abs(4.4); // x vaudra 4, car on utilise la fonction C abs, et non pas fabs() ou std::abs()

 
Mais si le coup de balancer le "-analyzer-output=text" passe bien, c'est déjà pas mal. Là, il ne me reste plus qu'à trouver comment on fait pour que ça marche aussi en mode html, ou pour que ce cochon de scan-build enregistre cette erreur dans un fichier html.

#include <cmath>
double x = abs(4.4); // x vaudra 4, car on utilise la fonction C abs, et non pas fabs() ou std::abs()

T'as pas ça chez toi ?

(Sinon je note pour les options supplémentaires d'analyze )
 
 
(Et aucun rapport, mais whoo c'est choli: https://www.youtube.com/watch?v=VHbHOQ1NRuw )
 

Y'a pas la teapot

J'en profite pour glisser subreptiscement ma question C++11 à 2 balles:

th = std::thread(&Foo::bar); // instancie un thread avec une méthode Foo::bar()

Peut instancier un thread avec autre chose qu'une méthode statique ?

 
Afaik pas directement, mais tu peux filer une lambda qui capture ton objet et appelle ta fonction.

ou tout simplement un wrapper statique (pour ceux qui seraient allergique aux lambda)

OK, c'est ce que je pensais.
Me reste à sortir l'incantation magique qui va bien.
 
Pour l'instant, VC++ me jette avec la syntaxe suivante:
 
 th = thread(&[this](){ bar(); }, 1500); // bar(int totoz)
 
"la fonction ne prend pas zero argument"

th = std::thread([this]{bar(1500);});

Bon après, l'objet partagé entre deux thread je le sens pas top mais bon...

   
 
J'avais essayé th = std::thread(&[this]{bar(1500);});

J'ai vu le « lancement » d'Antares en direct. J'ai pas été déçu par les effets spéciaux

c'est à dire ? feu d'artifice ?

En vidéo : https://www.youtube.com/watch?v=jHMmMgdcOSU

La comm' d'Orbital Science (on dirait un commercial d'une SSII après livraison du soft) :