Page de recherche dans les notes du jardin numérique de Stéphane Klein

Commandes valables sous Fedora mais aussi plus généralement sous Linux.

Affiche la configuration DNS actuelle :

$ resolvectl status
Global
         Protocols: LLMNR=resolve -mDNS -DNSOverTLS DNSSEC=no/unsupported
  resolv.conf mode: stub
Current DNS Server: 127.0.0.1:5300
       DNS Servers: 127.0.0.1:5300
        DNS Domain: ~test

Link 2 (wlp1s0)
    Current Scopes: DNS LLMNR/IPv4 LLMNR/IPv6
         Protocols: +DefaultRoute LLMNR=resolve -mDNS -DNSOverTLS DNSSEC=no/unsupported
Current DNS Server: 192.168.31.1
       DNS Servers: 192.168.31.1

Intéroge directement un serveur DNS :

$ dig @127.0.0.1 -p 5300 server2.vagrant.test +short
192.168.56.21

Résolution d'un hostname avec resolvectl :

$ resolvectl query server2.vagrant.test
server2.vagrant.test: 192.168.56.23

-- Information acquired via protocol DNS in 4.2ms.
-- Data is authenticated: no; Data was acquired via local or encrypted transport: no
-- Data from: network

La commande suivante affiche toutes la configuration de resolved.conf :

$ systemd-analyze cat-config systemd/resolved.conf

Voir aussi Facets.

https://danluu.com/monorepo/

https://en.wikipedia.org/wiki/Advanced_Vector_Extensions

https://osf.io/gxu3a?view_only=11c9e93011df4865951f2056a64f5938

Article Wikipedia : https://fr.wikipedia.org/wiki/Ada_Colau

Dépôt GitHub : https://github.com/AdguardTeam/AdGuardHome

Logiciel de personal finance manager.

Site officiel : https://actualbudget.org/

https://www.w3.org/TR/activitypub/

Article Wikipedia : https://fr.wikipedia.org/wiki/Accel_Partners

Accel est une société de Capital risque.

https://www.youtube.com/@AbsolVideos

J'ai beaucoup aimé son interview de Thibaut Giraud : Monsieur Phi (Thibaut Giraud) en 12 questions

APScheduler est un job scheduler écrit en Python.

Dépôt GitHub : https://github.com/agronholm/apscheduler

Kong
Hasura

XDNA est l'architecture des puces NPU de AMD.

Aussi nommé Ryzen AI.

D'après ce que j'ai compris, Ryzen AI est l'équivalent de Intel AI Boost.

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

https://fr.wikipedia.org/wiki/Test_A/B

En janvier 2024, j'ai acheté une paire de chaussure de la marque Ector Sneakers.

Le modèle : Chaussure Ector Cuir Basse 212 Cuir à 189 €.

Voici ce qui a motivé mon choix :

Dessinés et entièrement fabriquées dans notre atelier, à Romans-sur-Isère (26)

Slack
Mattermost ❤️
Zulip ❤️❤️

Typesense - voir Typesense comparison with Alternatives
Meilisearch
Elasticsearch
Sonic
pg_search

SaaS :

Algolia

Liste de Revue scientifique, Revue avec évaluation par les pairs, archive ouverte de prépublications… :

Ma traduction de l'article The Platinum Rule de Shawn Wang (dit swyx) avec quelques modifications et ajouts qui me permettent — peux-être à vous aussi — de mieux comprendre l'article.

La traduction commence ici ⬇️

Vous avez entendu parler de la la règle d'or : « Traiter les autres comme on voudrait être traité » ou « Ne fais pas aux autres ce que tu ne voudrais pas qu'on te fasse ».

Je pense qu'elle est incomplète. Je pense que les gens fonctionnent en réalité selon une norme plus élevée. Je propose la Règle de Platine : Traiter les autres comme ILS veulent être traités.

La Règle de Platine

Pour comprendre comment j'en suis arrivé là, il faut savoir que j'ai des traits de personnalité particuliers qui rendent la règle de Platine pertinente pour moi. Je préfère la franchise. Mon seuil pour considérer quelque chose comme "terminé" est plus bas que le vôtre. J'aime les personnes conscientes d'elles-mêmes et l'humour. Je préfère l'amour vache.

Cela signifie que je préfère livrer une chose imparfaite et itérer plutôt que de mettre de l'ordre dans mes affaires. Cela signifie que je dis les choses sans les adoucir pour les rendre plus agréables à entendre. Cela signifie que je me moque de moi-même et de tout ce à quoi je m'identifie fortement, ce qui peut parfois inclure les personnes avec lesquelles je travaille. Cela signifie que je suis souvent trop dur à l'égard de quelque chose qui me tient à cœur.

En lisant ce paragraphe — ci-dessus — certains d'entre vous ont sans doute pensée « ok, et alors ? » sans voir ce qu'il ne va pas dans ce comportement. Voici ce qui ne va pas.

Pourquoi la règle d'or pose problème ?

Imaginons que nous simplifions les préférences humaines en deux catégories : « plus particulières » et « moins particulières ».
Et supposons que les interactions humaines se résument à deux aspects : « comment vous traitez les autres » et « comment vous voulez être traité ».
La règle d'or — traiter les autres comme vous voulez être traité — suggère que les personnes plus particulières devraient traiter les autres selon leurs propres standards élevés — peu importe comment vous définissez ces standards.
C'est une bonne chose car cela rend les personnes particulières très prévenantes. Cependant, si les personnes moins particulières appliquaient cette règle et traitaient les autres comme elles veulent être traitées, elles paraîtraient vraiment désagréables aux yeux des personnes plus particulières, qui ne pourraient pas travailler avec elles.

Par exemple, imaginez quelqu'un qui aime que tout soit toujours bien rangé et organisé. Cette personne, très particulière sur la propreté, pourrait être très attentive à maintenir un environnement propre et ordonné pour tout le monde.
Cependant, si une personne qui ne se soucie pas autant du rangement appliquait la règle d'or et traitait les autres comme elle veut être traitée (c'est-à-dire sans se soucier de l'ordre), elle semblerait désordonnée et négligente aux yeux de la personne qui apprécie l'ordre. Cela créerait des tensions, car la personne qui aime l'ordre se sentirait frustrée et incapable de travailler efficacement avec l'autre.

Dans cet exemple, la règle d'or ne fonctionne pas bien, la personne qui aime l'ordre traite l'autre comme elle aimerait être traité, mais son souhaite ne se réalise pas !

Les nombres relatifs de personnes plus particulières et de personnes moins particulières n'ont pas d'importance - si ces personnes doivent travailler ensemble, elles doivent coexister dans le cadre d'un contrat social différent.

La règle de platine ?

Pour essayer de résoudre ce problème, je propose que la règle de platine soit ce contrat : traiter les autres comme ils veulent être traités.

D'un côté, cela semble relever de la plus simple politesse : bien sûr, il faut tenir compte des sentiments des autres. Utilisez leurs pronoms. Respecter leur autonomie et leur liberté.

D'un autre côté, cela peut sembler beaucoup trop accommodant - que faire si les gens abusent du système et veulent être traités de manière déraisonnable ? Il y a deux poids, deux mesures partout lorsqu'il s'agit d'intérêt personnel. Il faut bien tracer une ligne quelque part.

Elle est imparfaite, mais il est probable que le bon équilibre entre vous et moi se situe quelque part entre la Règle d'Or (empathie extrêmement centrée sur soi) et la Règle de Platine (accommodement extrêmement centré sur les autres).

La Règle d'Argent

En réfléchissant à cela dans un avion, j'ai également pensé à une belle conclusion pour ce message. Si la règle de platine est "meilleure" que la règle d'or, à quoi ressemblerait une règle d'argent ? (j'aime étendre les idées comme celle-ci, j'ai pris cela de Brian Chesky).

Une règle d'argent serait quelque chose qui est souvent considéré comme secondaire par rapport aux autres, mais qui reste important et précieux. Et sous la forme suivante : « Traitez x comme X veut être traité ».

Voici ma proposition pour une règle d'argent : Traitez-vous comme vous traitez les autres. Une belle inversion de la règle d'or.

Le framework des quatre tendances de Gretchen Rubin divise les gens en fonction de la façon dont ils répondent aux attentes intérieures et extérieures, ce qui semble tout à fait approprié à ce sujet. Les profils "Questioners" ont le plus besoin de la Règle de Platine. Mais les "Obligers" ont probablement le plus besoin de la Règle d'Argent.

Le souci de soi ne doit pas céder la place au sacrifice de soi.

Ce projet a été initialement commencé dans une issue le 8 mars 2024.

Sur un modèle de données SQL qui implémente un système de tags comme celui décrit ici, je souhaite pouvoir appliquer des filtres qui ressemblent à ceci :

a. tag_a or tag_b
b. tag_a and tag_b
c. tag_a and (not tag_b)
d. (tag_a and tag_b) or (tag_c and tag_d)
...

Voici à quels filtres (where) SQL peuvent ressembler ces filtres :

a. WHERE contacts.tags && (SELECT ARRAY_AGG(id) FROM contact_tags WHERE name = ANY(ARRAY['tag_a', 'tag_b'])
b. WHERE contacts.tags @> (SELECT ARRAY_AGG(id) FROM contact_tags WHERE name = ANY(ARRAY['tag_a', 'tag_b'])
c.

WHERE
  (contacts.tags && (SELECT ARRAY_AGG(id) FROM contact_tags WHERE name = ANY(ARRAY['tag_a'])) AND
  (NOT (contacts.tags && (SELECT ARRAY_AGG(id) FROM contact_tags WHERE name = ANY(ARRAY['tag_a'])))

d.

WHERE
  (contacts.tags && (SELECT ARRAY_AGG(id) FROM contact_tags WHERE name = ANY(ARRAY['tag_a', 'tag_b'])) OR
  (contacts.tags && (SELECT ARRAY_AGG(id) FROM contact_tags WHERE name = ANY(ARRAY['tag_c', 'tag_d']))

Questions que je me pose :

Existe-t-il un "langage" de query de tag sur lequel je pourrais me baser ?
Existe-t-il un parser qui me permettrait de transformer ma query de filtre en SQL ?

Todo :

[ ] Essayer de dresser une liste de langages de query, quelques idées où chercher :
- [ ] Des moteurs de recherche :
  - [x] Google
  - [x] Duckduckgo
  - [ ] Algolia
  - [x] Melisearch
  - [ ] …
- [ ] Prometheus
- [x] Loki
- [ ] GitLab
- [x] GitHub
- [x] Jira
- [x] Lobster
[ ] Poster un billet de recherche sur
- [x] Subreddit Postgres => https://old.reddit.com/r/PostgreSQL/comments/1bb6qvj/need_advice_on_how_to_convert_a_filter_string/?
- [x] Subreddit Javascript => https://old.reddit.com/r/javascript/comments/1bb8rr3/askjs_need_advice_on_how_to_convert_a_filter/
- [ ] Stackoverflow
- [ ] ~~Subreddit programming~~
  - [ ] AskProgramming
[x] Publier sur sklein.xyz :
- [x] En Français : https://sklein.xyz/fr/posts/2024-03-10_demande-de-conseils-pour-convertir-une-query-filter-string-sur-des-tags-en-sql/
- [x] En Anglais : https://sklein.xyz/en/posts/2024-03-10_need-advice-on-how-to-convert-a-filter-string-query-on-tags-in-sql/

Ce projet a été initialement commencé dans une issue, le 10 janvier 2024.

Quel est l'objectif de ce projet ?

Je souhaite mettre en pratique l'extension PostgreSQL fuzzystrmatch pour implémenter une fonctionnaltié Fuzzy Search.

Je souhaite que cette implémentation permette :

de trouver les éléments à partir d'erreurs d'insertion, de suppression et de substitution (voir paragraphe "Distances entre mots") ;
de trouver les éléments même si des lettres ont été transposées, par exemple, cout → touc est une transposition.

Repository de ce projet :

postgresql-fuzzysearch-poc (pas encore créé)

Ressources :

fuzzystrmatch
- Code source de l'extension fuzzystrmatch : https://git.postgresql.org/gitweb/?p=postgresql.git;a=tree;f=contrib/fuzzystrmatch;h=89b42b78852929839c19f07a98c86f29521bd8b7;hb=HEAD
Articles Wikipedia :
Résultat de la recherche "Fuzzy" sur Subreddit PostgreSQL
Billet de blog : PostgreSQL Fuzzy Text Search: Not so fuzzy to fuzziest

Ce projet a été initialement commencé dans une issue, le 16 novembre 2023.

Quel est l'objectif de ce projet ?

Je souhaite implémenter et publier un POC de https://automerge.org.

Ce que je souhaite réaliser dans ce POC :

Une implémentation du serveur
- En Javascript
- Une autre implémentation en Golang
Un client Javascript
- User story
  - Sur le client A, un user saisie "item 1", celui-ci est ajouté dans une liste ordonné par timestamp
  - "item 1" est affiché en temps réel sur client B
  - Le client A passe offline
  - Sur le client B, un user saisie "item 2"
  - Sur le client A, un user saisie "item 3"
  - Le client A passe online
  - Le client A se synchronise automatiquement et contient la liste "item 1", "item 2", "item 3"

Repository de ce projet :

automerge-playground

Ressources :

https://github.com/automerge/automerge-go
- https://github.com/astromechza/automerge-experiments/

Ce projet a été initialement commencé dans une issue le 9 août 2023.

L'objectif de ce projet est de créer un simulateur de manque à gagner suite à une rupture conventionnelle, un licenciement économique ou un licenciement simple.

Le projet est déployé sur : https://comparateur-rupture-conventionnelle-cdi.sklein.xyz/

Repository GitHub du projet : https://github.com/stephane-klein/comparateur-rupture-conventionnelle-cdi-france

Ressources :

Tâches restantes : https://github.com/stephane-klein/comparateur-rupture-conventionnelle-cdi-france/issues

Date de la création de cette note : mercredi 3 juillet 2024.

Quel est l'objectif de ce projet ?

Je souhaite implémenter un éditeur Markdown dans une application web frontend utilisant Svelte. Cet éditeur doit supporter la fonctionnalité de conceal en utilisant la librairie CodeMirror.

Plus précisément, mon objectif est de reproduire le comportement des "liens internes avec texte d'affichage" de Obsidian. Cela signifie que lorsque le curseur de l'éditeur n'est pas positionné sur la ligne contenant [[foobar|title]], seul title est affiché avec un style spécifique. Lorsque le curseur se trouve sur la ligne de [[foobar|title]], alors [[foobar|title]] est affiché intégralement.

Ce projet est en lien avec Projet 1 - "CodeMirror, autocomplétion, Svelte".

Pourquoi je souhaite réaliser ce projet ?

J'ai besoin d'implémenter une fonctionnalité Conceal dans l'application Value Props.

Repository de ce projet :

https://github.com/stephane-klein/svelte-codemirror-conceal-poc

Date de la création de cette note : 2024-06-05.

Ce projet est terminé : voir 2024-07-06_1116.

Quel est l'objectif de ce projet ?

Bien que j'aie beaucoup travaillé de décembre 2023 janvier 2024 sur le projet Implémenter un POC de pgBackRest, je souhaite mettre à jour et améliorer le repository restic-pg_dump-docker.

Quelques tâches à réaliser :

[x] Mettre à jour tous les composants ;
[x] Publier le Dockerfile de stephaneklein/restic-backup-docker ;
[ ] Réaliser et publier un screencast ;
[x] Améliorer le README.md.

Pourquoi je souhaite réaliser ce projet ?

Pourquoi continuer ce projet alors que j'ai travaillé sur pgBackRest qui semble bien mieux ?

Pour plusieurs raisons :

Je ne peux pas installer pgBackRest dans un « sidecar container Docker » — en tout cas, je n'ai pas trouvé comment réaliser cela 🤷‍♂️. Je dois utiliser un container Docker PostgreSQL qui intègre pgBackRest.
Pour le moment, je ne comprends pas très bien la taille consommée par les "WAL segments" sauvegardés dans les buckets.
Pour le moment, je ne sais pas combien de temps prend la restauration d'un backup d'une base de données d'une taille supérieure à un test. Par exemple, combien de temps prend la restauration d'une base de données de 100 Mo 🤔.
Je ne suis pas rassuré de devoir lancer un cron — supercronic — lancé par tini

Bien que pgBackRest permette un backup en temps "réel" et est sans doute plus rapide que "ma" méthode "restic-pg_dump", pour toutes les raisons listée ci-dessus, je pense que la méthode "restic-pg_dump" est moins complexe à mettre en place et à utiliser.

#JeMeDemande si la fonctionnalité "incremental backups" la version 17 de PostgreSQL sera une solution plus pratique que pgBackRest et la méthode "restic-pg_dump" 🤔.

Repository de ce projet :

https://github.com/stephane-klein/restic-pg_dump-docker

Je vais travailler dans la branche nommée june-2024-working-session

Date de la création de cette note : 2024-05-17 .

Quel est l'objectif de ce projet ?

Je souhaite essayer de réaliser avec Svelte Flow, une page web qui permet de :

Glisser / déposer 2 types d'objets vers un flow container.
Permettre de saisir du texte dans ces deux types d'objets.
Permettre de relier les objets de type 1 vers ceux de type 2 et inversement.
Interdire les liaisons entre des objets de même type.

Idéalement j'aimerais que les objets soient placés "harmonieusement" entre eux dans le flow container.

Pourquoi je souhaite réaliser ce projet ?

Je besoin de créer ce type d'éditeur dans mon projet Value Props

Repository de ce projet :

https://github.com/stephane-klein/svelteflow-playground

Ressources :

Documentation de SvelteFlow : https://svelteflow.dev/learn

Résultat

2024-05-22 : je déclare le projet terminé.

Voir détail dans cette note : 2024-05-22_1033