Michaël a écrit 2935 commentaires

Est-ce que l'on peut mettre plusieurs name server sur le même port sachant que les services sont différents ?

Oui bien sûr. Ce qui est peut-être un peu déroutant quand on vient de apache est que ce dernier fait bien la différence entre la configuration du socket bind et des virtual hosts mais la configuration de nginx se lit différemment et il n'y a pas de problème à avoir plusieurs règles qui écoutent sur le même port. (J'imagine que c'est ce qui peut te paraître louche.)

• Journal bookmark: you're doing it wrong
• 10 choses que les gens successful font avant de poster un journal Bookmark
• etc. :)

C'est moi ou le COBOL ressemble fortement à une très fine surcouche au dessus de l'assembleur?

Oui c'est ça, tout le monde qui sait quelque chose peut mettre à jour l'information affichée sur le awayboard. C'est un système très simplet. :)

Concrètement on utilise le bouton “add person” pour ajouter une étiquette puis on peut déplacer les étiquettes en triant-glissant le nom.

Ah sinon, je rajouterai juste que dès l'instant ou la boite dépasse les 100 salariés, ça deviendra juste ingérable :)

C'est pour les équipes, donc plutôt de 3 à 10 personnes. On a pour chaque équipe un écran assez grand qui cycle entre plusieurs pages de type “moniteur”qui donnent l'état du serveur, et il y a maintenant une page supplémentaire qui afficher le awayboard. Au départ c'était un tableau magnétique mais comme on a toutes les deux semaines un “hackday” dédié aux projets d'initiative personnelle, Sascha en a profité pour coder ça.

Salut! J'aimerais bien intégrer ton code dans le repository de la Fédération TapTempo mais je ne suis pas sûr de quelle license utiliser. Si tu es d'accord, quelle license libre te conviendrait? Et quelle notice de copyright?

Oui bien-sür, je te propose d'ouvrir un ticket pour demander à être inscrit comme ça j'aurais to handle :)

Et encore, il n'a pas mis le plugin maven qui permet de définir le nombre de secondes par minutes dans un fichier XML dont la DTD est téléchargée à la volée.

Quand j'étais au MPIM à Bonn en post-doc il y avait Faltings qui passait ses journées à lire le journal à la bibliothèque: dans un cas comme dans l'autre c'est quand-même pas super évident de résoudre des problèmes si difficiles très souvent. :)

Sous FreeBSD c'est pareil. Sauf qu'en plus on peut les regarder sans savoir grand chose ;) https://svnweb.freebsd.org/ports/head/www/firefox/files/

Dans un premier temps, j’ai utiliser un nouveau système de build (jbuilder) que je ne maîtrise pas. Je suis revenu aux bons vieux Makefile pour gérer l’internationalisation.

Si tu travailles encore avec des Makefile, tu peux essayer ceux-cis: BSD Owl. (Attention, c'est pour bmake. Il y a même un paquet Debia pour une vieille version. ⁾

Les sticky Tag c'est ce mécanisme qui fait que si tu tapes de l'italique après de l'italique, ce que tu ajoutes est aussi en italiques. Dans certain cas ça marche pas top.

Si tu veux trouver des comportements étranges, il faut juste se servir un peu d'éditeurs qui font ça (Word, GMail, Jira, Confluence) par exemple. Pour des comportements très étranges il suffit de passer au copier-coller. Par exemple avec Jira, j'obtiens trois formatages différents selon l'ordre dans lequel j'insère mes logs dans le ticket (détail amusant, aucune version n'est la bonne) (Du genre, coller puis formater ne rend pas pareil que formater puis coller.) Sinon prend une liste d'une page web et colle la dans Gmail. etc. En fait je vais commencer une chaîne Youtube je crois.

Exemple tout bête : il y a peu, j'ai essayé de mettre un cadre autour d'une zone de texte composée de paragraphes et de liste numérotées : impossible : cet imbécile s'est obstiné à mettre un cadre différent autour de chaque paragraphe.

En même temps, est-ce que tu connais un seul éditeur de texte “riche” qui utilise les “sticky tags” (le style du dernier mot colle à la suite) et n'est pas cassé au point que c'est triste à pleurer? J'ai un challenge ouvert à ce sujet au boulot ;)

Interface vieillotte, possibilité graphique faible, raccourcis clavier exotique, le lisp plus trop à la mode, portable windows moyen.

Franchement entre Emacs et les produits IntelliJI ou Visual Studio (ok j'avoue VS2010 mais il paraît que de puis c'est devenu bien) et bien franchement je trouve ces machins tout sauf agréable à utiliser – à part le débogueur visuel mais je préfère les langages où on a n'a pas trop besoin de faire du débogage visuel en pas à pas. ;)

C'est peut-être une observation un peu étrange mais j'ai du mal à faire abstraction de toutes ces annotations et pop-up, et, je pèse mes mots, ça me pète grave les couilles de voir un feu d'artifice de couleurs et de fenêtres popup d'auto-complétion et de changement d'états dès que j'ajoute un mot à une liste… L'approche de l'écosystème Emacs est plutôt plus seine – l'info complémentaire est en général affiché dans la petite barre au pied de l'écran et l'analyse de syntaxe est faite à la sauvegarde (merlin pour OCaml) ou à l'évaluation (slime pour Lisp).

Ceci-dit je ne perds pas espoir: depuis quelques années on a fait beaucoup de progrès dans l'UX et beaucoup d'interfaces se sont simplifiées et proposent des choses simples pour des tâches simples au lieu de submerger l'utilisateur d'un dégueulis d'informations et de questions importunes… peut-être que d'ici quelques années on aura aussi des IDEs ergonomiques (à part Emacs ;) ).

Sinon pour le “lisp pas trop à la mode” je pense que le rapport expérience/salaire des développeurs clojure mentionné dans le même rapport pourrait faire figure d'incitation ;)

Ca amuse qui de rebricoler un .emacs à chaque upgrade ?

Je pense que c'est un peu éxagéré!

Ce que me semble refléter ce chiffre est que beaucoup de développeurs sont soit JavaScript, PHP, Java, C ou C++ et que pour l'un quelconque de ces langages il y a des environnements très sophistiqués. Pour moi qui édite en sus des précédents du Lisp, OCaml, Shell, TeX, ansible, du markdown, et du task-juggler, j'ai quand même intérêt à utiliser Emacs – qui sait éditer les fichiers dans un container docker sur une machine distante, et ça aussi c'est pas forcément cochon.

En vrac :
- Complétion de code qui a du sens et qui est pertinente, out of the box ™
- Coloration syntaxique de plusieurs langages (Python, C, C++, C#, …) qui est juste lisible, out of the box ™
- Tout intégré (éditeur, compilateur, signalement des erreurs, débogueur, gestionnaire de paquets NuGet, gestionnaire de versions, gestion des tests, …). Plus besoin de changer de contexte/outil/logique tout le temps. Plus de perte de temps.

Pour ma gouverne c'est à partir de quelle version que Visual Studio est devenu bien? Ma dernière expérience avec le produit de 2012 et je suis sûr que tu parles d'autre chose. :)

Si je comprends bien, la première fonction correspond à Mettre sous forme de tableau dans Excel.

Non ce n'est pas du tout ça. Ce que je veux c'est pouvoir lire ces définitions sans passer mon temps à cliquer sur la boiboîte pour y mettre le focus puis déclencher l'action qui me montre ce que je veux voir. Même un truc aussi basique que ce que je décris dans cet autre commentaire 1729925 me suffirait. Juste une pile de texte qui me permet de vérifier ce que fait ma table.

En l'état actuel des choses, une feuille de calcul et en gros un programme mais qui fait de son mieux pour qu'on ne puisse pas le lire. Résultat: dès qu'on fait quelque chose de vaguement compliqué et qu'on se rend compte qu'il faudrait ajouter un résultat intermédiaire etc. tout part en cacahouète.

Pour bien faire il aurait fallu mettre une image docker. ;)

X

Un des gros inconvénients du modèle de Nodejs est d'avoir un seul fil d'exécution en collaboratif. Cela veut dire que si ce fil d'exécution est bloqué pendant 100ms pour calculer le hash d'un mot de passe avec une fonction moderne de hashage comme scrypt, il n'y a aucune autre requête HTTP qui va être traitée pendant ce temps et la latence va augmenter de 100ms pour toutes les requêtes de ce processus.

Ce serait effectivement une manière assez plus maladroite de faire! ;) Dans ce paradigme on n'attend que les “threads” collaborent entre eux: de temps en temps il faut donc rendre la main à la boucle. Plutôt qu'un long discours, un petit exemple:

function fiboLoop(n, k, a1, a2, callback) {
    var collaborate_p = (k % 20 === 0);

    if(n == k) {
        callback(a2);
    } else {
        if(collaborate_p) {
            setTimeout(() => {
                fiboLoop(n, k + 1,  a2, combine(a1, a2), callback);
            }, 1);
        } else {
            fiboLoop(n, k + 1,  a2, combine(a1, a2), callback);
        }
    }
}

(À tout hasard je précise que je suis loin d'être un spécialiste ou un amoureux de JavaScript, moi mon truc c'est plutôt OCaml, Lisp, SH et TeX. Donc mon code est très certainement assez médiocre. ;) )

Ma fonction combine déduit un hash des valeurs de a1 et a2, et j'utilise un “schéma de Fibonacci” pour faire une boucle, qui toutes les 20 itérations repasse la main à l'ordonnanceur pour collaborer un peu avec ses petits copains: il suffit de se retenir de faire le calcul et de demander à la boucle de continuer quand bon lui semble.

Voici un code complet qui met ça dans un serveur HTTP

const http = require('http');
const process = require('process');
const crypto = require('crypto');
const url = require('url');

const server_port = 8080;
const server_iterations = 400000;

const fibo_initialize_a1 = "I don't like secrets.";
const fibo_initialize_a2 = "God is my co-pilot.";

function combine(a1, a2) {
    return crypto.createHmac('sha256', a1)
        .update(a2)
        .digest('hex');
}

function fiboLoop(n, k, a1, a2, callback) {
    var collaborate_p = (k % 20 === 0);

    if(n == k) {
        callback(a2);
    } else {
        if(collaborate_p) {
            setTimeout(() => {
                fiboLoop(n, k + 1,  a2, combine(a1, a2), callback);
            }, 1);
        } else {
            fiboLoop(n, k + 1,  a2, combine(a1, a2), callback);
        }
    }
}

function fibo(n, callback) {
    fiboLoop(n, 0, fibo_initialize_a1, fibo_initialize_a2, callback);
}

function safeParseInt(text, _defaultValue) {
    var parsedInt = parseInt(text);
    var defaultValue = _defaultValue || 0;
    return isNaN(parsedInt) ? defaultValue : parsedInt;
};

http.createServer(function (req, res) {

    var parts = url.parse(req.url, true);
    var query = parts.query;
    var iterations =
        ('n' in query)
        ? safeParseInt(query['n'])
        : server_iterations;

    console.log('Receive fibo ' + iterations);

    fibo(iterations, (ax) => {
        res.writeHead(200, {'Content-Type': 'text/plain'});
        res.write('Hello World! ' + ax);
        res.end();
        console.log('Done fibo ' + iterations);
    });
}).listen(server_port);

On peut tester avec quelques commandes (while true; do curl 'localhost:8080?n=10'; done) (while true; do curl 'localhost:8080?n=100'; done) et (while true; do curl 'localhost:8080?n=10000'; done) qui tournent dans des terminaux.

On a également la distinction entre les threads dédiées aux appels système et les autre threads dédiés aux traitements. Le nombre de threads dédiés aux traitements est la variable d'ajustement pour la montée en puissance, il est limité par la variable d'environnement GOMAXPROCS.

C'est sympa cette distinction. En pratique ça se passe comment? Il faut annoter ses routines ou bien le compilateur s'en sort tout seul? Aussi c'est un peu bizarre de penser qu'une fonction change de catégorie si on la “pepper-printf” pour déboguer.

alors que pour Nodejs, ça demande souvent encore un peu de boulot de passer d'un seul à plusieurs processus : écrire le petit bout de code pour cluster, faire attention aux variables globales qui ne le sont plus (cache, pools de connexions à la base de données), etc.

Si on cherche à faire facilement du redimensionnement de capacité, la bonne stratégie dépend du contexte. Si par exemple on travaille avec des ressources de calcul élastiques avec des instances de 2-4 cœurs qu'on ajuste à la capacité demandée on peut se passer complètement de la couche cluster et compter sur un reverse-proxy type haproxy ou bien par exemple le répartiteur de charge de docker ou bien le consul de hashicorp par exemple – ou tout autre composant qui va répartir le flux sur plusieurs processus qui tournent sur des serveurs différents. Et même si on a une machine grassouillette avec 192 cœurs dont on veut tirer parti, ce n'est pas forcément aberrant de procéder de la sorte aussi.

Je m'en suis très librement inspiré inspiré pour coder le PPX de Lemonade (the sparkling monad library). ;)

Non c'est justement ce qui est garanti de ne jamais arriver: en NodeJs par exemple il n'y a à tout moment qu'au plus un fil d'exécution qui execute du JavaScript.

Juste parce que t’as un seul thread ne veut pas dire que tes parties critiques ne vont pas s’executer “entrelacées”. Si t’avais besoin de mutex avant, t’as toujours besoin de mutexes après.

C'est vrai, mais ce que j'ai oublié d'ajouter est qu'on a affaire à un modèle de programmation collaboratif et non préemptif – ce qui signifie que je suis sûr que personne ne touche à ma variable en même temps que je la manipule. Et comme les mutexes sont là pour rendre atomiques du point de vue de l'ordonnanceur des opérations qui en réalité ne le sont pas on n'en a plus besoin.

Non pas vraiment. Il s'agit ici d'avoir une granularité assez fine pour faire un switch non pas sur les threads (ce qui est plutôt lourd), mais au sein d'un même thread.

Oui, le modèle de gestion du multitâche popularisé par NodeJS a plusieurs intérêts. Le premier c'est qu'en gros il fournit un cadre assez simple de programmation multi-thread en proposant de prendre en charge complètement un thread dédié aux appels systèmes et un autre qui s'occupe de traiter les évènements correspondant à ces appels. Comme programmeur, je sais qu'a tout moment je n'ai qu'un fil d'éxécution et donc je peux laisser tomber les mutexes, j'ai des programmes moins difficiles à déboguer que le “multi-thread” total. Le second effet, qui n'est pas négligeable, est que si j'ai besoin d'ajuster la capacité de mon application, je n'ai qu'un seule variable à considérer: le nombre de processus que je veux faire tourner sur une machine. Dans le monde “complètement multi thread” j'ai un espace beaucoup compliqué à explorer: pour mon serveur apache, est-ce qu'il faut mieux 16 processus avec chacun 2 thread, 8 processus avec chacun 4 threads, etc.? Quelle stratégie utiliser pour allouer les threads dans mon application? Avoir un modèle simple pour décrire la capacité de son application est appréciable – quitte à potentiellement sacrifier un peu en efficacité en acceptant de ne pas explorer certaines formes d'organisation.

Heu, hum, Microsoft Word a un mode Plan.

La dernière fois (probablement vers 1999 :D) que j'ai regardé le mode plan de MS fait ressortir le chapitrage du document alors que ce que je vais c'est voir rapidement et facilement (sans détruire mon formatage) si tous les éléments du texte sont en accord avec ce que prescrit mon graphiste. Des prescription du style:

– toutes les références au catalogue de la société doivent être en caractères blabla, taille machin, dans tel contexte
– tous les noms propres de personne, comme ci,
– tous les items des menus de l'application sont présentés comme ça,
– tous les termes du manuel de référence du logiciel qui font l'objet d'une section dédiée sont visuellement identifiés comme tel dans le manuel de l'utilisateur
– etc;

Et oui il y a des gens qui font ça avec Word et peut-être d'autres WYSIWYG, et autant que je sache il n'y a pas de vrai support pour faciliter ce type de relecture.