Michaël a écrit 2929 commentaires

Ton fichier reformat.sed

/Numero de serie/{
  s/.*//
  N
  h
}

/chiffrement du certif/{
  s/.*: //
  H
  x
  s/^\n//
  s/\n/,/g
  p
}

puis

% sed -n -f reformat.sed < input.text
12345677889,SHA256
23345677889,SHA1
26545677889,SHA1
26545677889,SHA1

Tu peux faire beaucoup plus simple pour la lecture en faisant

process_lines()
{
  local recordname type ip
  while IFS=',' read recordname type ip
    # Do something with the zone file
  done
}

print_csv()
{
  sed -n -e '2,$p' "$1"
}

print_csv "/tm[/csvfile" | process_lines

Aube Dorée est très minoritaire (6,28% aux dernières élections, en recul par rapport au précédentes)

C'est un précision très importante. Les quelques commentaires que j'avais pu lire dans la presse à leur sujet, les donnaient gagnants à l'élection qui a en réalité consacré Syrizia, leur donnant ainsi une importance qu'ils n'auraient pas en réalité.

Accepter de l'augmenter indéfiniment avec les propositions de l'UE c'est juste accepter un esclavage à vie.

Ce serait surtout ouvrir la voie à l'élection des néo-nazis d'Aube Dorée. Je pense qu'il faut éviter cela à tout prix, qui a envie de voir un tel parti arriver au pouvoir en Grèce – ou ailleurs? En dépit de la crise terrible qui s'abat sur lui, le peuple Grec a fait le choix de la démocratie et s'est doté d'un gouvernement républicain: tout ceux qui pousseraient Syriza vers l'échec politique feraient le jeu de l'extrême droite!

Je vois pas de quoi tu parles. (je suis pas très intelligent)

Pour faire des sauvegardes des fichiers sur une partition, tu peux faire:

1. Une copie bit à bit de la partition (genre dd)
2. Une copie du système de fichiers (comme avec dump sous FreeBSD)
3. Une copie des fichiers eux-mêmes (avec rsync par exemple).

Tu peux effectivement garder (en plus de /boot) une partition classique, au cas où, si ton volume physique LVM s’est banané… ça m’est jamais arrivé et je suis presque sûr que si ça m’arrive un jour se sera à cause d’un problème matériel.

Imaginons que j'ai planté un serveur qui ne démarre plus et mon prestataire me propose seulement d'accéder au disque via une console dédiée… pour réparer, je peux faire une copie bit à bit du système de base, réparer chez moi et retransférer l'image sur le serveur. Mon intérêt est d'avoir le transfert le plus petit possible, je suis donc intéressé par une forte granularité dans mon système de partititons.

(En vrai, c'est aussi un atout du immutable server pattern de ne pas avoir à se soucier de ces cas là!)

Est-ce que tu peux accéder aux volumes logiques à travers /dev/ ? Parfois c'est important d'avoir des partitions petites pour faire de la restauration bit à bit ou au niveau du système de fichier, à travers le réseau.

J'accepte toute aide pour des informations complémentaires et des pistes à ce sujet (équations mathématiques). Car pour l'instant je n'ai aucune idée de quoi chercher en particulier.

Le standard de fait utilisé par la communauté scientifique est LaTeX. L'AMS (American Math Society) a sponsorisé le développement de MathJax, un script JavaScript qui compile les formules LaTeX en HTML (probablement MathML).

Si tu veux l'intégrer à ton soft, le plus simple est de suivre les recommendations de l'AMS ou bien de regarder comment les autres le font (MathOverflow, plugin MathJax pour trac, par exemple).

Sous freebsd, quand faut compiler openoffice y a besoin de minimum 30Go…

C'est probablement vrai, mais si tu fais partie des rares personnes qui doivent compiler OO au lieu de l'installer par les packages, rien ne t'oblige à utiliser un dossier sur ton système racine comme répertoire de travail.

c'est vrai qu'avec la solution que je propose, le cas du tag qui s'étale sur 2 lignes ne sera pas pris en compte… mais ça peut se négocier :)

Oh oui, je pense qu'avec un script sed bien poilu, on pourrait presque à faire onsgmls sur du HTML! :D

D'un autre coté , l'idée est de "monter en compétence", donc l'utilisation d'un outil tout prêt ne me semble pas être ce que Bobmoutarde demande.

Oui bien sûr, mais c'est bien de savoir que certains outils ont leur limites, et l'idée qu'on peut utiliser des expressions rationnelles pour analyser le HTML, c'est comme le chiendent, il vaut mieux s'en débarrasser le plus vite possible. C'est pas comme si analyser du HTML était la seul chose qu'on pouvait faire avec du texte!

Par exemple, on peut extraire des données des pages HTML avec de expressions rationnelles. Si il cherche du texte pour rentrer dans la moulinette, il peut prendre des livres (Gutenberg Project), faire du sqlite3 + shell, etc.

http://stackoverflow.com/questions/1732348/regex-match-open-tags-except-xhtml-self-contained-tags/1732454#1732454

Utilise le programme onsgmls de Jim Clark pour normaliser ton document

% onsgmls index.html 2>&- | sed -n -e 's/^(//p' | sort | uniq -c
   4 A
   1 BODY
   2 BR
   1 DIV
   1 H1
   1 HEAD
   1 HTML
   3 LI
   6 LINK
   1 META
   1 TABLE
   2 TD
   1 TITLE
   1 TR
   1 UL

Comme écrit plus haut la sortie de onsgmls ressemble à ça:

% onsgmls index.html 2>&- 
(HTML
(HEAD
AREL CDATA stylesheet
AHREF CDATA style.css
ATYPE CDATA text/css
(LINK
ACONTENT CDATA text/html; charset=iso-8859-1
AHTTP-EQUIV CDATA Content-Type
(META
AREL CDATA Start
AHREF CDATA index.html
ATYPE IMPLIED
(LINK
AREL CDATA Appendix
AHREF CDATA index_types.html
ATYPE IMPLIED
ATITLE CDATA Index of types
(LINK
AREL CDATA Appendix
AHREF CDATA index_values.html
ATYPE IMPLIED
ATITLE CDATA Index of values
(LINK

Je suis certainement le premier à utiliser Unix pour résoudre un problème, mais si je veux extraire la ligne de tags de quelque chose comme

<a
href="http://pasla"
>Un guillemet"<
img
 alt="Un chevron<"
 src="http://ailleurs" /></a>

avec du sed et bien il va falloir par commencer par nettoyer très soigneusement l'entrée.

Sans aller jusqu'à utiliser (explicitement) une bibliothèque adaptée je pense que le passage par un des outils de onsgmls ou bien par tidy est à recommander.

Exemple de output de onsgmls

(HTML
(HEAD
AREL CDATA stylesheet
AHREF CDATA style.css
ATYPE CDATA text/css
(LINK
ACONTENT CDATA text/html; charset=iso-8859-1
AHTTP-EQUIV CDATA Content-Type
(META
AREL CDATA Start
AHREF CDATA index.html
ATYPE IMPLIED
(LINK
AREL CDATA Appendix
AHREF CDATA index_types.html
ATYPE IMPLIED
ATITLE CDATA Index of types
(LINK
AREL CDATA Appendix
AHREF CDATA index_values.html
ATYPE IMPLIED
ATITLE CDATA Index of values
(LINK
AREL CDATA Appendix
AHREF CDATA index_modules.html
ATYPE IMPLIED
ATITLE CDATA Index of modules

Après si il y a une bonne raison de tout faire n'importe comment, c'est chacun comme il veut.

Tu n'es quand-même pas en train de recommander d'analyser du HTML avec des expressions rationnelles? :)

N'importe quoi !

Oui tu as raison d'être plus précis.

Et même dans le contexte du javascript, pourquoi ne pourait-on pas copier les structures qui ont des méthode.

Parceque tu ne peux pas copier (au sens de dupliquer) les fonctions, ou plutôt les closures.

Qu'as-tu donc contre la myriade d'exemples qu'on peut trouver sur le web ? :)

Je n'ai rien contre, je veux juste comprendre à quoi ça sert. Mon parcours de programmeur avant le JavaScript contient plein de choses, et beaucoup de fonctionnel (surtout OCaml et un peu de Scheme). Dans ses langages on a des streams et des catamorphismes (le nom pédant de forEach et reduce et consorts.) et on pourrait utiliser les même mécanismes en JavaScript. Mais on préfère introduire une nouvelle syntaxe pour implémenter ces fonctionnalités et je veux juste comprendre pourquoi. C'est de la curiosité, tout simplement.

(Pour comprendre pourquoi une solution à un problème est intéressante, la meilleure méthode est d'essayer de résoudre soi-même le problème.)

yield n'est pas obligatoire pour faire un Iterable en JS. Ton objet peut être imutable. Tout ceci dépend de ton implementation.

J'ai lu un peu rapidement et fait une confusion entre iterable et générateurs. La question que je pose est à quoi sert yield qui demande une extension syntaxique alors qu'on peut apparemment se passer de générateurs en implémentant des fonctions d'ordre supérieur de type reduce ou forEach. Est-ce qu'il y a des cas qu'on ne peut que traiter avec un générateur?

Je ne vois pas trop bien ce que tu veux dire par programmation pseudo synchrone mais cela n'a certainement rien de spécifique aux générateurs. Si la génération d'un nouvel élément dure longtemps, on peut très bien demander son calcul à une promise qui se chargera d'appeler le callback et de demander la génération du prochain élément au moment voulu.

Je n'ai jamais vu un exemple où les générateurs apportaient quelque chose par rapport à une fonction de type forEach, et apparemment ce n'est pas pour aujourd'hui! :)

Tu as un exemple relativement petit de programmation pseudo-synchorne avec des générateurs et des promises?

Par exemple on peut configurer l'objet a la création pour lui fixer une borne supérieure. Je voulais juste monter comment définir un forEach qui ne fonctionne de façon paresseuse, sans faire trop attention aux autres détails.

Pour donner un exemple concret de définition d'un objet itérable au moyen d'un forEach j'ai défini un objet primes qui énumère les nombres premiers (SpiderMonkey / js) – de la façon la plus naïve possible:

var createPrimes = function(spec, _my) {
    var that = {};
    var my = _my || {};

    my.knownPrimes = [ 2 ];
    my.upperBound = 2;

    var isDivisible = function(n) {
        return my.knownPrimes.some(function(k) {
            return (n % k) === 0;
        });
    };

    var findPrimesUpTo = function(n) {
        for(var i = my.upperBound; i <=n; ++i) {
            if(! isDivisible(i)) {
                my.knownPrimes.push(i);
            }
        }
        my.upperBound = n;
    }

    var isPrime = function(n) {
        findPrimesUpTo(n);
        return my.knownPrimes.some(function(k) {
            return k === n;
        });
    }

    that.forEach = function(callback) {
        var i = 2;
        while(true) {
            if(isPrime(i)) {
                callback(i);
            };
            ++ i
        };
    };

    return that;
};

var primes = createPrimes();
primes.forEach(print);

Cela ne s'arrête jamais, mais si le code utilisant l'énumération en a marre, il peut lancer une exception par exemple. On peut partager le même énumérateur entre plusieurs threads dans node.js par exemple. Qu'est-ce qu'apporte une réécriture avec yield dans cet exemple? Et dans d'autres exemples?

Oui Lwt utilise des monades, ce qui permet de programmer en composant des threads un peu comme on compose des fonctions. Même si on programme un peu à la va-comme-je-te-pousse, cela reste à peu près lisible et maintenable, tandis que les paradigmes basés sur des callbacks comme Node.js requièrent uneplus grande discilpline de programmation.

Pour des implémentations fictives d'un objet représentant un intervalle, qu'est-ce que c'est l'avantage de dire

var sequence = createSequence(1,10);
for(let i of sequence(0 {
  print(i);
}

par rapport à

var sequence = createSequence(1,0);
sequence.forEach(print);

Si le traitement est plus compliqué on peut remplacer le print du deuxième exemple par une fonction anonyme. La deuxième forme est rendue possible par le langage depuis longtemps (toujours?) et je ne vois pas trop l'intérêt d'étendre le langage pour proposer de faire de façon compliquée ce qu'on pouvait faire simplement avant.

En plus l'intérêt de la deuxième forme est qu'on peut implémenter facilement le forEach pour éviter d'avoir un état mutable dans sequence ce qui permet de partager la valeur entre plusieurs threads sans se casser la tête. La forme avec yield n'a pas cet avantage.

La forme avec yield a peut-être des avantages sur le forEach mais ce n'est pas celui que tu dis. Rien n'interdit à un objet de publier des fonctions forEach ou la forme plus générale reduce pour permettre à tout le monde d'itérer sur la propriétés de l'objet de façon standardisée. Ou de générer les éléments à la demande.

Tout ce que tu dis n'est pas spécifique au yield et est déjà rendu possible par les fonctions d'ordre supérieur à la reduce et forEach.

Merci pour cette dépêche!

C'est chouette de voir des fonctions comme les promises ou les modules qui existent depuis longtemps dans des implémentations variées arriver dans le standard. Les proxies et la réflection sont aussi prometteurs de structures abstraites plus faciles à utiliser.

Certains point me convainquent beaucoup moins, comme par exemple la petite surcouche objet puisque le livre de Douglas Crockford *JavaScript, the good parts” répertorie des techniques faciles à utiliser qui permettent de vivre en paix avec le modèle objet plutôt exotique de JavaScript… il ne semblait pas urgent de rendre encore plus compliqué ce qui l'était déjà assez.

Pour l'assignement d'objets, c'est dommage de ne pas avancer plus loin en proposant aussi la copie en profondeur des objets – qui marche au moins pour les PODs – c'est du jargon C++, je veux dire les structures sans méthodes. Je ne vois aussi pas trop l'intérêt des itérables, puisque JavaScript est un langage fonctionnel et que la bibliothèque standard propose des tableaux qui savent faire reduce ou forEach la fonctionnalité des itérables me semble un peu superflue, et demande de comprendre des nouveaux concepts (comment marche le 'yield') alors qu'utiliser reduce ou forEach rentre dans le cadre normal du langage.

Bon et puis même si l'hypothèse que de plus en plus d'utilisateurs utilisent le cloud et voient leur PC comme un cache, est-ce forcément une bonne chose ?

On a déjà une expérience en la matière, puisque c'est le retour aux débuts de l'informatique avec une architecture terminal et unité centrale.

Pour l'instant, le tout-Cloud n'est pas encore une alternative viable.

Il y a une différence entre les technologies cloud et le déploiement en software as a (web) service. En fait ces deux choses n'ont rien à voir et on peut faire remonter le software as a service aux scripts CGI!

Le software as a service introduit:

1. Une fiabilité moindre (il faut mettre Internet dans la chaîne de fiabilité!)
2. Des problèmes de sécurité, peut-on accéder à mes documents sans mon consentement?
3. Des problèmes de confidentialité, ai-je raison de faire une confiance aveugle à l'entreprise qui héberge mon service?
4. Des problèmes de maintenance, est-ce que mon prestataire va faire une maintenance rendant son servie inaccessible à un moment critique pour moi?
5. Des problèmes de pérennité, que se passe-t-il si mon partenaire disparaît? Vais-je récupérer mes données? Vais-je pouvoir les utiliser?

Et encore je ne mets même pas les questions power user de type comment intégrer le service dans du traitement par lot.

À cause de tout ces points, le software as a service est complètement impensable pour toutes les professions qui ont des hauts degrés de confidentialité, voire même rendu pratiquement impossible par les régulations!

Le gros bénéfice de software as a service est en réalité pour les développeurs qui au lieu de travailler avec Unix et Windows se retrouvent dans un environnement relativement standardisé, le navigateur – j'imagine que les différences de compatibilité ne sont aujourd'hui pas pires que celles des différents Unix!

Il est très rare (de mon expérience toujours) d'avoir des cas d'état partagé ou de processus (léger ou pas) qui doivent réellement coopérer.

C'est également mon expérience. Je programme beaucoup en OCaml qui a une bibliothèque très puissante Lwt pour faire de la programmation concurrente. Comme OCaml est un langage fonctionnel, on est en tant que programmeur assez disposé à utiliser des valeurs contantes et des fonctions récursives pour décrire les traitements. Le fait que les valeurs soient constantes réduit énormément les besoin en mutexes. La bibliothèque Lwt propose des threads collaboratifs – plutôt que le traditionnel modèle préemptif – l'ordonnanceur ne peut changer de thread que lorsque le thread en cours d'exécution atteint un point de collaboration. Cette stratégie réduit d'autant les besoins en mutexes. Par une astuce élégante, le type des fonctions indique clairement si elles contiennent un point de collaboration ou pas, ce qui rend la bibliothèque très facile et agréable à utiliser.

Le revers de la médaille est que OCaml ne supporte en principe pas le parallélisme, mais on peut cependant faire fonctionner Lwt comme Node.JS où un thread (de type OS) exécute le programme OCaml ou Javascript tandis qu'un second s'occupe des appels systèmes.

Ce que j'apprécie avec ce genre de démarche c'est qu'elle limitent le nombre de processus créer ce qui permet d'éviter de perdre du temps dans des ordonnanceurs.

Ça évite aussi de se prendre les pieds dans un drapeau Suisse! :)

Quitte à essayer de construire une bibliothèque qui le fait bien, autant coder directement en Haskell

On n'est pas vendredi, mais remplacer du caml par du haskell ;)

Ce que je veux dire c'est que votre familiarité avec un langage fait croire que ce langage est clair, mais qu'en fait ce n'est le cas que pour ceux qui sont familiarisés avec ses idiomes.

Voilà un exemple de programme pas très clair: je veux afficher Hello, world! et je dois écrire:

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char **argv)
{
    printf("Hello, world!\n");
    return EXIT_SUCCESS;
}

Par rapport à mon but il y a plein de bruit que je ne comprends pas. Je vois bien que le biscuit c'est le printf(…) mais quel est le rapport entre mon but et le main et les #include, argc, argv ? Ce n'est pas clair parceque beaucoup d'éléments sont sans lien apparent avec mon but. Quand tu lis

main :: IO ()
main = (take 10 <$> 
        sort <$> 
        map toFloat <$> 
        filter (\s -> length s > 0 && (s !! 0) /= '#') <$> 
        cat "fichier") >>= output 

on retrouve un peu de bruit main et output mais la plupart des éléments peuvent facilement être rattachés à la description de la tâche. Comme dans ton exemple

chain(cat(),
      filter(lambda s: s and s[0] != '#'),
      map(float),
      sort(),
      head(n=10),
      output())

Il y a un petit peu de bruit, le chain mais les autres éléments sont facilement rattachables à la description de la tâche à effectuer.