Michaël a écrit 2935 commentaires

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.

En ce qui concerne le formatage direct, tant que les traitements de texte n'auront pas un “mode plan” qui permettrait de contrôler facilement que les styles qui n'ont pas de nom ne sont pas utilisés dans le document, autant privilégier ce qui marche – à savoir le formatage direct.

Mode plan: du genre je vois mon document avec deux énormes marges où apparaissent les noms des styles utilisées et les paragraphes concernés apparaissent sur fond coloré p.ex. Avec un visuel un peu comme ça

ou comme ça

sauf qu'au lieu d'avoir des fragments de code dans le panneau qui n'affiche pas le document, on aurait des informations sur le style.

(Mode plan: le genre de fonctionnalité qui a l'air claire et sympa comme ça sur un coin de table mais qui est hyper galère à spécifier en vrai ;) )

Je trouve chiante et instable la façon de gérer les extensions emacs : cela a peut être changer mais pour moi, on est loin de npm/ go get /urpmi il s'agit toujours d'aller chercher une version à la main et modifier le fichier de config.

Instable je ne sais pas parceque je n'utilise quasiment que des extensions qui sont fournies par mon système de ports ou installable directement depuis Emacs. Après effectivement il faut souvent copier-coller quelques lignes dans son fichier dot.emacs. Comme on fichier `dot.emacs' est sous SCM je peux te donner le log des dernières années:

2017-12-03 11:43:32 +0100 Allow long lines in Lisp
2017-11-25 10:13:17 +0100 Add simplified window and frame navigation
2017-11-02 16:56:33 +0100 Fix emacs configuration
2017-11-02 08:07:47 +0100 Update for new system
2017-09-25 14:46:37 +0200 Configure slime as in portacle
2017-09-13 10:09:05 +0200 Install slime
2017-06-06 15:16:11 +0200 Update emacs settings
2016-12-12 10:34:45 +0100 Update merlin configuration
2015-08-28 15:29:12 +0200 Update style
2015-08-28 15:15:38 +0200 Record company PHP Style
2015-06-02 09:21:04 +0200 Configure merlin and ocp-indent
2015-06-02 08:47:35 +0200 Remove broken hunspell support
2015-03-24 14:45:36 +0100 Add PHP mode
2015-02-03 09:48:02 +0100 Change the font size on Darwin
2014-03-03 10:37:44 +0100 Remove CEDET
2014-03-03 10:34:05 +0100 Disable the tool-bar and the scroll-bar
2014-03-03 10:23:38 +0100 Add trac-wiki
2014-03-03 10:22:00 +0100 Add Markdown mode
2013-08-18 08:36:18 +0200 Update key shortcuts
2013-08-18 08:32:55 +0200 Correct the name of ocamldebug
2013-08-04 16:20:14 +0200 Whitespace mode
2013-08-04 16:03:04 +0200 Rework dot.emacs
2013-07-20 19:07:20 +0200 Add slime

(Généré avec git log --pretty='format:%ci %s').

Pour quelqu'un qui travaille vraiment beaucoup avec Emacs, je ne l'ai jamais utilisé moins de 20h par semaine dans l'historique que tu vois, et qui se sait se satisfaire des réglages par défaut sans trop faire de customisation, je trouve que s'il s'agit d'un effort à faire, ce n'est pas non plus disproportionné.

Et une fois, le truc installé, il faut deviner tout seul comment le module marche. Il me semble que tuareg est fournis de base maintenant, mais il ne semble pas que tu peux "jumper" d'un fichier à l'autre pour trouver définition de code et usage de code.

La navigation de fichier à fichier peut effectivement laisser à désirer dans le réglage de base par rapport au confort de PHP Storm (sauter à l'implémentation etc.) mais cela dépend des modes. Par exemple Slime (pour CL) sait le faire, mais je crois que pour OCaml cela n'existe pas. (Pour C et le reste, je crois que l'outil magique est CEDET.)

tu n'as pas auto-complétion sémantique ou de library (à moins d'ouvrir tout dans un buffer…) […], ou de vérification de la syntaxe en ligne.

En ce qui concerne OCaml, merlin apporte tout cela: la syntaxe est testée à la sauvegarde et l'auto-complétion marche (en tout cas pas plus mal que dans les IDE que j'ai utilisé). Pour Lisp, slime fait assez bien cela – sauf la vérification de syntaxe mais en pratique on programme interactivement c'est à dire qu'on fait des va-et-viens constants entre le programme et la REPL et il y a un petit raccourci qui évalue la défintion en cours (C-M-x) ce qui rapporte les erreurs. L'approche des IDE de type Visual Studio ou PHP Storm donne plus d'information interactives, mais d'une c'est assez lent et de deux je n'ai jamais réussi à m'habituer à tous ces coloriages (genre rouge faute de syntaxe, violet pour une infraction à la coding guideline XY, orange pour ceci-cela) et les petits tooltips qui vont avec sont assez pénibles – je préfère l'approche de merlin par exemple qui met à jour cette information à la sauvegarde, c'est à dire à un moment que je choisis.

tu n'as pas […] de refactoring […]

Ça oui!

Pour programmer en

• OCaml que tu cites, aver tuareg, merlin et ocp-*
• Shell, à cause de l'évaluation interactive.
• Lisp avec Slime, à cause de tout.

Pour avoir utilisé longtemps deux IDEs – Visual Studio et PHP Storm de Jet Brains – et bien je les trouve assez désagréable à utiliser. Pour l'un comme pour l'autre l'analyse de code et la complétion sont d'une lenteur quasi-prohibitive sur des grosses bases de code, voire carrément inutilisables. La configuration est assez difficile pour tout ce qui est exotique et la documentation pas franchement merveilleuse. (Je n'utilise plus, donc je n'ai plus d'exemples en tête, mais ça m'est quand-même arrivé plusieurs fois de vouloir ajouter des traitements à l'IDE ou lui demander de lancer une commande avant de commencer une session de débogage, par exemple.) Ensuite je suppose que c'est une affaire d'habitude mais les interface touffues avec des boutons partouts et des fenêtres coulissantes avec tout et n'importe quoi dedans, et bien ça me distrait énormément et je préfère largement travailler avec un éditeur qui montre du code et plus d'informations quand je lui demande plutôt que le contraire. Même en fouillant dans mes souvenirs je crois bien que je n'ai jamais eu le sentiment que les fonctions dans ces IDEs soient très faciles à trouver… bref quand je feux faire quelque chose qui sort de ma routine que ce soit avec Emacs ou un IDE il faut que tapote dans mon moteur de recherche préféré. (Et si on n'arrive pas à retrouver certaines fonctions dans la doc, que ce soit avec Emacs ou un IDE, et bien ce n'est pas interdit de prendre des notes ;) )

P.S.: En ce qui concerne le reformatage de code ou les divers refactoring, dans mon Visual Studio pour C++ et bien ça n'y était pas et dans PHP-Storm même le renommage de méthode ou de variable membre se prend les pieds dans le tapis de temps à autres.

Dans une table en général il y a d'une part le “gros” des données, au dessus et à gauche des annotations de type légende et en bas de colonne parfois des agrégats (somme, moyenne, écart-type, quartiles, ou quoiqu'on veuille y mettre). Pour moi j'aimerais bien pouvoir penser à ma ma table comme:

table {
  header {
    a1 = "TITRE DE MON TABLEAU"
    a2 = 2015
    b2 = 2016
    c2 = 2017
    d2 = 2018
  }
  data {
    a1 = …
    a2 = …
  }
  foot {
    a1 = average(../data/a:)
    a2 = standard_deviation(../data/a:)
    b1 = average(../data/a:)
    b2 = standard_deviation(../data/a:)
  }
}

L'intérêt est que ça évite de devoir changer les références dans les cellules aussi souvent que dans les modèles classiques. Dans la plupart des tableurs, si on insère une ligne au dessus de sa ligne avec la moyenne, le tableur change les définitions. En plus d'être plus propre, plus facile à vérifier dans une présentation de type “preuve”, ça permet aussi de facilement représenter les imports externes (genre data = sqlite(file.db) ou data = csv(file.csv)). Je trouve ça assez idiot qu'un logiciel ajoute une sémantique à une donnée (le pied de page) sans rendre cette donnée “représentable”.

Il y a deux fonctions qui manquent dans beaucoup de tableurs. La première est assez basique et consiste à travailler, au lieu d'une grosse feuille avec des cellules, de petites tables en indexant de façon spéciale les lignes pied-de-table et haut-de-table. La seconde est “un mode contrôle” qui permettrait de voir simultanément toutes les définitions d'une feuille ou d'une table. Est-ce que tu as écrit ça?

C'est en général une assez mauvaise idée d'utiliser des expressions rationnelle pour fouiller dans une page HTML.

Ici la page est assez simple tu peux afficher la première IP trouvée sur chaque ligne avec

awk 'match($0,/[0-9]+[.][0-9]+[.][0-9]+[.][0-9]+/{print(substr($0,RSTART,RLENGTH))

En général pour traiter du HTML ou plus généralement du SGML, on utilise OpenSP et plus précisément le programme onsgmls. Par exemple

% curl https://monip.org | onsgmls 2>&-
(HTML
-\n
(HEAD
-    
(TITLE
-MonIP.org v1.0
)TITLE
-\n    
AHTTP-EQUIV CDATA Content-type
ACONTENT CDATA text/html; charset=UTF-8
(META
)META
)HEAD
-\n
AALIGN CDATA center
(P
ASIZE CDATA 8
(FONT
(BR
-IP : 89.0.149.201
(BR
)BR
)BR
)FONT
ASIZE CDATA 3
(FONT
(I
-xdsl-89-0-149-201.netcologne.de
)I
(BR
)BR
)FONT
ASIZE CDATA 1
(FONT
(BR
(BR
-Pas de proxy détecté - No Proxy detected
)BR
)BR
)FONT
)P
)HTML

Sous cette forme canonique il est facile d'extraire l'IP recherchée, par exemple avec awk:

awk -F ' *: *' '$1 == "-IP" {print($2)}'

Ceci dit, si c'est un serveur que tu contrôles, tu pourrais lui apprendre à répondre avec du texte ou du JSON à la demande. Par exemple

% curl -H 'Accept: application/json' https://monip.org
{'ip':'89.0.149.201','dns':'xdsl-89-0-149-201.netcologne.de','proxy':false}

Te fournirait un moyen bien plus fiable de récupérer une IP.

Je ne suis pas d'accord : si seule l'existence d'une preuve primait, personne ne chercherait à re-prouver un résultat déjà établi.

Je ne vois pas trop en quoi tu exprimes un désaccord avec arnaudus.

Ça doit faire 25 ans aussi que personne ne dit “djeun's” et je te taquinais aimablement ;)

aaah okay okay okay (copyright Papin)

Ça fait djeun's. ;)

En anglais to hop signifie sautiller, par exemple à cloche-pied. Dans le slang de l'informatique on donne au substantif dérivé a hop le sens de petit bond, mais de façon abusive on peut aussi désigner ainsi la destination intermédiaire.

Tu as plusieurs approches possibles. Tout d'abord notons CLIENT et PERSO tes dépôts (copies de travail) git, ce qui nous servira à décrire les workflows. Pour évaluer les différentes solutions il faut que tu regardes ce qui est techniquement et commercialement faisable.

La raison qui fait que c'est possible techniquement est que git est décentralisé et un dépôt donné n'a aucun rôle techniques spécifique par rapport à un autre – le clone produit par git clone est en principe total – et git fournit plein d'outils pour échanger les données entre les divers clones d'un même dépôt.

1. INSTALLER UN HOP SUR TON INTRANET

Comme tu mentionnes que tu peux accéder pour quelques minutes à ton propre depuis chez ton client, ce serait facile de créer un serveur sur ton propre intranet qui tourne toujours et héberge un dépôt HOP, accessible via SSH-GIT, HTTPS-GIT, ou bien par NFS par exemple. Ainsi ton workflow ressemblerait à:

• Arrivée site client
• Hack
• Pousse de CLIENT vers HOP avant de rentrer à la maison
• À la maison, tire de HOP sur PERSO
• Hack
• Avant de partir chez le client pousse de PERSO sur HOP
• Arrivée sur le site client, tire de HOP sur CLIENT
• Hack
• Pousse de CLIENT vers HOP avant de rentrer à la maison
• …

2. INSTALLER UN HOP AILLEURS SUR INTERNET

Tu peux aussi considérer un hébergement de dépôt git payant, cela coûte une poignée d'euros par mois. Tu y créerais un dépôt HOP, que tu utiliserais comme précédemment. Variante avec une box complète, prix analogue.

3. UTILISER UN HOP SUR UNE CLEF USB

Si tes postes de travail peuvent accéder aux mêmes systèmes de fichiers (par exemple ce sont deux Linux) tu peux utiliser un support amovible pour stocker ton dépôt HOP (par exemple un bare repo). Il faudrait certainement crypter ce support pour se prémunir contre sa perte.

4. UTILISER GIT-BUNDLE PAR E-MAIL

La sous-commande git bundle permet de sauvegarder une partie d'un dépôt git dans une archive fichier, dite “bundle”, qui peut ensuite être importé dans un autre dépôt. Le “bundle” peut être acheminé via une clef USB ou en P.j. sur un email.

% man git-bundle
…
       Some workflows require that one or more branches of development on one
       machine be replicated on another machine, but the two machines cannot
       be directly connected, and therefore the interactive Git protocols
       (git, ssh, http) cannot be used. This command provides support for git
       fetch and git pull to operate by packaging objects and references in an
       archive at the originating machine, then importing those into another
       repository using git fetch and git pull after moving the archive by
       some means (e.g., by sneakernet). As no direct connection between the
       repositories exists, the user must specify a basis for the bundle that
       is held by the destination repository: the bundle assumes that all
       objects in the basis are already in the destination repository.

Cela correspond assez exactement à ton besoin. Je l'ai utilisé pendant longtemps en mode “sneakernet,” c'est un peu relou mais si tu dois jongler entre les intranets cela reste sûrement plus simple que les push/pull à travers le réseau.

En gros c'est le même workflow qu'avec le HOP mais au lieu de cela à la fin de ta session de travail, tu fais und bundle avec tous tes derniers commits et l'apporte ou l'email à ton autre station pour pouvoir l'importer.

5. GIT-IMAP

Jette un œil à la man-page git-imap-send – je n'ai jamais utilisé cette fonction mais cela semble pouvoir répondre à ton besoin.

6. MON AVIS

Admettant que ton client soit d'accord avec ces manips, je pense que les solutions les plus simples sont, par ordre croissante de complexité à l'usage.

1. Installer un HOP ailleurs sur Internet, si tu as un accès illimité chez ton client.
2. Utiliser un HOP sur une clef USB, si tu as droit au support amovible.
3. Utiliser git-bundle via email
4. Installer un HOP sur ton intranet.

Pour le calcul de taux, que le long_float soit binaire ou décimal n'a aucune importance concernant l'exactitude des résultats

C'est chouette! Et donc si je calcule un truc du genre 0,2% de 1000 milliards d'euros, le genre de blagues qui arrive avec les flottants du type

# printf  "%.25f\n" (0.0021  *. 1_000_000_000_000.0);;
2099999999.9999997615814208984375000

n'arrivent pas. (Puisque comme on le voit sur l'exemple la précision est assez grande pour donner le bon résutlat après arrondi.) Le point important est de bien arrondir après chaque multiplication dans la définition de la structure de “float-module,” c'est bien ça?

Sauf que Python fournit le module datetime qui gère des dates de l'année 1 à 9999.

Qui les gère, mais vite fait:

The papal bull of February 1582 decreed that 10 days should be dropped
from October 1582 so that 15 October should follow immediately after
4 October, and from then on the reformed calendar should be used.

This was observed in Italy, Poland, Portugal, and Spain. Other Catholic
countries followed shortly after, but Protestant countries were
reluctant to change, and the Greek orthodox countries didn't change
until the start of the 1900s.

(Voir https://www.tondering.dk/claus/cal/gregorian.php, notamment la section “When did country X change from the Julian to the Gregorian calendar?” avec mention spéciale pour nos amis suédois!)

Les calculs fait par Python datetetime ne sont probablement justes que pour l'époque contemporaine.

A l'inverse un commercial rapporte de l'argent puisqu'il vend des billets donc il faut augmenter leur budget ou au moins ne pas le baisser, c'est une logique stupide mais c'est la logique de la sncf.

Si cette logique ne sévissait qu'à la SNCF, quel beau monde dans lequel nous vivrions!

En tout cas bonne chance! Si jamais tu décides quand-même de regarder ce que peut faire packetfence pour toi, ce serait super chouette que tu le racontes sur LinuxFR!

Je ne connais pas trop cet outil mais si je comprends bien leur plaquette, packetfence est un logiciel qui permet d'administrer la configuration des routeurs (si le matériel est supporté!): il s'agit d'un outil de plus haut niveau, qui peut en particulier, parmi toutes les mesures que l'outil sait prendre, configurer des pare-feu. Un pare-feu tourne sur une machine et la configuration parle d'interfaces, d'adresses IP, de ports, alors que manifestement PacketFence peut modéliser les différents éléments du réseau et assigner les nouveaux venus à des classes spéciales, etc.

Ensuite ta question "si j'ai besoin d'une solution de pare-feu, puis-je installer packetfence?" n'est pas très bien posée parcequ'elle ne parle que de solutions techniques et pas des besoins – du coup on ne sait pas quel besoin particulier te pousse à choisir un pare-feu. Si tu prends un peu de temps pour faire la liste de ce que tu veux faire avec ton pare-feu tu devrais assez facilement voir si packetfence te permet de faire la même-chose, ou pas.

Pour donner l'exemple de Java que tu donnais BigDecimal bd = new BigDecimal(5.5); le plus simple serait sûrement soit de construire une classe spéciale MoneyAmount qui fait ce qu'il faut pour s'initialiser correctement à partir d'un float. Ou bien de définir une sorte de constructeur à BigDecimal, qui fait ce qu'il faut?

J'ai l'impression que ton commentaire porte uniquement sur la deuxième partie de la citation ; corrige-moi si je me trompe.

Tu as raison, ma citation est un peu “bizarre par excès” si on peut dire. :)

Pourquoi tous les nouveaux langages fonctionnent avec, à chaque fois, une interprétation des litéraux à virgules comme étant des floats ou des doubles ?

Je pense qu'un aspect important est que soit “interpréter les litéraux à virgules comme étant des décimaux” est une idée tellement géniale que tous les langages vont adopter cette convention dans les 5 ans, soit le langage qui fait ce choix va rester durant toute son existence le cousin un peu bizarre avec qui tout le monde se prend les pieds dans le tapis parcequ'il fait les choses un peu différemment. (Déjà que certains langages se paient le luxe d'avoir des opérateurs égal ==, vraiment égal === et physiquement égal ;) )

Mettre l'exactitude mathématique comme but ultime, ce n'est pas toujours ce qui est attendu du programme informatique.

Je crois que le but des exemples n'est pas d'insister sur l'exactitude ou pas des calculs mais sur le fait qu'il y a plein de décisions arbitraires à prendre (arrondir quoi, comment, etc.) au delà des calculs proprement dits et que, qu'on utilise des flottants des rationnels ou encore autre chose ne change rien au fait que le comportement du programme doit être soigneusement spécifié par le programmeur.