Krunch a écrit 4025 commentaires

Ah, moi sur http://www.google.com/search?q=get+the+facts la première page que je trouve c'est thefacts.com.au

pertinent adj. Approprié : qui se rapporte exactement à ce dont il est question.

> Ce que je ne comprend pas dans toute cette histoire, c'est si
> des entités se font des millions (milliards ?) de $, qui sont ceux qui
> en perdent autant ?

Moi on m'a dit que ça ne tombe pas juste tout ça parce qu'il y a des gens qui créent des richesses. Genre quand tu écris un programme utile, tu crées de la richesse mais personne n'en perd.

C'est la théorie en tout cas.

pertinent adj. Approprié : qui se rapporte exactement à ce dont il est question.

Dans la mesure où la bourse est fermée en dehors des heures de bureau, ça laisse plein de temps pour changer le matériel en fin de vie chaque jour. Par ailleurs, il est aussi possible d'architecturer pour pouvoir cramer un processeur au hasard sans affecter la production.

pertinent adj. Approprié : qui se rapporte exactement à ce dont il est question.

Pourquoi utiliser ClusterShell plutôt que massadmin ? https://linuxfr.org/2010/09/28/27421.html

pertinent adj. Approprié : qui se rapporte exactement à ce dont il est question.

Pourquoi utiliser massadmin plutôt que ClusterShell ? https://linuxfr.org/2010/09/24/27412.html

pertinent adj. Approprié : qui se rapporte exactement à ce dont il est question.

Si tu ne chiffres que tes connexions importantes, il est beaucoup plus facile de les espionner que si elles sont noyées parmi nombre d'autres connexions triviales mais chiffrées également.

pertinent adj. Approprié : qui se rapporte exactement à ce dont il est question.

toutafé
http://www.pathname.com/fhs/pub/fhs-2.3.html#TMPTEMPORARYFIL(...)
http://www.pathname.com/fhs/pub/fhs-2.3.html#VARTMPTEMPORARY(...)

pertinent adj. Approprié : qui se rapporte exactement à ce dont il est question.

> tu as déjà vu le nombre de popup quand tu branche un nouveau clavier dans Windows?

À vrai dire, non.

Mais à partir du moment où le « clavier » est branché, il devrait pouvoir désactiver les popups de manière assez rapide pour que ça ne se remarque pas trop.

Mais de toute façon apparement, ça n'est pas la technique qui était utilisée dans ce cas.

pertinent adj. Approprié : qui se rapporte exactement à ce dont il est question.

Et ?

Avec noexec ça devient plus amusant mais sur la plupart des systèmes tu peux trouver un répertoire dans lequel tu peux écrire un exécutable avec l'utilisateur de base.

pertinent adj. Approprié : qui se rapporte exactement à ce dont il est question.

> sans se rendre compte qu'elle réagit bizarrement (détection de nouveau
> clavier par Windows au pire ou simplement la clef est non-fonctionnelle)

La clé peut présenter un clavier juste le temps d'introduire le malware. Elle peut aussi sans doute présenter à la fois un clavier et du mass storage en même temps (je connais pas bien les spécifications USB mais ça ne me semble pas impossible vu qu'il existe des hubs USB).

pertinent adj. Approprié : qui se rapporte exactement à ce dont il est question.

Si la clé USB se présente comme un clavier, celui-ci peut effectuer toute action que l'utilisateur pourrait taper au clavier (comme par exemple copier un sudo « personnalisé » dans ~/.bin et ajouter le répertoire dans le PATH).

Je ne sais pas si dans ce cas ci c'est la technique utilisée mais en principe, cela pourrait fonctionner aussi bien sous Windows que GNU/Linux (OK, la même implémentation pour les deux va être plus compliquée) et l'autorun n'a pas besoin d'être activé.

http://blogs.msdn.com/b/oldnewthing/archive/2009/11/09/99195(...)

pertinent adj. Approprié : qui se rapporte exactement à ce dont il est question.

Bon, ça va poser problème si tu as un truc genre « char plop[] = "foo//bar"; » mais sinon ça a l'air de marcher :

my $incomment;
while (<>) {
        chomp;
        if (not m|^\s*//| and $incomment) {
                s|^| */$/|;
                undef $incomment;
        }
        if (m|//| and not $incomment++) {
                s|//|/\*|;
                s|$|$/|;
                next;
        }
        if ($incomment and m|^\s*//|) {
                s|(\s*)//|$1|;
                next;
        }
        if (not $incomment and not m|//|) {
                s|$|$/|;
        }
} continue {
        print;
}

pertinent adj. Approprié : qui se rapporte exactement à ce dont il est question.

L'adresse e-mail de William Cohen n'est pas visible (bien que présente dans le HTML). J'ai oublié de préciser que le second numéro pour l'Amérique du Nord est gratuit.

pertinent adj. Approprié : qui se rapporte exactement à ce dont il est question.

> Anéfé, je me suis fais violemment moinssé sans raison, pour avoir écrit le
> commentaire suivant :
> « {{reference needed}}
>
> Pour moi il n'y aucune autre raison que celle de froisser les annonceurs qui
> financent le tout venant. » en réponse à l'affirmation fautive qui précédait :
> « A la TV on ne peut pas trop citer des marques pour ne pas se faire accuser
> de publicité clandestine. »

Ton commentaire était trop long (comme ton journal). Si tu avais laissé juste l'essentiel tu aurais fait un +4 : https://linuxfr.org/2010/08/06/27217.html#1150363 (ok c'est sans doute plus facile quand ça parle de cul^Wseins)

pertinent adj. Approprié : qui se rapporte exactement à ce dont il est question.

> Ne pas prendre la responsabilité d'allouer de l'espace mémoire permet de
> laisser au client le choix de l'allocateur, du type de mémoire (automatique ou
> dynamique), etc.

Heu, le gros problème du C c'est que tu dois te coltiner la gestion de la mémoire toi même justement et qu'il est facile de faire des erreurs. Si la fonction gère la mémoire à la place de l'appelant, ça fait beaucoup mois de possibilités d'erreurs.

Après, il y a des cas où utiliser un buffer static ne correspond pas aux besoins de l'appelant mais alors tu fais une variante fonction_r().

Quant à la sois disant perte de performance dûe à l'initialisation, charger un octet en mémoire (ou même 1024 octets) me semble passablement moins couteux que de faire un malloc().

pertinent adj. Approprié : qui se rapporte exactement à ce dont il est question.

j'imagine, toute variable statique n'est initialisée qu'au moment du premier appel (à vérifier néanmoins). Arrête d'imaginer et vérifie. Les variables static initialisées à autre chose que 0 vont dans la section data au lieu de BSS (comme indiqué par neologix et GLMF#2^7) :

$ cat t.c 
#include <stdio.h>
#include <stdlib.h>

static int s(int d)
{
        static int zero;
        static int quarantedeux = 42;
        return d + zero + quarantedeux;
}

int main(int argc, char **argv)
{
        printf("%d\n", s(atoi(argv[1])));
        return 0;
}
$ cc -O0 -o t.so t.c
$ nm t | egrep 'zero|qua'
0000000000600968 d quarantedeux.2396
0000000000600980 b zero.2395

pertinent adj. Approprié : qui se rapporte exactement à ce dont il est question.

Dans le sens où la fonction elle-même est static, il n'y a pas vraiment de possibilité pour quelqu'un qui n'a pas de visibilité dans la fonction elle-même de l'utiliser de manière concurrente (ou alors de manière indirecte mais alors j'ose espérer que la non-réentrance est documentée).

pertinent adj. Approprié : qui se rapporte exactement à ce dont il est question.

Bah tu arrêtes tout et tu attaches un debugger.

pertinent adj. Approprié : qui se rapporte exactement à ce dont il est question.

L'utilisation de {g,s}etcontext() au niveau applicatif me semble assez douteuse (autant abstraire ça dans une bibliothèque de threading) mais différentes techniques permettant de servir plusieurs clients par thread sont détaillées sur http://www.kegel.com/c10k.html

pertinent adj. Approprié : qui se rapporte exactement à ce dont il est question.

Toutafé, le C pour le web c'est mal et pas secure. Yaka voir http://undeadly.org/ qui est plein de gens qui comprennent rien à la sécurité.

pertinent adj. Approprié : qui se rapporte exactement à ce dont il est question.

> J'avais lu que Hurd a de gros problèmes de performances car les données
> doivent être copiées d'un processus à l'autre

Pour faire passer des données d'un processus à l'autre, il n'y a pas forcément besoin de les copier puisque le kernel peut mapper la même page dans les deux processus. Le problème c'est plutôt le coût du passage userland/kernel puisque tout est en userland et qu'il faut forcément passer par le kernel pour passer d'un processus/thread/serveur userland à l'autre.

> Soit les processus partagent de la mémoire. Ce qui revient un peu à utiliser des threads
> avec de la mémoire partagée. Un bug ou une faille de sécurité affectant un processus
> va contaminer tous les autres processus.

Si la mémoire n'est qu'en lecture seule pour tous les processus sauf un, non.

En pratique je suppute que ashd est passablement pourri au niveau des performances mais en théorie il devrait y avoir moyen d'en faire quelque chose d'assez correct je pense.

pertinent adj. Approprié : qui se rapporte exactement à ce dont il est question.

De ce que je comprend de ce lien, ils ont utilisé du code GPL par erreur (via un sous traitant) et ils ont effectué une nouvelle release qui respecte la licence (avec sources) dans les deux semaines après avoir été notifiés (et en promettant de faire plus attention la prochaine fois). On peut reprocher plein de trucs à Microsoft mais cet exemple particulier me semble assez peu pertinent.

Si quelqu'un a des meilleurs exemples de contrefaçon de la part de Microsoft je suis intéressé.

pertinent adj. Approprié : qui se rapporte exactement à ce dont il est question.

J'ai une expérience assez limitée dans le domaine mais :

Maximum size for a database? unlimited (32 TB databases exist)
Maximum size for a table? 32 TB
http://wiki.postgresql.org/wiki/FAQ#What_is_the_maximum_size(...)

Si tu as des indexes bien pensés, que le matériel est dimensionné correctement et que tu fais pas des requêtes trop louches, je vois pas pourquoi cela poserait des problèmes de performance quelque soit la taille de la table/base.

A priori je verrais un stockage des données dans une série de tables (changement toutes les X semaines ou à chaque fois qu'on approche des 32 TB) avec une table à côté pour indexer dans quelle table se trouve quoi.

Ça pourrait s'appliquer aussi bien à PostgreSQL que Oracle que MySQL que n'importe quelle autre db je pense.

pertinent adj. Approprié : qui se rapporte exactement à ce dont il est question.

> - La performance à la résolution de problèmes (troubleshooting) et au tuning : comment
> résoudre un problème posé par PostgreSQL, comment se sortir des situations de non
> performances etc. PostgreSQL est bien outillé pour fournir les informations nécessaires au
> tuning et à la gestion des cas d'erreur. De ce point de vue, Oracle fait plutôt appel à
> l'expérience et à des recettes de tuning. L'outillage idoine d'Oracle est effectivement plus
> évolué de ce point de vue.

Il y a des probes DTrace/SystemTap dans Oracle ?

pertinent adj. Approprié : qui se rapporte exactement à ce dont il est question.

> Microsoft : Contrefaçon

J'ai dû rater un épisode. Microsoft contrefait quoi ?

pertinent adj. Approprié : qui se rapporte exactement à ce dont il est question.