David Delassus a écrit 709 commentaires

J'avais fait cette lib pour répondre à un besoin personnel, et j'ai décidé de la publier même non finie au lieu de la laisser pourrir sur mon pc.

Pas mal de codebases n'autorisent pas C++20

C'est réellement pas mon problème. C++20 et C++23 apportent beaucoup de fonctionnalités très intéressante, je vois pas pourquoi je m'en priverais.

STL utilisée, et pour de mauvaises raisons en plus.

Tu as réussi a inférer mes raisons simplement en lisant le code ?

La raison c'est que je ne voulais aucune dépendance. Le langage de base me fournit tout ce dont j'ai besoin, je ne vois pas pourquoi j'irais chercher ailleurs.

Ce code utilise auto pour tout et n'importe quoi.

Oui, parce que l'inférence de type c'est bien.

Il y a des shared_ptr qui devraient vraiment être des unique_ptr, également.

Ca c'est le premier point ou je suis d'accord. Mais j'ai eu des problèmes avec unique_ptr:

• std::initializer_list ne peut pas contenir de unique_ptr car quand on itère dessus, cela fait une copie
• je ne peux pas initialiser un std::vector de unique_ptr pour la même raison, car le constructeur utilise std::initializer_list

Cela m'obligerait donc a créer le std::vector, faire des push_back avec std::move, et ensuite std::move le std::vector au constructeur qui en a besoin, chiant.

Alors oui, j'ai pris l'option de facilité, utiliser shared_ptr, ça marche bien.

aucun outil.

Libre à toi de faire une PR, c'est ça aussi l'opensource.

Et pour finir :

Pour moi, cette lib n'a que peu d'intérêt

C'est bien, personne ne t'oblige à l'utiliser.

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

Ah oui je me suis peut être mal exprimé.

J'ai initialement choisi Hugo, mais parce que je ne pouvais pas lui filer ma propre grammaire TexMate pour coloriser le code Letlang, j'ai d'abord utilisé Shiki côté client (qui donc parse le code et ajoute le style CSS côté client), pour ensuite faire Gin qui utilise Shiki directement côté "serveur".

Quand je dis "la coloration se fait à la compilation" je parle de parser le bloc de code pour le transformer en <pre><code>...</code></pre> avec plein de <span style="...">...</span>. Bien évidemment le rendu final est fait par le navigateur.

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

En plus l'article est pas complet :(

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

Pas sur d'avoir compris la question, avec Gin, je fais la colorisation syntaxique à la compilation justement, la ou avec Hugo je devais le faire côté client.

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

C'est pas un tracker, c'est un token d'authent pour bypasser le paywall pour ceux qui ne sont pas membre sur Medium.

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

Puisqu'on fork les outils d'Hashicorp avec des noms de plats japonais, je propose de forker Consul avec le nom "Openigiri".

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

Et pourquoi appeler ça wheel ?

Dans l'espoir de pas la réinventer (la roue) :)

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

C'est vraiment de la mauvaise foi ça. Surtout après lecture des réponses suivantes.

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

On moinsse l'humour et on plussoie la condescendance maintenant sur LinuxFR ?

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

En vertu de la bonne foie, ou dans cette phrase est il mentionné que Napoléon a été pillé ?

Il a été offert ok, mais bel est bien déplacé jusque Paris. Ou est l'énormité ici ? Ou est la justification pour tant d'aggressivité envers un commentaire explicitement humoristique ?

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

Ils ne vont pas remplacer les objets qu'ils ont volé dans les autres pays

Pourquoi les pyramides sont en Egypte ?

…

…

…

Parce qu'il n'y a pas la place au British Museum.

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

On va dire que c'est permis par CPython :

• la fonction decompile(x) de ponyorm, notamment la ligne : codeobject = x.gi_frame.f_code
• le module opcode de CPython
• le module ast de Python

On a même le module dis qui ne semble pas utilisé par contre.

En regardant tout ça d'un peu plus près, cela me semble très spécifique à CPython. Quid de PyPy, Jython (JVM), et autres implémentations ?

Je n'irai pas jusqu'à dire que c'est un gros hack, car cela exploite les détails d'implémentations "interne" de CPython, mais je n'irai pas jusqu'à dire que c'est "prévu". C'est "permis" me semble un bon compromis.

En tout cas, si je comprends bien le code, il vont en chier pour assurer la compatibilité lors des montées de versions de l'implémentation, car rien ne garantie qu'elle ne bougera pas.

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

c for c in ... c'est une "expression générateur" en Python :

>>> (i for i in [])
<generator object <genexpr> at 0x…>

Donc select(c for c in ...) passe un objet de type générateur à la fonction select().

En survolant le code source, ils décompilent le code du générateur (la stdlib de Python fournit les outils pour faire cela) et ensuite réécrit l'AST pour recompiler ça en SQL.

Le générateur n'est jamais exécuté directement du coup.

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

Et quelle est la différence entre panic/recover et des exceptions avec try/catch ?

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

Non, c'est une interface

My bad, je le savais en plus, mais j'ai vu tellement de codebases Go ou c'était juste des strings que j'ai fait un raccourci un peu trop rapide.

Est-ce que faire un unwrap, ça compte vraiment comme traiter l'erreur ?

Oui car unwrap sur un Result::Err(E) ça panic!. Alors que ne pas faire de if err != nil en Go, le programme continu comme si de rien n'était.

Dans les deux cas, on ignore explicitement l'erreur sans la traiter.

Ben non :

func foo() (something, error) {
  a, err := bar()
  // pas de if err != nil

  // beaucoup de code
}

La c'est pas explicite du tout.

Alors qu'en Rust :

if let Ok(a) = bar() {
  // ...
}

// ou

match bar() {
  Ok(a) => { /* ... */ },
  _ => {}
}

En gros :

• en Go, tu dois ajouter du code pour traiter l'erreur
• en Rust, tu dois ajouter du code pour ignorer l'erreur

Perso, je trouve la gestion des erreurs en Go assez bof, mais pas atroce non plus.

Chacun ses goûts. Pour ma part, je défend l'idée que "fournir un type/interface 'error'" ce n'est pas de la gestion d'erreur.

En fait, je ne vois même pas de différence avec le C dans ce cas là :

int foo(); // retourne 0 en cas de succès, -1 en cas d'erreur

Au moins, la GLib (pas gnu libc, mais bien GLib de GTK), on a GError et compagnie :

bool foo(GError **err);
// true en cas de succès, false en cas d'erreur
// si erreur, et que err != NULL, on propage l'erreur dans *err

Verbeux, peu pratique, mais déjà un peu mieux qu'un int.

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

Je trouve la gestion d'erreur de Go atroce, pour ne pas dire inexistante.

Le langage ne te force pas à la traiter, rien ne t'empêche d'écrire :

res, _ := foo()

Il peut quand même y avoir des données dans le résultat, même si err est nil :

func foo() (int, error) {
  return 42, errors.New("oops")
}

Dans ce cas, on fait quoi de res ?

Il faut utiliser des modules tiers pour garder les informations qu'une stacktrace d'exception a par défaut, car :

res, err := foo()
if err != nil {
  return whatever, err
}

Ici on pert complètement l'information, la bonne pratique c'est d'encapsuler l'erreur dans une nouvelle, en utilisant par exemple le module xerrors.

Le type error est concrètement juste une chaîne de caractères, sans module tiers tel que xerrors ou autre, impossible de déterminer le type de l'erreur, alors qu'avec une exception, on peut au moins faire du pattern matching sur son type.

---

Au final, je préfère un type monadique, comme std::expected<T, E> en C++ ou Result<T, E> en Rust.

Ici:

• on a bien une valeur OU une erreur
• on est obligé de traiter l'erreur
• on peut faire du pattern matching sur le type de l'erreur et sa valeur
• on sait quel type d'erreur une fonction peut retourner

Les exceptions pourraient être du sucre syntaxique pour un tel type monadique. D'ailleurs, l'opérateur ? en Rust ressemble beaucoup à ça :

fn foo() -> Result<T, E1> {
  // ...
}

fn bar() -> Result<T, E2> {
  let val = foo()?;
  // si foo retourne Result::Err(E1),
  // alors bar retourne Result::Err(E2) a condition que E2 implémente From<E1>
  // si l'implémentation n'est pas trouvée --> erreur de compilation
}

C'est tout de suite plus propre.

---

TL;DR: Les gens qui vantent les mérites de la gestion d'erreur en Go, je les comprends pas :(

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

J'adore le titre de l'article :

Django, HTMX and Alpine.js: Modern websites, JavaScript optional

Comme si HTMX et Alpine.JS n'avaient pas besoin de JS.

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

Pour info, le module Python tkinter est inclus dans la librairie standard.

Quand j'ai besoin d'une GUI pour un script Python, c'est vers ce dernier que je m'oriente :)

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

C'est pour ça que je kiffe le Semantic Versionning.

Sinon, 10 ans, pour un dev JS c'est du LTS :)

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

Il y a 10 ans, on entendait les gens dire qu'il fallait développer pour GTK2 et pas GTK3.

Il y a 20 ans, on entendait les gens dire qu'il fallait développer pour GTK1 et pas GTK2.

Dans 10 ans, on entendra les gens dire qu'il faut développer pour GTK4 et pas GTK5.

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

vi était considéré comme raisonnablement hardcore (le top du hardcore, c'était d'utiliser ed)

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

Vim est vraiment un bel outil, même si je ne l'utilise plus, c'est selon moi un monument du logiciel libre.

Il en a inspiré beaucoup, dont :

• http://vimperator.org/ (interface Vim pour Firefox)
• le mode Vim dans Sublime Text, VS Code, et bien d'autres éditeurs de texte

D'ailleurs, durant mon adolescence, j'avais comme projet un navigateur internet basé sur Webkit avec l'interface de vimperator --> https://github.com/linkdd/cream-browser

Et j'en avais même parlé ici : https://linuxfr.org/tags/creambrowser/public

Vim a eu un gros impact sur ma manière d'aborder l'édition de texte, encore aujourd'hui, sur VS Code, je refactor mon code à coup de Ctrl+Shift+H et de regex (ce qu'il y a de plus proche de :s). Jamais j'abandonnerai le comfort d'un éditeur avec le multi-curseur au minimum.

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

il ne fait que montrer que toi et/ou ton collègue ne connaissent pas les IDE graphiques

On s'en cogne non ?

On peut pas laisser les gens utiliser les outils qu'ils veulent, pour les raisons qu'ils veulent, sans devoir leur tomber sur la gueule à chaque fois qu'ils disent "j'aime ci, j'aime ça" ?

Le commentaire initial c'était : "je préfère vim à vscode que mes collègues utilisent" et "j'aime bien leur montrer comment je me sers de vim".

Et toi tu viens essayer de lui démontrer qu'il y connait rien car d'autres IDE peuvent faire le même taf. Oui d'autres peuvent le faire, et on s'en cogne royalement. Personne ne t'as rien demandé.

Les goûts et les couleurs, ça se discute pas. La discussion est complètement inutile et n'a rien à faire ici.

Un peu de respect pour les défunts, et arrêter de se crêper le chignon pour des conneries, ça serait un bon début.

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

Personne A: J'aime bien $CHOSE surtout quand $EXEMPLE
Personne B: On peut faire $EXEMPLE dans $AUTRE_CHOSE

Utilité de la réponse : 0/10.

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

Une série télescopique et une série géométrique divergente sont deux objets mathématiques bien différents, avec des opérations ayant des règles bien différentes.

Et si tu lis l'article que tu as toi même cité, tu verras qu'il en conclut que la valeur que l'on associe à cette série divergente est bien 1/2.

Donc tu peux me renvoyer le compliment autant que tu veux, mais soit tu n'as pas lu l'article Wikipédia, soit tu ne l'as pas compris.

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