Benoît Sibaud a écrit 9171 commentaires

À ma connaissance, Gcj utilise les bibliothèques de classes de GNU Classpath et non celles d'Apache Harmony.
http://fr.wikipedia.org/wiki/GNU_Classpath
http://www.gnu.org/software/classpath/
http://gcc.gnu.org/java/

La clause que tu évoques (et tu connais pour avoir eu le même contrat à signer) est « (...) s'interdit de porter atteinte directement ou indirectement à la réputation, à l'image de marque du Mécène (...) ». On peut aussi mentionner la clause de publicité : « Le logo et ou nom du Mécène sera présent sur le site Internet et l’ensemble des supports de communication de l'association (...) ». Le Mécène étant la Fondation Free. C'est le genre de clauses que l'on trouve dans tous les contrats de mécénat ou de subventions que j'ai pu voir, et un moteur de recherche célèbre le confirmera avec moultes occurrences. Oui, c'est un engagement contractuel clair évidemment.

Ceci étant dit, par rapport au commentaire précédent sur « LinuxFr.org vs GPL+FreeBox », ce contrat ne peut être invoqué, vu que le Mécène est bien la fondation Free, association déclarée au J.O. en 2008, et non Free, entreprise de type SAS datant de 1999, ou Iliad, entreprise de type SA datant de 1980.

Concernant trogood, on passe par la fondation Free qui le transmet à une association qui fait du reconditionnement/recyclage de serveurs (suivant les cas).

Concernant les précédents, je ne sais pas.

Qu'en est-il aujourd'hui ? Le datacenter où est le serveur ne gère pas IPv6 ?

Si. Ça fait partie des choses à faire.

À ma connaissance : en 1998, le serveur était chez l'employeur du moment de Fabien Penso, fondateur du site. En 2000, migration chez Multimania. En 2002, migration chez Illiad/Free (à l'époque dans le 16ème dans Paris dans un hôtel particulier avec des vitraux, puis migré en datacenter). Transférés ensuite à la fondation Free à sa création.

Les photos ne sont pas une vision correcte du datacenter de Free en général. Il ne s'agit que des baies de la fondation Free, qui héberge de nombreuses associations du libre.

Voir la vidéo de Free présentant deux datacenters

Concernant blob, je n'étais pas là à l'époque de sa mise en place, et la base de données actuelles commence en septembre 2000 (Tout n'est pas encore passé et certaines pages ne sont toujours pas transferées. on peut dire qu'elles ne le sont toujours pas...). Faudrait faire de la paléonto-informatique ou demander aux Grands Anciens.

Même chose pour les stats sur cette période... Sur le site actuel, les données statistiques conservées commencent en 2007 (sinon faut lire les dépêches annuelles sur le trafic des 12 mois précédents). Peut-être en demandant à archive.org les pages de 1999.

à quoi de s'identifier ?

Cf http://linuxfr.org/aide#aide-authentification

Et puis pourquoi toujours autoriser les votes anonymes ???

Parce qu'il y a plus de visiteurs non authentifiés que de visiteurs authentifiés.

Souci technique... Cf http://linuxfr.org/suivi/impossible-de-r%C3%A9ordonner-des-paragraphes-en-mod%C3%A9ration

Doublon du #582 que je venais d'ouvrir.
https://linuxfr.org/suivi/impossible-de-r%C3%A9ordonner-des-paragraphes-en-mod%C3%A9ration

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 ».