David Delassus a écrit 749 commentaires

J'ai eu comme un mauvais souvenir qui a refait surface sans crier gare en lisant le titre.

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

Dans mon cas, Windows 11 avec VS Code.

Parmi les toolchains que j'ai :

• Elixir 1.13 / OTP 24
• Python 3.10 avec poetry
• NodeJS (via NVM pour supporter plusieurs versions) avec Yarn
• Rust (via rustup)
• CLang et CMake
• Go 1.17

Je travaille intensément avec Docker et Kubernetes (KinD en local, DigitalOcean pour la (pre)prod).

Cela va faire 5-6 ans que je n'ai plus de Linux installé en natif autre part que sur des serveurs. Ca a commencé par un ordinateur fournit par un employeur qui était sous Windows 10. J'utilisais pas mal le Windows Subsystem Linux, au début. Maintenant je ne l'utilise que rarement.

L'OS de Microsoft a beaucoup évolué et me permet d'avoir un environnement de dev efficace. Et cela m'a permit de beaucoup progresser question portabilité.

J'ai fini par tomber amoureux par le manque de choix. Au lieu de passer mon temps à tout configurer au poil, ou a tester 30 000 alternatives, je prend ce qui est fournit et je me focus sur mon travail.

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

De mémoire, tu peux pas avoir ton RootFS qui utilise fuse.

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

De toute façon, y a plus de petit fichiers, c'est fini (joke)

Toi tu connais pas NPM (joke aussi)

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

Les pluriels des mots n'apparaissent jamais dans un dictionnaire. Étant donné que c'est ma source, normal que cela ne soit pas pris en compte.

Faire une liste complète prendrait beaucoup de temps je pense.

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

Les pluriels sont des déclinaisons d'un mot. Il est donc "normal" de ne pas le trouver dans un dictionnaire. Le mot c'est "tear".

Ce que je retiens de la plupart des retours que j'ai eu, c'est que pour rendre le jeu agréable il faut passer plus que 30 secondes sur la conception de la liste.

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

Certes Nomad est un excellent outil. Mais le comparer à Kubernetes n'est pas très correct.

Nomad est un outil d'orchestration de conteneur et de VM. Kubernetes est bien plus que ça. Kubernetes offre des fonctionnalités comme la gestion du traffic (Service, Ingress, NetworkPolicy, …), la gestion des secrets et de la configuration (ConfigMap, Secret), la gestion du stockage (PeristentVolume, PersistentVolumeClaim, …). Il permet de gérer précisément le scheduling, le monitoring (liveness/readiness probes), le service discovery, etc…

Les opérateurs Kubernetes qui existent permettent également d'augmenter les capacités de son API, on va avoir ainsi du Cert-Manager, du Tekton, du KubeDB, du ArgoCD, etc…

Kubernetes offre aussi la gestion de cluster (drainage des nodes, ajout de worker node depuis un peu partout, etc…),

Si on veut atteindre le même niveau de fonctionnalité avec les outils de Hashicorp, il va falloir mettre en place Nomad, Vault, Consul, Terraform, etc… Tout de suite, la complexité de l'infrastructure atteint celle d'une distribution Kubernetes.

Bref, Nomad c'est bien mais non ce n'est pas la même chose que Kubernetes : https://www.nomadproject.io/docs/nomad-vs-kubernetes

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

~2500 mots de 5 lettres dans ma liste vs 12478 mots au scrabble anglais. Oui il m'en manque beaucoup.

J'ai pas cherché plus de 2min :

• google: english dictionary json
• premier lien pertinent, clic, download
• python + filtering

Bim.

Si tu trouves une liste plus complète, libre à toi de faire une PR :)

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

dans quels cas std::function ne fera-t-elle pas d'allocation dynamique ? Est-ce garanti ?

Quand elle est initialisée à partir d'un pointeur de fonction, et oui c'est garanti.

Pour les lambdas, je suis pas sûr.

proposer une implémentation qui ne fait jamais d'allocations dynamiques

A partir du moment ou je veux pouvoir "defer" des fonctions, lambdas, des méthodes d'objet, et pouvoir jouer avec std::bind. Je pense pas que cela soit possible.

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

Un autre exemple qui vaut le coup d'oeil :

class texture_manager {
  private:
    new_defer_frame();
    SDL_Renderer *m_renderer;

  public:
    texture_manager(SDL_Renderer *renderer) : m_renderer(renderer) {}

    SDL_Texture *load(const char *asset_path) {
      defer_frame __; // pour pas shadow celle définie au niveau de la classe

      auto surface = IMG_Load(asset_path);
      if (surface == nullptr) {
        throw std::runtime_error(IMG_GetError());
      }
      __.defer([&]() { SDL_FreeSurface(surface); });

      auto texture = SDL_CreateTextureFromSurface(m_renderer, surface);
      if (texture == nullptr) {
        throw std::runtime_error(SDL_GetError());
      }
      defer({ SDL_DestroyTexture(texture); });

      return texture;
    }
};

Dans cet exemple, j'ai 2 frames, une au niveau de la classe qui sera appelée par le destructeur, m'évitant ainsi de devoir maintenir une liste des textures créées. Et une au niveau de la fonction pour détruire la surface qui n'est que temporaire.

Dans ma fonction run_sdl_program(), j'ai plus qu'à faire un new et "defer" le delete de mon texture_manager.

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

il me semble que l'ordre de libération est inverse

C'est le cas, j'ai utilisé rbegin et rend, qui itère sur le std::vector depuis la fin vers le début.

En go, j'imagine que ça :

En Go defer exécute du code à la fin de la fonction, pas à la fin du scope, donc ton defer à l'intérieur du if ne sera pas exécuté au bon moment.

Donc ma version C++ permet une gestion plus fine. Le fait de déclarer une seconde frame dans le if (qui repose sur le variable shadowing) va justement te permettre d'avoir le comportement souhaité.

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

Et donc tu appelles quand le SDL_DestroyRenderer/Window et SQL_Quit ?

Si tu me dis que tu les appelles pas et que tu quittes tout simplement le programme sans t'en préoccuper, je te répondrais :

Et tu fais quoi si tu as plusieurs fenêtres (cf ceci) ?

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

Prend l'exemple de la SDL.

Tu serais obligé de créer des unique_ptr<SDL_Window> et unique_ptr<SDL_Renderer> avec les deleters appropriés. Tu devras aussi encapsuler dans une classe l'appel à SDL_Init avec son destructeur qui appelle SDL_Quit. Tout plein de code qui complexifie une fonction pourtant toute bête.

Je t'avouerai en plus ne pas connaître suffisamment la spec pour te garantir dans quel ordre les destructeurs seront appelés. Ici, au moins, c'est explicite.

RAII c'est un design pattern parmi d'autres. Si tu utilises une lib C en C++ (SDL, lua, …), c'est parfois plus simple et plus clair d'avoir un simple defer.

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

Et voilà, après 5 relectures, je laisse ensemble de fonction au lieu de ensemble de fonctions.

Quand est-ce que je le vois ? Juste après avoir cliqué sur "Poster".

Si les modos passent par là…

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

Ah si je pouvais être payé pour écrire ce qui me passe par la tête sur LinuxFR, j'écrirais peut être plus souvent que 2-3 articles tout les 4-5 ans.

C'est pas que je manque de sujet, c'est plutôt que si j'écrivais vraiment tout ce qui me passe par la tête, mon karma ne survivrait pas longtemps. Du coup je vous partage que ce qui selon moi vous intéressera.

Coup de bol, ce mois-ci, pour la première fois de mes 10+ années de moulage, je suis dans les meilleures notes, et 2 fois en plus ! Ça fait plaisir, j'ai gagné des points internets :D

Vivement le jour ou mon score de base de mes commentaires est de 2 ou 3 pour pouvoir m'accaparer plus de visibilité par défaut un peu partout sur le site…

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

https://fr.wikipedia.org/wiki/Club_des_27

Le club des 27, appelé aussi Forever 27 Club, 27 Club ou le Club 27, est le surnom donné à un ensemble d'artistes célèbres du rock et du blues qui ont comme point commun d'être morts à l'âge de 27 ans.

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

Le kernel : 6.6 Mo
Le initrd : ~40 Mo

Et les bins de busybox ~20Mo. J'aurais pu télécharger uniquement le binaire busybox et faire des hard links (cc ln) pour économiser de l'espace.

Mais oui j'ai pris celui de Debian tel quel, pour pas me prendre la tête, il y a beaucoup d'optimisations possibles.

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

Que tout le monde comprend, c'est pas évident, faudrait faire un sondage.

Comme je l'ai dit dans un autre commentaire. La majeure partie de la littérature informatique et technique est en anglais.

Il est donc très très peu probable qu'un individu ne rencontre jamais les termes anglais. Il est de même très probable que ce même individu ne rencontre jamais les termes français. D'ailleurs pour être honnête, la plupart de ces termes, je ne les vois QUE sur LinuxFR.

Au delà de ça, en fonction du contexte, tout le monde a probablement une limite d'acceptabilité de l'artificialisation du langage, dont la jargonnalisation procède.

Kamoulox!

Par exemple je trouve disgratieux et potentiellement pas clair l'idée d'uploader sa ssh-key pour checkouter son repo.

Merci de prendre cet exemple.

• "to download" -> télécharger
• "to upload" -> télécharger

Et non ! Téléverser est un néologisme, il n'existe pas dans le dictionnaire de l'académie française.

Du coup, la vraie traduction de "upload an ssh-key to checkout a repository", c'est "télécharger une clé SSH pour récupérer un dépôt".

On est d'accord que c'est sujet à confusion ?

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

j'ajouterai que les francisations qui n'existent (quasiment) pas dans le language courant sont vraiment reloues …

Exemple, toutes les déviations de "logiciel" :

• cadriciel, systématiquement je dois googler pour me rendre compte qu'on parle de "framework"
• progiciel pour logiciel propriétaire
• maliciel, pour malware
• gratuiciel, pour freeware
• cacaciel, pour la blague

Après, il y a les faux amis qui sont mal traduit :

• library -> c'est bibliothèque, pas librairie, merci

Je suis pour la francisation des termes, mais ça doit aussi refléter la réalité …

La réalité c'est que 99% de la littérature informatique et technique est en anglais. Et que la nomenclature qui en dérive, est anglaise. Pour un débutant dans le domaine, c'est difficile de devoir apprendre des termes que de toute façon personne n'utilise.

Je dis plus souvent kernel que noyau, je dis booter et pas démarrer, je continuerai de dire framework, library, software et bullshit au lieu de cadriciel, bibliothèque, logiciel et merde de taureau.

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

La manie de vouloir absolument traduire les termes anglais que tout le monde comprend… moi je la comprend pas.

Release of Groovy 4.0

Ça se traduirait par :

Sortie de Groovy 4.0

Bien que Google Translate traduit "to release" en "libérer" (dans le sens libérer de prison). C'est pas le cas ici. Pour le coup "libération de [SOFTWARE]" ça signifie qu'il était propriétaire et qu'il est sorti sous licence libre. On est bien loin de la réalité ici.

Sur une note plus positive, ravi que le langage derrière les Jenkinsfile continue d'évoluer. Merci pour cette mise en bouche.

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

bref, j'ai écrit un init qui se configure en Lua

Je suis un DevOps, le "Infrastructure as Code" c'est mon quotidien :D

Si tu te méfies pas, tu vas te retrouver avec une distrib perso :)

Là, on en est encore loin quand même :

• pas de gestion des users, il y a que root pour l'instant
• pas de gestionnaire de paquet
• pas une chaîne de compilation indépendante d'un système hôte (faire gaffe donc au chemin des .so, ou alors tout compiler en statique, ou alors tout plein de lien symboliques)

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

Mon RootFS utilise actuellement environ 70Mo.

Ce que tu décris est parfaitement possible, c'est le principe même des unikernel.

Il faut cependant noter que le processus init a un rôle particulier :

• il doit toujours tourner, si il s'arrête, kernel panic
• il doit écouter le signal SIGCHLD de tout ses enfants, et le traiter correctement, sinon les processus zombies de sont pas supprimé de la liste des processus
• il doit gérer les signaux ACPI pour éteindre la machine, rebooter, etc…

C'est la raison pour laquelle j'ai choisi BusyBox au lieu de développer le mien.

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

Yes, pas besoin de le préciser, mais je l'ai mis de manière explicite pour faire découvrir l'option du noyau, au cas ou tu veux t'écarter du FHS.

Je me suis amusé à faire un /apps/busybox/bin/* par exemple.

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

Je suis vraiment curieux de savoir quel type de technologie il y a là dessous :p

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

Ben déjà parce que npm ne compile pas vraiment et que c'est compliqué de savoir ce que l'on garde ou pas, contrairement à un langage compilé qui sait tout ce qui est référencé.

Oui, c'est bien ce que je voulais souligner :

• langage interprété : beaucoup de dépendances == problématique
• langage compilé : beaucoup de dépendances == osef

cela vient aussi en doublon du gestionnaire de paquets de ta distrib.

Sauf que sous Linux, tu n'as pas 2 distributions qui fournissent les mêmes versions de la lib dont tu dépend. Ce qui rend la tâche difficile pour celui qui veut distribuer son logiciel. Plusieurs choix s'offrent à lui :

• supporter toutes les distros et chacune des versions de la lib via du code spécifique, des tests de régressions, etc…
• supporter une seule version de la lib et donc ne supporter potentiellement que peu de distro Linux
• se reposer sur des environnements type flatpak ou docker qui standardise entre plusieurs distro les libs incluses

Je te laisse deviner quel choix est le plus souvent fait.

Heureusement qu'on n'a pas attendu Rust pour faire de la compilation statique…

Vas-y, montre mois les binaires fait en C/C++ qui compilent statiquement boost, Gtk, Qt, et autres giga-lib, alors qu'ils n'utilisent que 3 fonctions de ces dernières.

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