David Delassus a écrit 766 commentaires

Les scripts shells illisible, inmaintenable, qui changent d'une distro a l'autre car ils ont implémenté un framework shell différent comme base (avec comme mention honorable, debian qui requiert des commentaires avec une syntaxe spécifique)

^{^}

C'est pas un problème intrinsèque à SysV qui a été reproché maintes et maintes fois ?

Et que upstart/systemd ont remplacé par un fichier de conf simple, unifié entre distro, et surtout bien documenté ?

C'est une contre vérité ? C'était mieux avant ?

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

Je m'attendais pas en postant ce lien de créer une telle flamewar. Je pensais que systemd avait tellement bien fait ses preuves que ses débats étaient d'une autre époque.

Par contre, je note bien qu'après que tout tes arguments techniques ont été contré, tu passe aux attaques personnelles à l'encontre de Lennart.

Tu le connais personnellement pour dire ça ?

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

on pouvait déjà théoriquement embarquer de véritables programmes

Je me demande si quelqu'un a déjà pensé a embarquer un lecteur de pdf dans un pdf.

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

Qui aurait pu deviner qu'un dépôt centralisé que tout le monde utilise, y compris des acteurs privés, qui permet à tout le monde d'y publier du code, sans aucune restriction, aucune validation, aucune revue, aucune limite, contiendrait du malware ?

On parle de NPM, mais PyPI, crates.io, CPAN, etc… ont tous le même problème.

Et même quand tu as de la revue/validation/limitation comme les dépôts officiels d'une distribution Linux, on n'est pas à l'abri.

D'un point de vue "expérience développeur", cet outillage est très pratique. Mais d'un point de vue "sécurité", je rejoins de plus en plus l'avis de Drew Devault et sa décision de ne pas supporter ça pour son langage Hare.

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

Tu as bien 2 espaces de nom "global" (accessible via la fonction builtin globals() et "local" (accessible via la fonction builtin locals().

On vois ici que x ne fait partie ni de "global" ni de "local" :

>>> def foo():
...     x = 0
...     def g():
...             print(globals())
...             print(locals())
...     return g
...
>>> foo()()
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, 'foo': <function foo at 0x000001F518DA7F60>}
{}
>>>

Mais alors, d'où il vient ?

Réponse courte : Du locals() de la fonction f().

Réponse longue : Pour bien comprendre ce qu'il se passe, voici le code désassemblé :

>>> def f():
...     x = 0
...     def g():
...             return x
...     return g
...
>>> import dis
>>> dis.dis(f)
              0 MAKE_CELL                1 (x)

  1           2 RESUME                   0

  2           4 LOAD_CONST               1 (0)
              6 STORE_DEREF              1 (x)

  3           8 LOAD_CLOSURE             1 (x)
             10 BUILD_TUPLE              1
             12 LOAD_CONST               2 (<code object g at 0x00000243D97258F0, file "<stdin>", line 3>)
             14 MAKE_FUNCTION            8 (closure)
             16 STORE_FAST               0 (g)

  5          18 LOAD_FAST                0 (g)
             20 RETURN_VALUE

Disassembly of <code object g at 0x00000243D97258F0, file "<stdin>", line 3>:
              0 COPY_FREE_VARS           1

  3           2 RESUME                   0

  4           4 LOAD_DEREF               0 (x)
              6 RETURN_VALUE

Premièrement, dans la fonction f on créé la variable x avec l'opcode MAKE_CELL. Et on l'initialise à 0 avec LOAD_CONST et STORE_DEREF.

Vient ensuite le MAKE_FUNCTION qui va créer la fonction g() en utilisant un "code object" (le corps de la fonction g compilé), ainsi qu'un tuple qui va contenir l'espace mémoire pour des variables libres.

Ce tuple est créé avec l'opcode BUILD_TUPLE 1 (tuple de 1 élément), le tuple va être créé en prenant un élément sur la pile. Cet élément c'est une référence vers x qui est chargée avec LOAD_CLOSURE (python 3.11, depuis python 3.13 c'est LOAD_FAST).

Enfin, dans le code de la fonction g(), on a COPY_FREE_VARS qui va introduire dans la "stack frame" actuelle les variables référencées par le tuple avec lequel on a construit la "closure".

Démontrant bien qu'il n'existe que 2 espaces de noms : global et local. La fonction g porte avec elle une copie des variables qu'elle capture. Après tout, g n'est pas une fonction mais une "closure" (fonction + environnement).

En pseudo-code python, voici à peu près ce qu'il se passe :

def f():
    x = 0
    g = make_g(x)
    return g


class make_g:
    # rien ne nous oblige a appeler `self` "self" ;)
    def __init__(free_vars, x):
        free_vars.x = x

    def __call__(free_vars):
        return free_vars.x

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

"Imbitable" ça insinue que cela serait impossible a comprendre.

Hors cela suit des règles simples et précises et d'autant plus logique si on tient compte de la nature et la philosophie du langage.

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

Python est un langage dynamique, la création de classe est donc également dynamique. C'est un aspect de Python qui le rend très puissant, et la plupart des ORMs Python utilisent ce comportement.

Je ne vois rien de choquant ici.

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

Python n'a que 2 espaces de noms : global et local.

Donc :

# global

class Foo:
    # local

    def meth(self):
        # local (mais un nouveau local, pas celui au dessus)
        ...

Quand une variable n'est pas définie dans l'espace de nom "local", Python le cherche dans l'espace de nom "global". Dans ton exemple, x n'existe pas dans "global", d'où l'erreur.

Le corps de la classe est exécuté lors de la création de la classe, mais le corps de la méthode est exécuté que lorsqu'elle est appelée, l'espace de nom du corps de la classe n'existe donc plus à ce moment là.

Il faut imaginer que ce qu'il se passe c'est ça :

def Foo_meth(self):
    return x


def make_Foo():
    return type("Foo", tuple(), {"x": 0, "meth": Foo_meth})


Foo = make_Foo()
foo = Foo()
foo.meth()

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

Lors de l'instanciation de la classe, les variables de classes sont copiées dans l'instance (self).

Les collections en Python sont des références, c'est donc la référence qui est copiée.

C'est comme en C au final :

struct foo {
  int a;
  int *p;
};

int n = 42;
struct foo x = { .a = 23, .p = &n };
struct foo y;

memcpy(&y, &x, sizeof(struct foo));

*y.p = 0;
assert(*x.p == 0);

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

Je peux difficilement me citer moi même comme source :D

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

D'ailleurs, l'auteur de HTMX travaille actuellement sur des RFC / Specifications pour introduire dans HTML certaines fonctionnalités de HTMX.

Source: trust me bro. Plus sérieusement, j'avais vu passer un lien sur HackerNews parlant de cela il y a quelques temps, mais impossible de le retrouver :(

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

Pour mon test, j'ai utilisé Zapier pour créer une Webhook et transmettre les messages sur un Slack. Zapier te permettra également d'envoyer des mails, d'ouvrir des tickets Jira, etc… C'est un outil assez complet.

A $emploi_actuel on compte utiliser les webhook de AWX pour déclencher l'exécution de job Ansible lors de la réception de certains types de logs.

En fait, comme derrière c'est une simple requête HTTP POST, tu fais ce que tu veux.

Ce que je vois beaucoup au boulot, c'est du Prometheus+AlertManager, du Grafana + Grafana Alerting, du Splunk ou Datadog. On a aussi du SNMP. Et les notifications de tout ces systèmes sont ensuite envoyées par mail aux équipes concernées.

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

pstree est-il compilé statiquement ? Et possède-t-il le gros runtime de Go ? :)

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

La politique c'est comme l'andouillette. Quand c'est bien fait ça pue toujours un peu la merde.

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

"a des affinités avec" != "appartient au même parti politique"

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

De même beaucoup de logiciels n'ont jamais demarrés proprios.

Bah si, tous en fait. A cause du droit d'auteur. Une licence libre ne fait que donner des droits aux autres sur une création dont l'auteur a tout les droits.

Avant ce premier commit qui inclus le LICENSE.txt ou équivalent, toutes création est privée/propriétaire. Tu dois activement donner des libertés.

Tu ne commences pas dans le domaine publique, ce qui nécessiterait d'activement retirer des libertés.

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

si il y a eu un changement arbitraire une fois, ça peut rechanger à nouveau. Aucune garantie n'est donné

Je dirais même plus, pour absolument tout les projets qui existent dans le monde, si il y a eu un changement arbitraire 0 fois, ça peut changer. Aucune garantie n'est donnée.

Toute création est d'abord privée, soumise au droit d'auteur, puis ensuite rendue publique, et donnant plus ou moins de droits sur son usage. L'auteur est maître absolue de la création, il en fait ce qu'il veut.

Croire que l'on peut avoir une quelconque garantie de quoi que ce soit concernant l'oeuvre et l'auteur, s'est se mettre le doigt dans l'oeil jusqu'au coude.

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

Merci :)

N'hésite pas à faire des retours, toutes critiques est bonne pour améliorer la solution ^{^}

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

Désolé de faire ça en 2 commentaires, j'ai oublié de préciser :

Je veux aussi que l'outil soit le plus simple possible a déployer. C'est à dire une seule image Docker.

Donc dépendre d'une base de données externe comme PostgreSQL c'était exclu.

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

Alors, sur un screenshot on le voit pas, mais les lignes sont "animées" ce qui aide à la visualisation :)

Après, c'est surtout que je voulais faire tenir l'ensemble de la pipeline sur la capture d'écran. De toute façon, il y a plein de choses à améliorer sur le design.

React Flow offre la possibilité d'agencer les noeuds automatiquement, mais non, ici c'est bien moi qui ait fait ça ^{^}

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

Sisi, l'outil stocke bien les données.

Mon choix s'est porté sur BadgerDB car c'est une base de données clés/valeurs très solide et distribuée sous forme de librairie Go.

Une base de données SQL implique d'avoir un schéma, ou de s'en servir comme une base de donnée clé/valeur.

Pour ce qui est de la structure de données sous jacente, BadgerDB utilise un LSM Tree ( https://en.wikipedia.org/wiki/Log-structured_merge-tree ) ce qui se prête très bien aux données que je désire stocker.

De plus BadgerDB supporte les transactions ACID (la plupart des base de données SQL aussi cela dit), donc il n'y a aucun inconvénient à l'utiliser.

En utilisant une base de données clés/valeurs, j'ai aussi un meilleur contrôle sur la structure de données pour les indexes.

Je t'invite à lire ce document : https://github.com/link-society/flowg/blob/main/docs/design/storage.md
Il est peut être incomplet, donc tout retours dessus est bienvenu :)

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

Effectivement, pour le travail je communique principalement en Anglais (notre équipe est composés de personnes de plusieurs pays d'Europe différents, l'Anglais est le dénominateur commun). J'en oubli souvent mon Français.

J'ai fait des efforts ici pour essayer de traduire au mieux, mais j'ai du mal :)

on a un opinion défavorable de ELK pour aucune raison valable si ce n'est qu'on aime pas.

C'est le sentiment que je voulais partager ^{^}

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

Un binaire qui embarque les fichiers statiques, ainsi que l'interpréteur VRL.

Dans ton PATH, tes binaires sont compilés dynamiquement, et n'embarquent pas de code JS, CSS, d'images, de fonts, …

Comparons ce qui est comparable. Ici l'empreinte totale de FlowG sur le disque après installation, c'est 40Mo.

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

The year of the Windows Desktop!

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

La guerre c'est pas un sujet politique ?

Sinon, c'est quoi le lien avec Linux et le Logiciel Libre ?

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