chimrod a écrit 1102 commentaires

J'avoue, c'est le nom le plus proche que j'ai trouvé pour ce design pattern que j'utilise sans en connaître le nom.

Cela ressemble beaucoup à un trampoline, et c’est utilisé depuis au moins l’époque de Lisp. Cela permet de créer un code récursif sans surcharger la pile quand le compilateur n’est pas capable d’optimiser la récursion terminale.

Je laisse les experts préciser s’il s’agit d’un cas particulier de Continuation-passing style (désolé, je saurai pas comment le traduire en français) ou non.

C’était très intéressant. 20mn et très dense.

Très actuel aussi, j’y ai retrouvé du vécu (par exemple ma femme qui peste contre l’obligation de rénumérer les stagiaires dans le social car ça rend la recherche de stage plus difficile… ), mais aussi de l’espoir. J’aime cette question de la valeur que l’on accorde à notre travail, ça recentre le débat sur ce qui est important dans le travail !

L’Italie avait tenté l’expérience (dans les années 70 ou 80 je ne sais plus), d’évaluer le travail domestique qui n’est pas comptabilisé. L’idée étant de proposer une allocation qui serait équivalente à se travail non comptabilisé et invisible. Si l’on se remet dans le contexte de l’époque, il s’agissait surtout d’une main d’œuvre féminine, n’ayant pas forcément de ressources autres que celles du revenu de l’époux et l’idée était de donner une autonomie aux femmes.

C’est ce qui a fait capoter le projet : si l’on verse une allocation pour ce travail, on légitimise de ce fait la place de la femme à la maison, et au lieu de l’amener vers l’autonomie, on l’enferme à cette place…

Au contraire, ça casse la cohérence du langage. Le bloc de parenthèses représente une unité d’exécution du langage. (fonction arg1 arg2 …) peut se substituer à (EXPRESSION). Il faut plus les lire comme les {…} du C ou Java que les parenthèses qui listent les arguments d’une fonction.

Je voulais éviter d’avoir à débrancher les cables qui sont actuellement relié au PC client pour les basculer sur le PC hôte. S’il me faut me logguer phhysiquement, ça perd tout cet attrait :)

Si je comprend bien, tu ouvres ta session genre VNC sur SSH

Effectivement, et suite à ton retour j’ai modifié la démarche, sans succès. Il y a une option qui dans lightDM qui permet de lancer le serveur VNC. Désormais je loggue donc via le gestionnaire de connexion (ssh ne sert qu’à mettre en place le tunnel).

Pour autant, cela ne change pas le problème, l’utilisateur courant n’est pas autorisé à monter les clefs USB sans avoir à donner le mot de passe root.

Je vais regarder plus en détail, j’ai trouvé un ticket sur le github qui semble correspondre au même problème, mais dont la seule réponse est « cela vient de la couche spécifique apportée par debian ».

Merci du retour, je n’ai pas peut etre pas été assez clair.

Je parle bien de la brancher sur la machine distante. Sauf qu’il semble qu’il manque une brique dans la pile qui fait remonter le matériel jusqu’aux droits utilisateurs dans la session X. Et c’est là où je ne sais pas trop chercher (udev je connais, mais tout ce qui suis derrière m’est inconnu)

Cela fonctionne quand je lance ma session en physique (via lightDM), mais non pas quand j’ai ouvert ma session X via VNC.

Il y a très longtemps, Freenet avait un logiciel de messagerie de type forum (peut etre existe-t-il encore, je ne me souviens plus de son nom). Pour rappel, Freenet est un réseau anonyme et pair à pair, donc il n’y a pas vraiment de modération possible.

Donc, ce logiciel avait mis en place une règle de modération automatique, dans laquelle chaque personne notait les autres utilisateurs sur la base de deux critères :

1. Pertinence de ses propos (je suis d’accord avec ce qu’il dit / je ne partage pas ses opinions)
2. Pertinence de ses évaluations (je fais confiance à ses notes attribuées aux autres utilisateurs)

J’avais trouvé cette nuance intéressante : on peut etre d’accord avec une personne, mais trouver que celle-ci s’emporte trop vite dans ses propres notations et ne pas souhaiter en tenir compte, ou on peut etre en désaccord avec une personne, mais trouver que celle-ci est objective dans l’évaluation de son réseau.

Je n’ai pas assez pratiqué à l’époque pour savoir si cela fonctionnait sur l’ensemble des forums, mais j’avais trouvé que cette séparation permettait de nuancer les opinions. Ça oblige en tout cas à aller un peu plus loin que seulement "J’aime/J’aime pas".

De mon côté j’ai découpé ma clef en une série de qrcode et imprimé les feuilles. C’est ce qui me semble demander le moins de manipulations pour restaurer le fichier.

Je confirme :) si l’on a pas l’info avant, on ne la trouve pas sur le site.

Ton journal m’a bien aidé aussi pour faire la part des choses. Je n’y avais rien compris sur le moment, mais l’avais relu avant de sauter le pas pour acheter ma 1ère clef !

J’ai l’impression que la solo key n’est pas une clef GPG (du moins ça n’est pas spécifié dans les specs). Elle ne serait donc pas compatible du tout.

Je trouve difficile de mettre un pied dans les jetons de sécurité vu la pléthore d’information diffusée sur les différents vendeur : FIDO, U2F, GPG… la plupart des tokens promettant à chaque fois le meilleur de la sécurité, et l’on ne sais pas vraiment à l’avance quel besoin nous avons tant que nous n’avons pas la clef en main pour tester ce que l’on peut faire avec.

Pour ma part, la clef GPG me suffit. Le NFC vient en bonus (afin d’avoir les mots de passes sur le téléphone) et j’attend que le firmware de la Nitrokey3 soit mis à jour pour en profiter pleinement.

À noter que le modèle Pro n’est pas vraiment nécessaire ; c’est la passerelle GPG qui fait tout. Du coup, il est possible d’utiliser une Nitrokey Start (moins cher) ou meme une GPG card !

C’est pris en compte mais non documenté (seulement commenté) : dans la version en console, il faut valider une ligne vide, l’application fera une nouvelle proposition, dans la version en ligne, il y a un bouton pour "recharger" la proposition.

Par contre il y a un cas qui n’était pas pris en compte à l’époque et que j’ai rencontré avec sutom : si le mot contient une répétition de lettres, il se peut que le moteur nous indique que la 1ère lettre est bien placé, mais n’indique pas que la seconde soit mal placée. Si l’on recopie bêtement les infos remontées, l’application va charger deux règles incompatibles (lettre présente + lettre absente) ce qui va mettre fin au processus.

Et comme chaque nouveauté attire automatiquement les gens qui ne pensent qu’à tricher, mon outil qui permet de trouver la solution pour les différentes grilles est désormais disponible dans une page web !

• Le dépôt pas Github du code source

D’abord un grand merci à aux contributrices et contributeurs qui ont participé à l’écriture, et merci également d’avoir pris le temps pour ton commentaire !

Cette dépêche est restée longtemps dans les tuyaux de la rédaction avant d’être validée, et j’ai été relancé plusieurs fois par la team qui s’inquiétait de la voir stagner… Tout d’abord par faute de temps de ma part (l’excuse facile), mais aussi parce que cette histoire est malheureusement chargée d’affect. La lecture de fils de discussions tel que Is rescript damaging Ocaml ecosystem? m’a touché et a rendu l’écriture d’une synthèse neutre vraiment difficile. Et la seule solution pour synthétiser ça et de marcher sur des œufs dans ce que l’on écrit… ce qui demande encore plus de temps au point d’en casser l’élan.

Il manque selon moi tout un pan qui aborderai la question de la réception du langage auprès des utilisateurs, mais je n’ai pas réussi à l’écrire. Pour ceux qui sont intéressé pourront trouver d’autres échanges dans A short history of ReScript (BuckleScript) (qui peut se lire comme un droit de réponse suite aux accusations) et vous faire votre propre avis !

J’avoue ne pas avoir preté vraiment attention à la beauté des lignes de code, elles étaient davantage là pour appuyer mon propos !

Je m’en sors mieux en OCaml (solution trouvée au quatrième coup avec le mot du jour)

Notes en vrac :

• ici, je me suis contenté d’appliquer un algorithme de type arbre de décision, afin de choisir quel est l’élément le plus pertinent à retenir.
• avec le français, cela aurait été plus compliqué, à cause des accents dans les mots qu’il faut transformer pour uniformiser les lettres
• enfin, j’ai commencé l’analyse en partant du dictionnaire complet, cela aurait été plus efficace si j’avais dès le début choisi les mots de 5 lettres pour identifier les fréquences.

Note : je me base sur la liste des mots présents dans le dictionnaire américain de Debian, accessible via le paquet wamerican et listé dans le fichier /usr/share/dict/american-english

Il est également possible de choisir ses mots en fonction de la quantité d’information contenus dans chacun d’eux. Par exemple, le dictionnaire anglais contient 102.774 entrées :

$ wc -l american-english 
102774 american-english

et l’on se rend compte que le a est présent dans 52% d’entre eux :

$ grep -i "a" american-english  | wc -l
53715

Si l’on choisi un mot avec un a, sans meme savoir quel sera le résultat, nous éliminons la moitié des mots possibles. Comme nous avons 5 lettres possibles, autant choisir celles qui permettent de discréminer un max de résultat. Et c’est parti pour une plongée en bash pour trouver la solution !

$ grep -o . <<< "abcdefghijklmnopqrstuvwxyz"| while read letter; do echo $letter $(grep -i $letter american-english | wc -l); done
a 53715
…
e 65692
…
n 47826
…
r 50018
…
t 44232

$ grep "^.....$"  american-english | grep -i "a" | grep -i "r" | grep -i "n" | grep -i "t"
Brant
Grant
Rutan
Trina
grant
rants
train

essayons train avec le mot du jour : le a est reconnu, mais pas les autres lettres ! Parfait, il ne reste que 878 mots présents :

$ grep "^.....$"  american-english | grep -i "a" | grep -iv "[trin]" > /tmp/iter1
$ wc -l /tmp/iter1
878

On recommence notre itération :

$ grep -o . <<< "abcdefghijklmnopqrstuvwxyz"| while read letter; do echo $letter $(grep -i $letter /tmp/iter1 | wc -l); done
b 124
c 169
d 181
e 370
h 135
l 342
m 175
o 137
p 139
s 504
y 139

$ grep "^.....$"  american-english | grep -i "s" | grep -i "l" | grep -i "e" | grep -i "d" | grep -i "m"
melds

31 mots restants ! On s’approche !

$ grep "^.....$"  /tmp/iter1 | grep -i "a" | grep -i "e" | grep -iv "[trinmlds]" > /tmp/iter2
$ wc -l /tmp/iter2
31 /tmp/iter2
$ grep -o . <<< "abcdefghijklmnopqrstuvwxyz"| while read letter; do echo $letter $(grep -i $letter /tmp/iter2 | wc -l); done
b 6
c 11
f 2
g 8
h 9
k 5
o 2
p 9
q 2
u 8
v 6
w 3
x 1
y 4
z 1

$ grep "^.....$"  /tmp/iter2 | grep -i "c" | grep -i "h" | grep -i "p"
cheap
peach

Prenons-en un des deux, et faisant notre test : plus que 14 possibilité, et il reste 3 coups !

$ grep "^.....$"  /tmp/iter1 | grep -i "a" | grep -i "e" | grep -iv "[trinmldspch]" > /tmp/iter3
$ wc -l /tmp/iter3
14 /tmp/iter3

$ grep -o . <<< "abcdefghijklmnopqrstuvwxyz"| while read letter; do echo $letter $(grep -i $letter /tmp/iter3 | wc -l); done | grep -v [01]
b 4
g 5
k 4
o 2
q 2
u 6
v 4
w 3

$ grep "^.....$"  /tmp/iter3 | grep -i "u" 
…
quake

Plus que 5 mots dans la liste, et encore deux coup restants ! Je pense qu’on est bon !

$ grep "^.....$"  /tmp/iter3 | grep -i "a" | grep -i "e" | grep -iv "[trinmldspchquk]"
abbey
above
agave
gaffe
weave

En fait, si l’on tient compte des informations sur le placement des lettres, on sait à ce moment là que le e n’est pas en dernière position, et il ne reste plus qu’une seule possibilité.

Y a-t-il un volontaire pour mettre tout ça dans un petit scritp interractif qui s’occupe de nous trouver la solution ? :)

J’ai également ce casque qui m’est fourni par le boulot ; il fonctionne effectivement en deux modes :

• par la clef USB qui est fournie, dans ce cas la connexion est automatique
• par bluetooth, ce qui permet d’appairer un 2nd appareil

Tout d’abord, il faut savoir qu’en branchant la clef USB sur le pc linux, le casque est reconnu de suite. Cela vaut peut etre le coup d’acheter un adaptateur USB-C / USB-A plutot que d’acheter un casque neuf.

Ensuite, je n’ai eu aucun problème à connecter le casque en bluetooth : j’utile le couple blueman / pulseaudio et cela fonctionne sans problème. Il faudrait savoir ce que tu utilises pour que nous puissions t’aider !

Si c’est pour un exercice, on ne va pas donner la réponse (bien que SoooLooo ait compris le principe) :)

Par contre, je pense qu’il y a un soucis car là, l’ennoncé n’a pas de sens… Hypothèse, le programme affiche le texte puis l’efface très vite, sauf que pour une raison ou une autre, la commande d’effacement n’est pas interprétée par le terminal -> tester avec un autre terminal ?

Lorsque je lance simplement le binaire j'ai un message qui me dit que j'ai échoué bien sur.

De ce que je comprend de ton ennoncé, tu ne devrais pas avoir d’erreur en lançant le binaire. Peux-tu copier la sortie de ton terminal quand tu lances la commandes ?

Et beaucoup d'encres ont tendance a s'estomper au bout de quelques années.

C’est assez récent ça. L’encre métallo-gallique qui a dominé l’écriture pendant presque mille ans pose des problème inverses ! Elle fini au contraire par ronger le papier !

En fait, GPG fait partie des applications qui "fonctionnent tout simplement" et qui finissent par s’oublier :

• je n’utilise pas GPG directement, mais mes mots de passes sont chiffrés avec GPG
• je n’utilise pas GPG, mais mes sauvegardes sont réalisées avec duplicity, qui utilise GPG

J’aime déléguer la partie chiffrement à GPG, et je privilégie des applications qui font la séparation dans les deux opérations. Du coup, je n’utilise jamais GPG, et il est présent dans mon quotidien !

Effectivement je n’avais pas ce cas en tete. Merci d’avoir précisé !

C’est amusant de voir que le procès ne porte pas sur du code GPL qui aurait été intégré dans une application propriétaire, mais sur un code sous licence GPL qui a été distribué illégalement.

Même si ça peut sembler contradictoire, voici ce que je comprend de l’article : nous avons le droit de diffuser un code sous licence GPL d’une application dont nous disposons (liberté de redistribuer des copies), mais il faut pour cela que l’auteur nous ait autorisé à disposer de cette application. C’est implicite quand nous installons firefox ou debian, mais cette étape est importante.

Ici, les développeurs auraient "volé" un code GPL a leur employeur, et ne sont donc pas entrés dans le process contractuel qui les autorise à redistribuer ce code. On peut imaginer que l’employeur vend son code et a tout intérêt à en conserver la distribution (c’est quand même un cas qui doit arriver assez rarement)

Si on lit entre les lignes, le fait qu’il s’agisse de deux ex-employés semble indiquer un autre conflit dans l’histoire, mais c’est une reconnaissance du cadre de la licence.