David Delassus a écrit 752 commentaires

réduire la surface d'attaque

Alors oui, et non. Certes il y a moins de code attaquable dans le binaire, mais il est compilé statiquement. Donc si une dépendance obtient un correctif de sécurité, il faut le recompiler pour ne pas avoir un binaire qui traine avec une dépendance trouée et/ou obsolète.

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

Ici, rien ne l’indique.

J'ai très honnêtement passé plus de temps à trouver comment faire une capture d'une session de terminal (asciinema est génial au passage !) qu'à écrire le README pour un projet de moins de 500 lignes bourré de copier/coller :p

c’est un projet sans grand intérêt

Oui, tout à fait. Et je pense que ça vaut quand même le coup d'être partagé. Sur lobste.rs par exemple, cela m'a permis de découvrir les outils que d'autres utilisent pour répondre à ce besoin.

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

Ici, le projet a été créé notamment pour découvrir et apprendre la libraire "iocraft", une librairie pour faire des TUI en Rust, avec une expérience similaire à React+Flexbox, qui selon moi est une bien meilleure expérience que ratatui.

Oui, le seul argument c'est "écrit en Rust", car cela s'adresse principalement aux gens qui sont intéressé par le développement d'application en Rust.

Fonctionnellement parlant, le logiciel n'est même pas si intéressant que ça. Il ne gère qu'un cas d'usage très limité. Il suffit de voir ce commentaire sur lobste.rs qui est bien plus intéressant que le tiens : https://lobste.rs/s/zxpqz0/regname_mass_renamer_tui_written_rust#c_igvgna

Ici on aime bien critiquer la forme et pas le fond :)

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

Le requirements.txt n'est pas vraiment un "lockfile" car, sauf s'il est généré à partir de pip freeze, il ne "pin" pas les dépendances à une version exact, et ne force pas la présence des dépendances indirectes.

De plus, il n'était pas standard, dans le sens ou Python n'avait, jusqu'à maintenant, codifié le format du fichier.

Grâce à cette PEP, tout les outils (uv, poetry, pdm, pipenv, …) qui décideront de l'implémenter seront compatibles les uns avec les autres (réduisant ainsi la friction bien connue du packaging Python).

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

https://discuss.python.org/t/pep-751-one-last-time/77293/150

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

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