David Delassus a écrit 766 commentaires

La licence se contredit :

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software

• free of charge
• without restriction
• use, copy, …

Puis :

may not be used for the purposes of […]

L'en-tête du sujet :

Don't we have to ask for permission before feeding someone's years of work into an AI?

Ben non, c'est le principe d'une licence opensource, tu donnes la permission à tout le monde pour pas qu'on ait besoin de te la demander.

Ce genre de sujet me fait prendre conscience qu'en réalité, peu de monde ne comprennent le concept d'OpenSource / Libre, c'est triste. C'est ces mêmes gens qui vont basculer sur des licences type BSL dès que les gens vont utiliser les permissions qu'ils ont eux même donné, et vont ensuite se plaindre que "personne ne veut payer pour le truc que j'ai consciemment donné gratuitement".

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

C'est un projet Open Source, pas un "produit".

En tant que tel, il est passé par le même (long) chemin de validation que nginx, traefik, apache, etc…

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

https://gitmoji.dev

Ca créé un git log beaucoup plus facile a lire visuellement, et ça reste facilement "greppable" vu qu'on utilise la notation :emoji_name: qui est textuelle.

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

DISCLAIMER: Je travaille en tant que SecOps à la Commission Européenne.

En interne, on pousse pas mal pour utiliser de l'opensource la ou on peut, et s'émanciper un maximum des géants américains. C'est pas facile, car comme dans toute bureaucratie, les choses bougent lentement, et adopter une nouvelle technologie demande beaucoup de préparation, surtout si il faut migrer d'une précédente technologie propriétaire qui est présente depuis 20 ans.

On a réussi en 2025 a migrer une grosse partie de nos environnements de "techno proprio X" vers "techno opensource Y" (faudrait que je relise mon contrat pour savoir a quel point je peux divulguer ce genre d'information, donc désolé si je reste vague). La migration se poursuit en 2026 et on espère l'avoir fini d'ici la fin du premier trimestre.

D'ailleurs, on est aussi en train d'introduire petit à petit https://github.com/link-society/flowg que je développe avec ma société, le but étant de prouver ses capacités a remplacer encore d'autres technologies propriétaires qui coûtent bonbon.

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

remplace u par user

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

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