David Delassus a écrit 747 commentaires

De mon expérience personnelle et professionnelle avec Python, c'est quand même rare que ça arrive.

Et quand ça arrive, ben on fait pas, on fait un apt install avant le pip install. Le dev le fait sur sa machine, l'ops le fait dans son Dockerfile.

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

Python a aussi un serveur HTTP dans la librairie standard :

from http.server import BaseHTTPRequestHandler, HTTPServer

class Handler(BaseHTTPRequestHandler):
    def do_GET(self):
        self.send_response(200)
        self.send_header('Content-type', 'text/plain')
        self.end_headers()
        self.wfile.write(b'hello world')

if __name__ == '__main__':
    server = HTTPServer(('localhost', 8000), Handler)
    print('Server running on http://localhost:8000/')
    server.serve_forever()

Pas besoin d'installer FastAPI pour ça. L'image `python:3.13-alpine" fait 45Mo (18Mo compressée), pas 164Mo.

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

Bref, les développeurs C quand ils codent ça va, mais dès qu'ils parlent, c'est là qu'il y a des problèmes.

---

A mince, on est plus vendredi, il aurait fallu attendre la semaine pour troller.

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

Merci pour les corrections !

J'avoue que j'ai encore du mal avec certaines expressions anglaises, je les comprends mais les retranscrire est parfois difficile. Je suis pas traducteur professionnel après tout :p Mais j'aime bien cet exercice occasionnel.

Si un modérateur peut éditer :)

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

C'est bien connu que sur internet, si on veut une solution à un problème, il vaut mieux poster la mauvaise réponse, plutôt que la question.

https://meta.wikimedia.org/wiki/Cunningham%27s_Law/fr

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

Moi je me demande pourquoi toutes les distros auraient sauté sur systemd si c'est tellement pourri.

Argument fallacieux, il y a plusieurs milliards de mouche sur terre qui bouffent des excréments, on devrait les imiter ?

:)

PS: Je suis d'avis que systemd c'est très bien, pas parfait, et qu'il aura sûrement un successeur qui sera pas parfait non plus.

Il n'y a que 2 types de logiciels : les logiciels que tout le monde déteste, et les logiciels que personne n'utilise.

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

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