Michaël a écrit 2929 commentaires

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.

Effectivement je me suis un peu emmêlé les pinceaux, l‘habitude du OCaml et de la composition »contravariante«. Mais effectivement l‘important est que l‘ordre du texte corresponde à celui du traitement.

Les langages avec des vraies macros , comme Collin Lisp que je cite permettent de tout programmer de façon assez agréable. Par exemple avec cl-async, on peut presque réutiliser son code synchrone avec des promises, il suffit presque de changer les let en alet;)

Tu penses (probablement) à une monade spécifique qui fait de la composition de fonctions

Pour être très précis je pense en l‘espèce à la monade utilisée dans Lwt (OCaml) Comme le dit kantien, c‘est la monade qui enferme chaque valeur dans thread (pas nécessairement un Thread système) calculant cette valeur. La monade définit de plus une finction spéciale qui me permet de passer la valeur à l‘ordonnanceur.

En fait, le code que tu montres, on dirait du code en CPS…

C‘en est non? Peut-être pas de façon parfaite »selon la définition du livre« mais on pourrait le déformer légèrement pour qu‘il s‘y plie.

Le premier point que je voudrais ajouter, c'est que NodeJS utilise libuv qui a été développé pour et est utilisée pour plein d'autres langages. En plus de langages relativement classiques on la trouve pour OCaml et Lisp ou la version de haut niveau par exemple.

Le gros problème de l'approche de NodeJS est qu'elle propose une approche de la programmation événementielle basée sur des callbacks et qu'on finit invariablement par avoir du code spaghetti assez indigeste, pas super facile à maintenir – et pas non plus super facile à mettre au point. Un des gros problèmes de la programmation par callbacks est qu'elle inverse l'ordre de composition des fonctions. Au lieu d'écrire Applique f au résultat de g on écrit Fait g puis donne son résultat à f ce qui lorsqu'on empile les appels de fonctions anonymes pour produire la pyramide du destin où le code se déplace plus rapidement vers la droite que vers la complétion de sa tâche. ;)

// La pyramide du destin (merci à kriskoval)
step1(function (value1) {
    step2(value1, function(value2) {
        step3(value2, function(value3) {
            step4(value3, function(value4) {
                // Do something with value4
            });
        });
    });
});

En pratique le step1 est toujours un truc un peu banal du type “print” ou “exit” et le biscuit (les variables intéressantes et les appels de fonction intéressants) sont enterrés dans les niveaux inférieurs – même avec de l'habitude c'est assez malheureux et on a du mal à suivre le code ni à retrouver les parties intéressantes.

Pour retomber sur ses pattes il y a la programmation par monades qui permet de recomposer les traitements “dans le bon sens” – que l'on retrouve sous plusieurs formes de façon parfois un peu cachée comme les promises.

Ezgactement! :)

Je procéderais de la façon suivante :[…]

Oui moi aussi, le problème c'est que ce genre de bricolage ça va bien sur un petit document, mais le “tout casser pour tout bien remettre comme avant” en général, ça ne marche pas top et si on a une exigence professionnelle sur le résultat, et bien on n'a pas vraiment de soutien de la part du logiciel.

2/ chercher dans le document tous les mots ayant l'attribut gras. Si tu en trouves c'est que le style nom_de_commande a mal été appliqué.

Le style nom de commande … ou un autre ;)

C'est du bricolage, mais je ne suis pas sûr qu'on puisse définir aisément une procédure pour détecter les mélanges de formatage direct et d'application de styles.

Ben déjà de basculer sur un mode de type “mise en page basique” qui identifie les styles utilisés par soit une couleur de papier (avec une combinaison multiplicative par exemple) soit par des petits tags comme dans les éditeurs HTML rétro du début des années 2000 ça ferait avancer le schmilblick. Un problème de la modification manuelle des styles est que c'est compliqué (donc on fait des erreurs) et potentiellement assez long (donc il faut sauvegarder mais on n'a pas trop envie de sauvegarder son document avec des caractères rouge de taille 48pt) et que au moins pour ces deux raisons cela vaudrait le coup d'avoir un support logiciel.

Même si ça existait, je ne comprends pas la logique de ta phrase. Est-ce que tu peux expliciter ?

Si j'ai un style “nom de commande” qui correspond à des caractères gras et bien je n'ai pas de moyen simple de faire la différence entre le style sémantique “nom de commande” et le banal “gras” – ce qui fait que sur un document un peu long il n'y a en pratique aucun moyen de vérifier que des règles de style un tant soit peu précises soient suivies correctement.