gouttegd a écrit 1805 commentaires

On peut aussi simplement se poser la question de l'utilité réelle des certificats, surtout sachant qu'il a déjà été démontré qu'on peut créer des faux

À ma connaissance, les seuls cas avérés de certificats falsifiés étaient des certicats utilisant un condensat MD5.

Ce n’est pas parce que les autorités de certification font n’importe quoi — comme continuer à utiliser un algorithme longtemps après que sa résistance a été mise en doute — qu’il faut jeter le bébé avec l’eau du bain. Ce ne sont pas les certificats X.509 le problème, mais la manière de valider leur authenticité.

SSL devrait se contenter de faire se qu'il sait faire: chiffrer.

Sans authentification (ou avec une fausse promesse d’authentification comme celle apportée par les autorités de certification), ça ne sert à rien contre les attaquants actifs — ça protège contre Eve, pas contre Mallory.

Je propose un certificat :

• signé par une autorité de certification quelconque (CAcert ou une autre, peu importe, le problème des CA vient du système même des CA, non d’une CA particulière) ;

• publié dans le DNS via un enregistrement TLSA ;

• transformé en clef publique OpenPGP signée par un administrateur du site et publiée sur un serveur de clefs OpenPGP.

Comme ça tout le monde est content :

• ceux qui se contentent de PKIX et de ses faiblesses inhérentes ;

• ceux qui ont un résolveur DNS validant et un navigateur qui connaît DANE ;

• ceux qui connaissent directement l’administrateur du site, ou qui ont un chemin vers lui dans leur réseau de confiance OpenPGP.

Du coup, la seule manière de s'assurer de la reproductibilité, ça serait de répliquer la manip dans un autre laboratoire, par un autre expérimentateur. Et là, si tu es logique avec toi-même, tu devrais dire que la réplication inutile d'expériences concluantes a couté de l'argent public alloué à la recherche, avec lequel tu aurais pu faire d'autres expériences et avancer plus vite.

Non, en étant logique avec moi-même, je préfère 100 études rapportant 50 résultats reproductibles (à partir desquelles on peut réellement avancer) à 100 études rapportant 100 résultats à la reproductibilité incertaine.

Et je ne vois pas pourquoi on blâmerait les scientifiques pour de telles affaires ;

Je n’ai jamais parlé de blâmer qui que ce soit.

Il n’y a matière à blâmer que dans le cas où la non-reproductibilité est le fait de pratiques laxistes ou carrément frauduleuses. Si ce n’est pas la majorité des cas, pourquoi penses-tu immédiatement que je veux blâmer quelqu’un ?

c'est le processus normal des avancées scientifiques : on infirme ou confirme des hypothèses sur la base de faits ; parfois on se trompe, alors on revient en arrière, et on recommence.

Je pense que tu confonds deux choses :

• Émettre une hypothèse, la tester expérimentalement, et s’apercevoir qu’elle n’est pas valide (pas confirmée par l’expérience) : effectivement, c’est la base même de la méthode scientifique. Peut-être que tester l’hypothèse a coûté whatmille euros, mais il n’y a rien de reprochable là-dedans.

• Émettre une hypothèse, la tester expérimentalement, et obtenir et publier un résultat de mauvaise qualité — ou pire, frauduleux (peu importe d’ailleurs que le résultat prétende confirmer ou infirmer l’hypothèse). Là c’est de l’argent jeté par les fenêtres.

Oui, quand c’est bien fait. Ce qui n’est pas toujours le cas, même quand c’est publié par des « gros ».

Parfois, c’est bien fait, mais l’éditeur décide de passer outre. Après tout publier un résultat sensationnel est plus important que la qualité scientifique des travaux, n’est-ce pas ?

C’est ainsi que Nature a publié les papiers sur les « STAP stem cells » contre l’avis des reviewers qui avaient correctement pointé du doigt les faiblesses de ces papiers…

Aussi bête que ça puisse paraitre, ça n'a presque aucune importante. Les résultats importants sont reproduits, et on s'aperçoit rapidement s'ils ne tiennent pas. Les résultats pas importants tombent dans l'oubli, qu'ils soient reproductibles ou non ne change rien.

Ça change que les études non-reproductibles ont quand même coûté leur part de l’argent public alloué à la recherche.

Si ça ne te dérange pas, tant mieux, mais moi je préférerais que cet argent soit mieux employé (déjà qu’il n’y en a pas beaucoup…).

Attention, je ne dis pas que l’orientation des financements doit être exclusivement décidé par des bureaucrates qui ne pensent qu’en termes d’efficacité, de profits ou de rendements sans rien connaître de la science sous-jacente.

Mais on ne peut pas pour autant justifier de jeter ainsi de l’argent par les fenêtres au motif que « la recherche doit rester artisanale ». Quand on injecte des millions d’euros dans un truc, ce n’est plus « artisanal ».

tu te mets à la paillasse et tu essayes de reproduire les manips.

Et avec quel argent ? Va donc essayer d’obtenir des financements pour uniquement reproduire un résultat déjà publié, quand tout le monde à côté demande des financements pour obtenir des trucs nouveaux (qui ne seront pas reproductibles, mais c’est pas grave, tu l’as dit toi-même)…

Et une fois que tu as reproduit les résultats, va donc essayer de publier un papier qui ne fait que confirmer un papier précédent.

La seule initiative dans ce sens que je connaisse, c’est le Reproducibility Project, dont la seule existence met en évidence que tenter de reproduire les résultats de cinquante malheureux papiers (sur les trouze millions publiés) est un effort extraordinaire.

Non, comme beaucoup de programmes Unix sed lit son entrée standard s’il ne trouve pas de noms de fichier sur sa ligne de commande.

Mais par contre n'y a-t-il pas un moyen de faire sans le fichier tmp ?

Si, avec un tube (« pipe ») : au lieu de rediriger la sortie de echo vers un fichier temporaire, tu la rediriges vers l’entrée de sed.

La plupart des chercheurs se posent des questions originales utilisent des méthodes uniques ou personnalisées, à partir d'échantillons uniques, etc.

Quelles belles excuses pour justifier des résultats que personne n’arrive à reproduire en dehors du labo d’origine…

De manière générale, il faut se méfier des mecs qui prétendent expliquer aux autres comment faire leur travail correctement.

Et ceux qui prétendent expliquer aux autres qu’ils doivent se méfier d’un type dont ils viennent à peine de découvrir l’existence, tu t’en méfies aussi ?

D’une part, l’expression rationnelle n’est pas bonne : les guillemets n’ont pas de signification pour sed, il va chercher une suite de trois caractères « guillemet – espace – guillemet » au lieu d’un caractère « espace ».

Ensuite, tu ne récupères pas la sortie de sed, alors que c’est ce dont tu as besoin.

Deux pistes :

• les « substitutions de commande » permettent de récupérer la sortie d’une commande et, par exemple, de l’affecter à une variable ;
• le « pipe » permet d’envoyer la sortie d’une commande vers l’entrée d’une autre.

Avec ça, tu peux construire ta variable VAR en une seule ligne.

Je ne sais pas comment tu t’y prends, mais en utilisant la variable $@, le nombre d’espaces entre les arguments lors de l’invocation du script n’a aucune importance…

À noter que je trouverais plus lisible d’écrire le test sur VAR et l’affectation subséquente en une seule ligne :

[ -n "$VAR" ] && VAR="$VAR,$i" || VAR="$i"

Mais ça n’engage que moi.

C'est la dernière virgule qui gène et je sais pas comment l'enlever

Il serait plus simple de ne pas la mettre plutôt que de l’enlever ensuite.

Il y a plusieurs moyens de faire ça, moi a priori je testerais à chaque tour de boucle si VAR contient déjà quelque chose (auquel cas on y ajoute une virgule puis l’argument courant) ou non (auquel cas on y ajoute juste l’argument courant).

L’expression suivante devrait fonctionner :

sed 's/(\(\\cite{[^}]\+}\))/\1/' fichier.tex

Ou, avec la syntaxe des « expressions rationnelles étendues » :

sed -r 's/\((\\cite\{[^}]+\})\)/\1/' fichier.tex

(Le résultat est le même, seuls les caractères à échapper changent.)

par contre il n'est pas USB, tu fais comment pour le relier à l'ordi (carte externe MIDI ou bien cable usb/Midi) ?

Par une interface audio USB, une Roland UA-4FX.

J’ai aussi utilisé une interface audio FireWire (PreSonus FireBOX), ça marche aussi bien à condition d’avoir un contrôleur FireWire de qualité sur le PC.

ma question était plutôt de savoir si on peut assigner chaque bouton du clavier à une fonctionnalité sur le logiciel

Si le logiciel en question est ZynAddSubFX, spécifiquement, non.

Dans l’ensemble, ZynAddSubFX est très peu pilotable par MIDI, à l’exception des changements de programmes et de quelques paramètres généraux (volume, expression, sustain, filter cutoff, portamento, et deux ou trois autres). Notamment, la plupart des paramètres de synthèse ne sont pas pilotables.

j'en reviens au clavier que j'ai mis comme exemple un peu plus haut et pour lequel je n'ai pas eu de réponse honnête

Je suis allé voir ce qu’en disait le constructeur. En gros, tu fais comme tu veux mais moi je ne l’achèterai pas…

Il est évident que ce contrôleur est spécialement conçu pour fonctionner avec la gamme de logiciels du constructeur plus quelques autres logiciels spécifiques (Cubase & co.). Si c’était un vrai contrôleur standard, il n’y aurait pas besoin d’intégration.

Le constructeur dit lui-même (enfin, sans vraiment le dire) que ce n’est pas vraiment un contrôleur MIDI (question 9) :

« puis-je utiliser le port MIDI à 5 broches sur mon clavier KOMPLETE CONTROL S-Series pour activer d’autres instruments matériels et logiciels ? »

(Bref, puis-je m’en servir comme d’un clavier maître, quoi). Réponse :

Le port 5 broches ne fonctionne actuellement pas en mode autonome. Vous devez brancher le clavier à un ordinateur et envoyer les données MIDI depuis une application hôte.

Si on ne peut pas piloter d’autres instruments MIDI, ce n’est pas un contrôleur MIDI, point.

Dernier point qui me rebute franchement : impossible de trouver la « MIDI implementation chart », même dans la section « spécifications ».

Je me réponds à moi-même, pour dire que ces constantes « secrètes » sont en fait inoffensives a priori, vu que si j’ai bien compris elles ne servent complètement à rien.

En effet arc4random(3), sur les systèmes où cette fonction existe, est semble-t-il directement « seedé » par le générateur de nombre aléatoires du système (soit par lecture de /dev/urandom, soit par getentropy(2)). srandom(3) sert à initialiser le générateur derrière random(3) et n’a pas d’effets sur arc4random(3).

Et en dehors de tout ce beau discours vous connaissez un clavier maitre avec des drivers Linux qui permettent de tout faire fonctionner (les pitchs les pads les divers potars…)?

Non, je n’en connais pas. Et pour cause, mon clavier maître (Roland Edirol PC180A) et mon synthétiseur (Korg microX) fonctionnent tous les deux out-of-the-box sous GNU/Linux, sans le moindre driver autre que les modules inclus dans le noyau vanilla, et ce depuis au moins 2005.

ça me confortera dans ma volonté de dire du mal sur la MOA/Linux.

Si ça t’amuse… Moi perso je n’ai jamais eu envie de dire du mal de la MAO sous Windows, et pourtant j’aurais de quoi dire.

Cett situation intolérable (pour moi, dual boot berk) a pris fin en 2004, quand jack est devenu stable.

À peu près la même chose pour moi. J’ai effacé ma partition Windows le lendemain du jour où j’ai découvert Jack (qui devait déjà être stable à ce moment, je n’ai jamais eu de problèmes) et Rosegarden. Cubase était le dernier logiciel qui me retenait sous Windows.

Moi j’aime bien le fichier alea.c :

    srandom((unsigned int)(time(NULL) % 9061973)); // put a secret prime number to raise entropy
    u.seed_chunks.part1 = ((unsigned int)arc4random()%222)+32;
    srandom((unsigned int)(time(NULL) % 2039485230948572951)); // put a secret prime number to raise entropy
    u.seed_chunks.part3 = ((unsigned int)arc4random()%222)+32;
    read_random_device(8, u.seed_chunks.part5);
    srandom((unsigned int)(time(NULL) % 2039485267));  // put a secret prime number to raise entropy
    u.seed_chunks.part2 = ((unsigned int)arc4random()%222)+32;
    srandom((unsigned int)(time(NULL) % 98876033));  // put a secret prime number to raise entropy
    u.seed_chunks.part4 = ((unsigned int)arc4random()%222)+32;
    read_random_device(8, u.seed_chunks.part5 + 8);

    srand(clock()+(time(0)/3001));  //a secret prime number to raise entropy

    srand(clock()+(time(0)/3011));  // a secret prime number to raise entropy

Ça me paraît le plus raisonnable effectivement. J’ai déjà commencé à voir ce que je pouvais faire à partir de argparse.

Si j’aboutis à quelque chose de pas trop moche et presque fonctionnel, je vous en ferai part (ce sera libre, bien évidemment).

cela me fait penser à Gooey, un module pour créer une interface graphique à partir d'un script Python en ligne de commande.
Il te faudrait la même chose en version web.

Oui, c’est exactement ce qu’il me faudrait. Merci d’ailleurs, je ne connaissais ce projet. Je le garde sous le coude, ça pourra me servir…

TODO: Get OS X version working

… mais pas pour l’instant :/ avec mes collègues qui sont tous sous Mac OS X.

tu pourrais créer un outil assez complexe au final.

Si c’est moi qui m’y colle, il y a peu de chance. :-°

Pour le cli tu veux te connecté directement (via ssh ou genre putty) et executé tes commandes en directe ou envoyer juste la commande à executé via le réseau web comme le CGI ?

Non, le mode CLI, c’est pour exécuter directement sur ma machine, comme n’importe quel autre de mes scripts. Le mode CGI est un « bonus » pour mes collègues, mais j’écris mes scripts aussi pour moi-même et la ligne de commande est pour moi une interface beaucoup plus naturelle qu’un formulaire dans un navigateur.

Pour l’instant, ce que je fais ressemble à peu près à ça (en un peu moins à LA RACHE quand même) :

#!/usr/bin/python

import sys, os, getopt, cgi

if __name__ == '__main__':

    # Valeurs par défaut des options
    operation = 'intersection'
    format = 'csv'

    if os.getenv('GATEWAY_INTERFACE'):
        # mode CGI, on récupère les paramètres de la requête CGI
        form = cgi.FieldStorage()
        if len(form) == 0:
            # il n’y en a pas? on affiche le formulaire
            # qui permettra à l’utilisateur de saisir les paramètres
            print """Content-Type: text/html

<html>
    <body>
        <form action="script.py" method="post" enctype="multipart/form-data">
            <p>Operation to perform:</p>
            <p><input type="text" name="operation" /></p>
            <p>Output format:</p>
            <p>
                <select name="format">
                    <option value="xml">XML</option>
                    <option value="csv">CSV</option>
                </select>
            </p>
            <p><input type="submit" name="submit" /></p>
        </form>
    </body>
</html>"""

            # et on termine là pour l’instant, la soumission du
            # formulaire lancera une nouvelle exécution du script
            sys.exit(0)

        else:
            # Il y a des paramètres ? Bien. On les analyse, on
            # vérifie que tout est correct (les paramètres obligatoires
            # sont bien présents, les valeurs sont dans les limites
            # attendues, etc.)…
            operation = form['operation']
            format = form['format']

    else:
        # Pas de variable GATEWAY_INTERFACE ? On est en mode CLI,
        # on parse la ligne de commande

        try:
            opts, args = getopt.getopt(sys.argv[1:], 'o:f:', ['operation=', 'format='])
        except getopt.GetoptError:
            sys.exit(1)

        for o, a in opts:
            if o in ('-o', '--operation'):
                operation = a
            elif o in ('-f', '--format'):
                format = a

    # Arrivé ici, on a les paramètres dont on a besoin dans les
    # les variables 'operation' et 'format', on peut commencer
    # le vrai travail que le script est supposé faire, et qui
    # est indépendant de la manière dont le script a été appelé
    # (ou presque : en mode CGI, il faut quand même penser à faire
    # précéder la sortie d’un en-tête Content-Type)

Et ce que je voudrais, c’est pouvoir faire la même chose avec moins de code, genre quelque chose comme ça :

#!/usr/bin/python

import ModuleMagique

if __name__ == '__main__':

    m = ModuleMagique.ObjetMagique()
    m.addOption('operation', 'o', 'Operation to perform')
    m.addOption('format', 'f', 'Output format', allowedValues=['csv', 'xml'], defaultValue='csv')

    m.getArgumentsOrDie()

    # Si on arrive ici, c’est que le script a été appelé avec les bons
    # arguments (que ce soit en mode CLI ou en mode CGI), on peut
    # faire ce qu’on a à faire
    operation = m.arguments['operation']
    format = m.arguments['format']

Ce que je cherche, et que je suis éventuellement prêt à développer bricoler moi-même, c’est ce fameux ModuleMagique…

Donc ça rend service, merci je n’ai pas dit le contraire. Mais de là à dire que c’est ce qui fait que « le son marche sous GNU/Linux », désolé je ne suis pas d’accord.

M’enfin, on en arrive à un point où ceux qui encensent les projets de Poettering comme s’ils étaient miraculeux me saoûlent autant que ceux qui les critiquent sans chercher à les connaître, donc je vais profiter une dernière fois du strip « Discussion » et m’arrêter là. Désolé pour le bruit.

PA est le truc qui fait que l’audio marche sous linux, y compris avec plusieurs cartes son. Mais j’ai remarqué que ceux qui critiquent systemd sont aussi souvent ceux qui critiquent pulseaudio…

Faudrait voir à ne pas exagérer non plus. Que PulseAudio rende service, je veux bien, mais on ne l’a pas attendu pour profiter pleinement du son sous GNU/Linux…