Benoît Sibaud a écrit 10261 commentaires

Pas sûr que beaucoup de personnes aient compris la référence de la photo (une série diffusée en 1982 en France par TF1...). Cf http://fr.wikipedia.org/wiki/Jonathan_Hart

Pour le reste, respect pour le bonhomme, « un pionnier de la mise à disposition du patrimoine littéraire, relire cet article de 1998 http://severino.free.fr/archives/copieslocales/ladeuxiemerevolutiongutemberg.html » disait fcouchet

donner au moins une phrase explicative de ce qu'est MongoDB au début de la dépêche ?

« Base de données : Sortie de MongoDB 2.0 RC »

« Moins de dix mois après la sortie de sa dernière version stable, l'entreprise 10gen a sorti la nouvelle mouture de sa base de données »

On pourrait dire que MongoDB est un système de gestion de base de données.

Histoire d'éviter qu'un consultant sécurité dépose un brevet sur cette idée révolutionnaire en terme de sécurité, je l'expose ici publiquement :

1) on sait que l'utilisateur ne retient pas les mots de passe compliqués et les mets en post-it sur son écran (voire sur sa fenêtre)
2) il insère n'importe quelle clé USB qu'il trouve sur sa machine et ça pose des soucis de sécurité
3) on ne peut pas changer l'utilisateur final, alors autant lui simplifier la vie : on lui met un mot de passe à 32 caractères totalement aléatoires, que l'on dépose sur une clé USB telle qu'évoquée ici. Pour se loguer, il a juste besoin de coller la clé dans le port USB. Oui, au final ce n'est pas pire qu'un post-it... La version clé PKI du pauvre, sans mot de passe à retenir, sans certificat de sécurité, sans serveur centralisé de clés, sans rien à expliquer à l'utilisateur.
Dans la version 2, on pourra même coller le login, entrée, le mot de passe, entrée, pour les utilisateurs ayant le moins de mémoire.

Bref un truc aussi stupide qu'une clé de porte quoi (enfin une vraie clé de porte, pas un truc à RFID ou badge ou NFC ou digicode ou ...).

Ceux qui jouaient avec write, mesg y et autres cat de fichiers binaires (genre /vmlinuz) dans le tty ont fini par disparaître devant les comiques sous X11. Bientôt l'humour désopilant sera à base de glisser-déposer d'une machine virtuelle dans le cloud à partir d'une interface wayland simulée en HTML5+SVG dans un navigateur, le tout affichant « Prout ! » dans le site de microblogging de la victime, wizzant sa fenêtre de réseau social et le mettant comme ami de Pedobear. Sinon y a la clé USB qui insérée affiche « Prout ! » dans l'immédiat.

Absolument pas. Elle est de 25h depuis longtemps.

Debian vient aussi de retirer l'autorité de certification DigiNotar de ses paquets ca-certificates (Debian Security Advisory DSA-2299-1) et nss (DSA 2300).

Exactement. Problème temporairement réglé en reculant de 3 mois la date de création en base.

À sa publication, il était impossible de commenter cette dépêche, car « Impossible de commenter un contenu vieux de plus de 3 mois ».

L'explication : la dépêche a été commencée il y a longtemps, même si elle a été publiée récemment.

+-------------------------+---------------------+---------------------+
| title | created_at | updated_at |
+-------------------------+---------------------+---------------------+
| Miro 4 : pouet iTunes ! | 2011-05-25 11:33:03 | 2011-08-31 08:14:50 |
+-------------------------+---------------------+---------------------+

Problème temporairement contourné en retardant le created_at de 3 mois.

Un « web of trust » à la GPG donc ? Le contraire d'un système centralisé à base d'autorité(s) de confiance.

Par deux unités de calcul différentes. D'un côté une addition sur 64 bits, de l'autre une addition sur 80 bits dont le résultat est ensuite tronqué/arrondi sur 64 bits. Disons que quand on sait ce qui se passe, c'est logique, mais que spontanément on ne pense pas forcément en premier lieu qu'il y a des calculs avec surprécision dans l'unité de FPU...

La subtilité c'est que l'arrondi peut avoir lieu à des précisions différentes suivant là où il est effectué, le CPU faisant les calculs sur 64 bits en double, alors que la FPU les fait sur 80 (donc à chaque passage de l'un à l'autre, y a apparition/disparition de précision). Et que l'endroit où est effectué l'arrondi dépend des optimisations du compilateur, donc des options de compilation (et du compilateur).

Bref cela peut amener au contre-intuitif (A+B) != (A+B) suivant qui fait l'addition. Et je parle bien de dire que (1/3+1/3+1/3) != (1/3+1/3+1/3), et pas de (1/3+1/3+1/3) != 1 qui n'est pas surprenant en calcul flottant.

C'est pire que cela en fait, cf le bug 323 ouvert depuis 11 ans chez GCC, et qui va le rester, le flottant peut passer par les registres plus précis de la FPU aussi...

#include <iostream>

double foo(unsigned nb) {
        double sum = 0.9;
        for (unsigned i=0; i<nb;++i) sum+=0.1;
        return sum;
}

int main() {
        double diff = 1.0 - foo(1);
        std::cout << diff << std::endl;
}

Résultat attendu : 0 (c'est le cas en GCC 4.4)
Résultat obtenu : -2.77556e-17 (GCC 2.95 à 4.0 au moins, sur x86)

Palliatifs : déclarer sum comme volatile et utiliser -ffloat-store (Do not store floating point variables in registers, and inhibit other options that might change whether a floating point value is taken from a register or memory.)

Codage en binaire (IEEE float 32 bits, double 64 bits, long double 80 bits), prenons le cas des float par exemple :

• 1.0 = (-1)^0 . 2^(127-127) . (1.00000000000000000000000)
• 0.1 ~ (-1)^0 . 2^(123-127) . (1.10011001100110011001101...)
• 0.9 ~ (-1)^0 . 2^(126-127) . (1.11001100110011001100110...)

Le problème rencontré est dû à la précision excessive dans l'unité de calcul en virgule flottante (FPU). Les calculs en interne sont plus précis que les résultats renvoyés.

Je n'ai pas lu l'article, mais ça avait l'air marrant alors j'ai testé rapidement en C++ :

#include <iostream>
#include <limits>
#include <typeinfo>

using namespace std;

template <typename T> void swap1(T & A, T & B) {
  T oldA = A;
  T oldB = B;
  A = A + B;
  B = A - B;
  A = A - B;
  if (!((A==oldB) && (B==oldA))) {
    cout << "swap+\ttype=" << typeid(T).name()
     << "\tavant A=" << oldA << "\tB=" << oldB
     << "\taprès A=" << A << "\tB=" << B << endl;
  }
}

template <typename T> void swap2(T & A, T & B) {
  T oldA = A;
  T oldB = B;
  A ^= B;
  B ^= A;
  A ^= B;
  if (!((A==oldB) && (B==oldA))) {
    cout << "swap^\ttype=" << typeid(T).name()
     << "\tavant A=" << oldA << "\tB=" << oldB
     << "\taprès A=" << A << "\tB=" << B << endl;
  }
}

template <typename T> void letsTest(void (*swap)(T&, T&)) {
  T a;
  T b;

  a = 42; b = 69; (*swap)(a,b);
  a = numeric_limits<T>::max(); b = 42; (*swap)(a,b);
  a = numeric_limits<T>::min(); b = 42; (*swap)(a,b);
  a = numeric_limits<T>::max(); b = numeric_limits<T>::max(); (*swap)(a,b);
  a = numeric_limits<T>::min(); b = numeric_limits<T>::max(); (*swap)(a,b);
  a = numeric_limits<T>::max(); b = numeric_limits<T>::min(); (*swap)(a,b);
  a = numeric_limits<T>::min(); b = numeric_limits<T>::min(); (*swap)(a,b);
}

int main() {
  letsTest<char>(swap1);
  letsTest<bool>(swap1);
  letsTest<short>(swap1);
  letsTest<int>(swap1);
  letsTest<long>(swap1);
  letsTest<long long>(swap1);
  letsTest<unsigned short>(swap1);
  letsTest<unsigned int>(swap1);
  letsTest<unsigned long>(swap1);
  letsTest<unsigned long long>(swap1);
  letsTest<float>(swap1);
  letsTest<double>(swap1);
  letsTest<long double>(swap1);

  letsTest<char>(swap2);
  letsTest<bool>(swap2);
  letsTest<short>(swap2);
  letsTest<int>(swap2);
  letsTest<long>(swap2);
  letsTest<long long>(swap2);
  letsTest<unsigned short>(swap2);
  letsTest<unsigned int>(swap2);
  letsTest<unsigned long>(swap2);
  letsTest<unsigned long long>(swap2);
}

Les cas erronés (résumé : le premier swap ne marche pas sur les bool et tous les flottants) :

swap+ type=b avant A=1 B=1 après A=1 B=0
swap+ type=b avant A=1 B=1 après A=1 B=0
swap+ type=b avant A=1 B=1 après A=1 B=0
swap+ type=f avant A=3.40282e+38 B=42 après A=0 B=3.40282e+38
swap+ type=f avant A=1.17549e-38 B=42 après A=42 B=0
swap+ type=f avant A=3.40282e+38 B=3.40282e+38 après A=-nan B=inf
swap+ type=f avant A=1.17549e-38 B=3.40282e+38 après A=3.40282e+38 B=0
swap+ type=f avant A=3.40282e+38 B=1.17549e-38 après A=0 B=3.40282e+38
swap+ type=d avant A=1.79769e+308 B=42 après A=0 B=1.79769e+308
swap+ type=d avant A=2.22507e-308 B=42 après A=42 B=0
swap+ type=d avant A=1.79769e+308 B=1.79769e+308 après A=-nan B=inf
swap+ type=d avant A=2.22507e-308 B=1.79769e+308 après A=1.79769e+308 B=0
swap+ type=d avant A=1.79769e+308 B=2.22507e-308 après A=0 B=1.79769e+308
swap+ type=e avant A=1.18973e+4932 B=42 après A=0 B=1.18973e+4932
swap+ type=e avant A=3.3621e-4932 B=42 après A=42 B=0
swap+ type=e avant A=1.18973e+4932 B=1.18973e+4932 après A=-nan B=inf
swap+ type=e avant A=3.3621e-4932 B=1.18973e+4932 après A=1.18973e+4932 B=0
swap+ type=e avant A=1.18973e+4932 B=3.3621e-4932 après A=0 B=1.18973e+4932

Et le second swap ne marche pas sur les flottants.

Bof perso j'avais déjà discuté de ce point avec un des organisateurs sur place aux RMLL, en leur conseillant de faire une dépêche... Ta question était mal formulée, laissant entendre qu'il fallait forcément une carte dès le début, qu'elle est requise, nécessaire, obligatoire.

Il faut très probablement lire « Open Source » au sens définition de l'Open Source Initiative, soit en gros une définition équivalente à celle de logiciel libre avec les 4 libertés.

Et donc ne pas lire « open source » littéralement, au sens « le code est regardable, mais on touche juste avec les yeux ».

Ceci étant dit, d'après les pythies (*) de LinuxFr.org :

amessage, André Pousse, BeOS, Branson, BSD, ce perroquet, l'internet libre français, Napster, Planète Linux, "ça" (et en particulier « ça fait trois fois qu'il est mort »), Charles Bronson, citefutee, cryptoloop, DTML, Emacs, Farenheit, Flash, Freeamp, gaim, Helmut Newton, Microsoft, Hurd, "il", internet, Kadreg, la culture, le ftp, le lien, le pape, le projet MicroBSD, le roi, le troll, le web, l'hirondelle, l'industrie du disque, Linux @ Business, Linux, Linuxfrench, Linux populaire, Linux-Pratique, Lmule, Lyon 1, Maemo, Mandrake, DLFP, son blog, son chat, MS-OOXML, Napster, Netscape, OpenBSD Journal, Pierre Tramo, Pompidou, popup, Oracle, RMS, Shawn lane, Suse, Templeet, Ulice, United Linux, usenet, wiki et XFree sont morts.

(*) je voulais mettre « oracles », mais Oracle et troll sont morts paraît-il.

Tandis que toujours suivant nos analystes, BoomTchak est mourant et qu'une radio qui parlait des logiciels libres va mourir.

Par contre ils hésitent encore concernant la mort de Dyndns, Kde-look, google, ZDnet, knoppixfr.org, du lien (il était pas mort précédemment lui ?), du troll (idem), Looking Glass, du livecd et de Tribune libre.

Et là je ne parle que des titres des commentaires... Visiblement, comme dirait Mark Twain, « The reports of my death are greatly exaggerated. »

Ouais mais je parlais de « Flash va mourir ». Il s'avère juste qu'il est mort avant de mourir donc. Et d'ailleurs c'est arrivé avant https://linuxfr.org/nodes/25782/comments/1124085 (journal d'avril 2010).

C'est mieux en lisant les liens donnés : « un simulateur de Mini2440 avec Qemu »

Après une recherche sur l'ensemble des dépêches, journaux, forums et commentaires présents en base de données sur la chaîne « Flash va mourir », je peux dire que la première occurrence est dans ton commentaire.

Non, une coquille en modération.

Euh non c'est relativement facile d'avoir de l'ADSL sans box. J'ai toujours un vieux modem Alcatel SpeedTouch Ethernet par exemple. Juste que je n'ai pas accès à la TV par ADSL et à la ToIP via mon FAI.

C'est plus simple de demander un changement de l'adresse de courriel du compte alors... Changer le LOGIN1 pour LOGIN2 pose des problèmes (d'URL notamment). Mais fermer LOGIN1 et virer son adresse de courriel, puis ouvrir LOGIN2 avec la même adresse ne pose pas de souci technique.

À noter que garder l'adresse d'un compte à la fermeture permet de filtrer certains pénibles type spammeurs, auteurs de propos haineux, etc. et aussi empêche d'ouvrir 10 comptes avec une même adresse. A priori si quelqu'un choisit de fermer son compte, ce n'est pas pour en ouvrir un autre en général.

HAL-9000

Ce n'est pas spécialement un appel à contribution, c'est une entrée dans le suivi de LinuxFr.org, pour déclarer un bug/fonctionnalité que l'on pourrait ajouter, et pour ne pas oublier de le faire/d'en discuter plus tard.

Je ne comprends pas la question.

Au niveau LinuxFr.org, le but serait juste d'éviter qu'une version du site via un proxy ne soit indexée par les moteurs de recherche (parce que ça nuit à la recherche d'infos sur notre site). Donc nous avons juste à identifier les proxys concernés (*), et à ajouter une entête HTML pour eux.

Les proxys qui ne sont pas indexés, on s'en fiche (que ça soit un proxy d'entreprise, un proxy Tor ou autre).

(*) pour ceux auxquels je pense c'est trivial, via le User-Agent.

Ceci dit il est fort possible que ça soit finalement suffisamment marginal pour être inutile de s'en préoccuper plus.