David Delassus a écrit 761 commentaires

Pour le coup je ne le désactive pas car je veux que toutes variables dans mon code soit initialisée explicitement. C'est un truc que j'ai récupéré de mon expérience avec des langages un peu plus strict.

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

Compile avec -Wall -Wextra -Werror : https://gcc.godbolt.org/z/16Yfx3f3z

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

Et comme Clay est une librairie C, et que C n'a pas de "constructeurs par défaut", on doit tout préciser :)

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

Ah sérieux? J'utilise pas mal de C23, mais en C++ on est coincés à une version antérieure… bon à savoir.

Les "designated initializers" c'était une fonctionnalité de C depuis longtemps :

struct foo_type {
  int a;
  int b;
};

struct foo_type foos[10] = {
  [2] = { .a = 1 },
  [4] = { .b = 1 }
};

C++20 introduit la fonctionnalité pour les types agrégats (structures), mais pour les tableaux toujours pas (donc pas de [x] = ...).

Sauf erreurs, les channels sont aussi ce que font la plupart des frameworks récents en Rust.

En effet, des runtime async comme tokio proposent des oneshot channel (un producer, un consumer, un seul message), et des mpsc channel (multiple producer, single consumer).

Mais bon, à force de faire du Rust async, j'ai fini par développer une aversion épidermique pour ce langage. Si on ajoute à ça un écosystème pas mature, et des une perte de contrôle totale sur les dépendances ou mon target/ devient le nouveau node_modules/ (et le seul lot de consolation, c'est qu'ici c'est un langage compilé donc les symboles inutilisés peuvent être stripped out), mon choix se porte désormais sur Go malgré tout les défauts que je lui trouve (et il y en a).

Mais ici, j'avais le jeu en C++, donc j'implémente le serveur aussi en C++ :)

Tiens-nous au courant, perso je me ferai un plaisir de l'essayer -et de voir enfin la fameuse interface 😜.

J'essayerai ! J'ai un discord sur lequel il y a quasiment personne, et j'ai aussi rejoint le discord d'un dev indépendant qui bosse sur Daisy Train, je trouve ça motivant d'être entouré de gens avec des compétences diverses et variées qui tous bossent sur leurs projets :)

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

Chess meets Magic --> Wizard Arena

Un tour est découpé en plusieurs phases :

• Begin Phase : on réinitialise certaines stats des pièces sur le terrain (points de mouvement par exemple)
• Draw Phase : pioche une carte
• Cast Phase : tu joue des cartes (effet de zone, ou invocation)
• Move Phase : tu déplace tes pièces
• Battle Phase : tu choisis les pièces qui se battent (parmi celle qui sont suffisamment proche)
• End Phase

Chaque joueur commence avec un pièce sur le terrain qui fait office de roi. Quand elle meure, la partie est perdue.

Je vais peut être ajouter une seconde cast phase après la battle phase et avoir des types de cartes qui ne peuvent être jouées que pendant certaines phases, et autoriser le joueur adverse à jouer des cartes pendant la End Phase, comme à Magic. Tout ça doit être playtesté, mais avant ça je dois avoir quelque chose de jouable. Je bosse pas mal sur la partie réseau en ce moment, j'ai aussi craqué et implémenté en C++ un modèle acteur minimal avec des channels à la Golang.

https://streamable.com/0o1bqs & https://streamable.com/4yi4j4

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

J'utilise "Dear ImGui" aussi, mais plutôt pour l'UI de l'éditeur / mode debug.

Je la trouve puissante, mais difficile à styliser (peut être un problème chaise/clavier)

Comme tu dis, ici la syntaxe à base de structure etc… rappelle HTML&CSS, et permet de créer des composants fonctionnels comme on le ferait en React. La grosse différence avec ImGui, c'est que Clay ne stocke aucun état. C'est à toi de gérer ça (cela a été un challenge tout particulier lorsque j'ai implémenté mes textbox avec stb_textedit).

Ma lib "CSS" permet de créer les structures Clay_ElementDeclaration et Clay_TextElementConfig en amont, afin de pouvoir les donner aux macros CLAY(), CLAY_TEXT() etc…

A la base, j'avais voulu séparer le style de la logique de l'UI (de la même manière, en HTML&CSS on veut éviter les styles "inline" et plutôt utiliser des classes CSS). Je me retrouvait avec des 100aines de lignes de code juste pour le style en amont, et ici c'est la faute de C++ :

En C++23 (je sais plus depuis quand), lorsque l'on initialise une structure avec des "designated initializers", ils doivent être TOUS spécifiés, et dans le BON ORDRE :

struct foo_type {
  int a;
  int b;
  int c;
};

// ERROR
auto foo = foo_type{
  .b = 1,
};

// ERROR
auto foo = foo_type{
  .b = 1,
  .c = 1,
  .a = 1,
};

// OK
auto foo = foo_type{
  .a = 1,
  .b = 1,
  .c = 1,
};

Pourtant, en C23, les 3 exemples ci-dessus fonctionnent.

Je peux t'assurer que c'était chiant avec les structures de Clay et pas mal de ces macros.

Je me retrouvais avec ça au final:

auto foo = foo_type{};
foo.b = 1;

Du coup, pour chaque élément Clay, je devais avoir un Clay_ElementDeclaration de prêt. J'avais donc une structure immense avec plein de variable membre, et un fichier immense qui répertoriait tout les styles. Et je devais stocker les ids des images et polices de caractères après les avoir ajouté à l'atlas de mon moteur de rendu NanoVG.

C'était vraiment pénible, et j'ai essayé de résister pendant 3 semaines avec la pensée "je dois avancer sur le jeu, c'est pas un vrai problème". J'ai fini par craquer :D

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

Non, cela ne m'est plus arrivé depuis au moins 10 ans ça.

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

C'est ce que je faisais aussi. Mais la je tombe systématiquement sur des IA qui récitent leurs textes et ne sont pas programmées pour intéragir avec toi en fait.

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

Le soucis, c'est que j'ai des numéros légitimes qui m'appellent et que j'ai pas forcément dans mes contacts (comme des recruteurs par exemple).

Mais ces vrais que ceux là en général laissent des messages.

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

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