David Delassus a écrit 761 commentaires

Du coup, la discussion suivante s'est terminée par un let's go, on supprime.

Question pour les lecteurs, comment vous choisissez votre système de fichier ? J'avoue pour ma part en avoir strictement rien à faire et je prend le très vénérable ext (ext4 aujourd'hui), ne l'ayant pas comparé à XFS, ZFS, BTRFS, …

https://link-society.com - https://kubirds.com - https://github.com/link-society/flowg

Ça me rappelle : http://informatimago.free.fr/i/linux/emacs-on-user-mode-linux.html

https://link-society.com - https://kubirds.com - https://github.com/link-society/flowg

En plus, histoire de déterrer un vieux débat…

systemd est né de la réflexion suivante :

fuck POSIX, on est sur Linux pas sur UNIX, on a des fonctionnalités géniales qu'on utilise même pas sous prétexte que c'est pas POSIX

Le résultat est que systemd (aussi bloat soit il c'est pas le sujet) est devenu le standard sous Linux (il ne reste que quelques rare distributions à ne pas le proposer), et l'expérience utilisateur avec ce dernier comparé à SysV est infiniment supérieure.

C'est la même chose pour gcc/clang. Je n'ai JAMAIS utilisé un compilateur POSIX, j'avais AUCUN remort à utiliser des __attribute__(...) qui sont des fonctionnalités propre à un seul compilateur, des fois je faisais même des #define _GNU_SOURCES pour avoir des fonctionnalités non POSIX comme asprintf et vasprintf.

A un moment, tu maîtrise ta toolchain ou tu la maîtrise pas. Le "ça pu c'est pas POSIX" c'est bien quand tu fais des scripts shell pour déployer sur toute les plateformes (et encore, bash c'est tellement commun, ça tourne même sous Windows), c'est complètement stupide et décalé quand on parle de toolchain de build.

https://link-society.com - https://kubirds.com - https://github.com/link-society/flowg

Ce que je voulais dire c'est "implémenter moi même un prompt qui demande un secret alors que des outils dédiés existent pour ça" c'est pas top.

Je connaissais pas sshpass :)

https://link-society.com - https://kubirds.com - https://github.com/link-society/flowg

La différence, c'est l'ambition :)

Je prévois de rajouter par la suite des fonctionnalités du type :

• système de plugin
• "gather facts" à la ansible
• API Rust/Go/Typescript/Python pour intégrer ça dans ton langage de script favoris (parce que bash c'est quand même bof), imagine distribuer un setup.exe qui te déploie l'infra complète :D

J'ai commencé petit dans le but de voir comment cela pourrait être utilisé. Après tout exécuter des commandes sur des hôtes distant c'est le coeur du projet, le MVP si j'ose dire.

https://link-society.com - https://kubirds.com - https://github.com/link-society/flowg

Je commence à avoir l'habitude de te croiser en pleine nuit.

Avoue, tu n'es pas encore allé te coucher, donc c'est encore trolldi pour l'instant ;)

https://link-society.com - https://kubirds.com - https://github.com/link-society/flowg

Le module "shell" de Ansible n'est pas idempotent non plus.
En fait, beaucoup de modules de Ansible ne sont pas idempotent.

Ce qui permet d'implémenter l'idempotence dans Ansible c'est la possibilité d'interoger le remote sur son état et d'exécuter conditionnellement la tâche.

Par exemple, avec tricorder ça donnerait quelque chose comme :

# idempotent car si le service est déjà démarré, ça ne fait rien
tricorder -i inventory -- systemctl start nginx.service

res=$(tricorder -i inventory -- test -f $FILE)
host_ids=$(echo $res | jq "some request to get all hosts with non zero exit code")

for host_id in $host_ids
do
  tricorder -i inventory -H $host_id -- sh -c "echo $host_id > $FILE"
done

Alors oui, c'est verbeux pour le moment, parce qu'il faut le faire à la main, mais on pourrait très bien imaginer un plugin dans le futur qui fait ce genre de choses.

Donc pour te répondre, non pas d'idempotence dans cette brique élémentaire.

https://link-society.com - https://kubirds.com - https://github.com/link-society/flowg

C'est pour ça que les ukrainiens ont pu faire :

from russia import weapons

https://link-society.com - https://kubirds.com - https://github.com/link-society/flowg

Sauf que Salt c'est pas KISS du coup. Ca fait beaucoup de choses (c'est pas forcément un défaut).

De plus l'output de salt-ssh est difficilement exploitable dans un script shell ou autre programme.

Ici il s'agit de filer un outil et de pas rester dans tes pattes. Tu fais ce que tu veux comme tu veux par la suite.

Après, d'ici à ce que je fasse réellement concurrence à Ansible, Chef, Puppet, Salt, … il va falloir que je constitue un costaud écosystème.

Je prévois potentiellement de faire un système de plugin à la kubectl: tricorder-<plugin name> dans le PATH? alors tu as tricorder subcommand de disponible. Ce qui te laisserait faire des plugins dans n'importe quel langage.

Merci pour le retour en tout cas :)

https://link-society.com - https://kubirds.com - https://github.com/link-society/flowg

Merci pour le retour :)

Il n'y a rien à installé côté serveur à part ssh ?

Nope, comme ansible c'est "agent-less". C'est ce que j'appréciais grandement à propos de Ansible d'ailleurs.

En plus les bindings de libssh2 en Rust sont vraiment agréable à utiliser. Mais j'ai volontairement restraint à me reposer sur ssh-agent parce que :

• avoir un prompt pour le mot de passe dans un script d'automatisation c'est pas top
• avoir un prompt pour la passphrase de la clé ssh c'est pas top non plus

Et puis, dans un principe KISS, je délègue l'authent à un autre outil (ssh-agent) et je fais uniquement ce que j'ai besoin de faire : exécuter des commandes sur des remote.

https://link-society.com - https://kubirds.com - https://github.com/link-society/flowg

https://news.ycombinator.com/item?id=30806615

https://link-society.com - https://kubirds.com - https://github.com/link-society/flowg

Dans 80% des cas, le main.go est au même niveau que le go.mod.

Dans les 20% restant ce sera dans cmd/nom_de_la_commande/.

Mais oui, du coup c'est bien le nom du dossier et non le nom du "projet". Même si ça revient plus ou moins au même.

https://link-society.com - https://kubirds.com - https://github.com/link-society/flowg

Cargo (Rust) et Go utilisent le nom du projet (dossier dans lequel il y a le Cargo.toml ou go.mod).

Quelque chose de similaire serait sympa non ?

https://link-society.com - https://kubirds.com - https://github.com/link-society/flowg

Je suis toujours ravi de supprimer de code. C'est ça de moins à maintenir :)

La programmation c'est l'art d'ajouter des bugs à un fichier texte vide.

Moins de code, moins de bugs, moins de travail, plus de temps pour les choses vraiment importante.

Pour ce qui est de Rust, je note le troll (c'est permis, on est trolldi). Cependant certains bouts de code ont déjà commencé à être porté. Je ne pense pas qu'on verra de si tôt un noyau Linux entièrement en Rust, mais ce langage a déjà commencé à s'y introduire :

• Rust heads into the kernel?
• Supporting Linux development in Rust
• Using Rust for kernel development

Pour continuer dans la tradition du trolldi, à quand GNU/Hurd en Rust du coup ?

https://link-society.com - https://kubirds.com - https://github.com/link-society/flowg

Développeurs heureux = kernel mieux maintenu
kernel mieux maintenu = utilisateur heureux

Moins de code c'est aussi un vecteur d'attaque réduit, donc une sécurité accrue.

https://link-society.com - https://kubirds.com - https://github.com/link-society/flowg

Si un(e) modo passe par là, j'ai écorché le nom de l'auteur : Jonathan Corbet

https://link-society.com - https://kubirds.com - https://github.com/link-society/flowg

Oui, cela montre que les développeurs ont vraiment à coeur les utilisateurs.

Par contre, je pense pas qu'ils l'ont fait pour "un" utilisateur, mais qu'ils ont utilisé cet utilisateur spécifiquement comme exemple que on ne sait jamais quel est l'impact, car il y a probablement tout les utilisateurs qui ne lisent pas la mailing list ou les nouveautés.

https://link-society.com - https://kubirds.com - https://github.com/link-society/flowg

https://news.ycombinator.com/item?id=30792059

https://link-society.com - https://kubirds.com - https://github.com/link-society/flowg

Comme le nommage de variable est clair, on comprend tout de suite qu'on veut dormir des secondes carrées non ?

Le soucis, c'est la définition de time.Second (1 million de nanoseconde).

Avec un système d'unité, on obtiendrait effectivement s² et générerait une erreur de compilation car time.Sleep attend des secondes.

Ici à la place, on a delay * 1 million * 1 million. Une erreur qui passe inaperçue surtout si l'assignation de delay est loin de son utilisation. Bonjour les galères de debug.

La création de ces constantes part d'une bonne intention, mais comme d'habitude avec Golang, c'est juste un footgun de plus.

https://link-society.com - https://kubirds.com - https://github.com/link-society/flowg

L’homogénéité des formules, le travail de normalisation et l’estimation de la propagation des erreurs sont trop complexes pour être gérés par un langage de programmation.

On disait pareil des techniques pour vérifier la sécurité des opérations de manipulation de la mémoire avant que Rust arrive.

Après, Letlang n'est pas un langage scientifique, donc je ne compte pas forcément introduire des techniques pour le calcul de précision (propagation d'erreur etc…).

Cela dit, la notion d'unité et de quantité reste un outil fort pratique :

• auto-documentation des données manipulées (on ne mélange pas les torchons et les serviettes, encore faut-il savoir faire la différence)
• vérification de la cohérence des opérations (j'ai dit, on mélange pas les torchons et les serviettes, maintenant qu'on sait faire la différence…)
• conversion explicite (c'est fini de confondre degrés et radians quand on manipule cos/sin/tan, ce qui arrive souvent en gamedev)

https://link-society.com - https://kubirds.com - https://github.com/link-society/flowg

Oui, c'est bien un problème problématique ;)

Bien que imprécise, cette notion est quand même pratique. Par exemple :

• implémente moi un programme qui lance cette touche tout les 2 mois
• mets moi un rappel de cet événement dans 5 mois
• entraîne ce réseau neuronal pendant 1 mois complet

On a ainsi :

• une règle de récurrence, solution : donne moi le jour du mois au tu veux l'exécuter
• une date, solution : j'incrémente uniquement la partie "mois" de la date initiale
• une durée, solution : exprime cette durée dans une unité plus précise

L'idée c'est de fournir un framework cohérent pour exprimer précisément cette notion imprécise. Sujet drôlement complexe. C'est pourquoi je proposais dans l'article de différentier :

• durée "absolue" en secondes
• fenêtre temporelle à l'aide de 2 points temporels

Ainsi, on pourrait construire à partir d'un point temporel "1 mois" en fonction du calendrier associé à ce point temporel.

https://link-society.com - https://kubirds.com - https://github.com/link-society/flowg

Je ne connais pas de langage qui gère le calendrier dans le langage. Ça fait plutôt parti de la bibliothèque standard.

C'est pour ça que j'ai dit :

Revenons au sujet. Quand je vais devoir écrire la bibliothèque standard du langage. Quel serait selon toi le moyen le plus correct d'écrire cet objet timedelta ? Quelle est son unité ?

Concrètement, je trouve la manière de faire de Python pas bonne. Celle de Javascript est encore pire. Passons sur le Go qui est très douteux sur le sujet aussi.

La question ici, c'est vraiment : à quoi ressemblerai un framework correct pour manipuler des dates et des durées calendaires ?

https://link-society.com - https://kubirds.com - https://github.com/link-society/flowg

delay := 3 * time.Second

// 300 lignes de code plus loin

time.Sleep(delay * time.Second)

https://cs.opensource.google/go/go/+/refs/tags/go1.18:src/time/time.go;l=607

J'espère que tu as le temps.

https://link-society.com - https://kubirds.com - https://github.com/link-society/flowg

lancer une exception c’est loin d’être cheap

Totalement d'accord. Et c'est aussi plus complexe à implémenter correctement dans un interpréteur / compilateur.

ne pas abstraire le mécanisme, et laisser le développeur gérer ça

C'est la méthode Erlang/Elixir. Mais ça génère pas trop de boilerplate grâce au pattern matching.

abstraire le mécanisme, en prétendant que c’est une vraie exception, mais laisser le compilo gérer le sucre syntaxique

C'est plus ou moins la méthode de Rust avec le ? que tu mets après les appels de fonction qui retournent cette structure.

https://link-society.com - https://kubirds.com - https://github.com/link-society/flowg

C'est marrant car la majeur partie des commentaires de ce lien se plaigne justement du lien en question :P

https://link-society.com - https://kubirds.com - https://github.com/link-society/flowg