Benoît Sibaud a écrit 9683 commentaires

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.

En France, l'enveloppe est donnée dans le bureau de vote.

Par contre tu peux venir avec ton (tes) bulletin(s) papier (reçu(s) par courrier postal avec les professions de foi).

Le vote électronique arrive en France, enfin, pour l'élection des représentants d'une partie du peuple, la partie du peuple qui a préféré émigrer.

(je pense sur le enfin, perso ça ne fait pas rêver des votes sans contrôle citoyen, comme dans ma ville d'Issy les Mx... cf mes journaux sur le sujet et ma page perso)

Trois rapports accablants d’experts ont été produits à l’occasion de l'élection de 2006 :

• celui de François Pellegrini http://www.ordinateurs-de-vote.org/IMG/pdf/rapport_pellegrini.pdf « L'utilisation de tout système conduisant à une dématérialisation de l'information du suffrage est à proscrire. (...) Dans les cas où il est nécessaire de mettre en oeuvre un mécanisme de vote à distance (...) le mécanisme le plus fiable reste le vote par correspondance papier. » « je ne pense pas que la sincérité d'un scrutin dématérialisé tel que celui-ci puisse être garantie »
• celui de Bernard Lang http://www.datcha.net/ecrits/liste/evote-internet-2006.html « Cependant, il est peu vraisemblable, voire invraisemblable, qu'un seul expert puisse réunir toutes les compétences spécialisées requises par un système de cette complexité, compte tenu de l'importance des détails dans cette entreprise. » (alors pensez donc pour le citoyen lambda)
• et un troisième de Andrew W. Appel. http://www.ordinateurs-de-vote.org/spip.php?article168 « I observed many things about the process of the election that will make it impossible for the assesseurs to certify with any confidence that the election is conducted accurately and without fraud »

Et les commentaires supprimés.