jeanas a écrit 129 commentaires

Merci pour l'article !

Il faudrait regarder dans ce bouquin.

Cette page Wikipédia donne déjà une preuve « sophistiquée » du fait que la constante de Weiner est un nombre premier.

C'est aussi le cardinal du classificateur de sous-objet de la catégorie des ensembles (et de beaucoup d'autres catégories concrètes usuelles, comme les espaces topologiques, d'ailleurs je ne sais pas s'il y a une CNS intéressante pour ça).

Rectification : j'ai dit des bêtises sur les espaces topologiques. On vérifie que les monomorphismes sont les applications continues injectives. Mais du coup, il y a plein de monomorphismes qui ne sont pas des inclusions de sous-espace. Par exemple, l'identité sur {0, 1} si on met la topologie discrète au départ et triviale à l'arrivée.

Alors que les fonctions (automatiquement continues) vers {0, 1} avec la topologie triviale correspondent aux sous-ensembles, donc ce que j'avais en tête ne marche pas du tout. En fait, les inclusions de sous-espace topologique sont exactement les monos réguliers, et dans une catégorie qui a un classificateur de sous-objet, tous les monos sont réguliers, donc la catégorie des espaces topologiques n'a pas de classificateur de sous-objet du tout.

« Condition nécessaire et suffisante »

Vers la fin, il y a une section consacrée aux différentes propriétés et conjectures autour de la constante de Weiner. Si vous en connaissez d'autres, faites-le moi savoir.

Quelques idées :

• La constante de Weiner est le plus petit n tel que tout monoïde libre sur un nombre fini ou même dénombrable de générateurs soit un sous-monoïde du monoïde libre à n générateurs. Les conséquences pour l'informatique sont laissées en exercice. (Piqué à https://bsky.app/profile/gro-tsen.bsky.social/post/3kxzv27uwno2s)

• C'est le degré maximal d'un polynôme irréductible sur R, et le degré de la clôture algébrique de R.

• C'est le nombre de valeurs possibles pour la probabilité d'un événement dépendant asymptotiquement d'une suite de variables aléatoires indépendantes.

• C'est aussi le cardinal du classificateur de sous-objet de la catégorie des ensembles (et de beaucoup d'autres catégories concrètes usuelles, comme les espaces topologiques, d'ailleurs je ne sais pas s'il y a une CNS intéressante pour ça).

• Comme chacun sait, l'équation diophantienne aⁿ + bⁿ = cⁿ n'a de solutions non-triviales que pour n inférieur à la constante de Weiner.

(NB: Pinaillerie : tu dis que la constante de Weiner est l'indice du groupe alterné dans le groupe symétrique à tout ordre, il faut exclure les ordres strictement inférieurs à cette même constante.)

Malheureusement, si j'ai bien compris, le bug bounty se fait purement en boîte noire.

Comme mentionné dans la dépêche : https://linuxfr.org/news/l-union-europeenne-doit-poursuivre-le-financement-des-logiciels-libres

Est-ce que le rust est mieux que le c pour éviter de faire des bêtises ? Oui. Mais justement un des intérêts de faire du c c'est de comprendre pourquoi ce sont des bêtises, les mécanismes fondamentaux et quand faire attention. Si rust a un mot clé "unsafe", c'est bien parceque parfois on a besoin de traverser en dehors des clous. Apprendre à coder en C c'est comme apprendre à un enfant pourquoi on traverse au bonhomme vert plutôt que de simplement lui dire "c'est interdit de traverser au rouge". Le jour où le feu sera en panne, il pourra toujours traverser par lui même…

À prendre avec de grosses pincettes parce que la sémantique de Rust est beaucoup plus restrictive que celle du C, et du coup, il y a des choses que tu peux très bien faire en C et qui sont interdites en Rust, et si tu les fais en Rust unsafe, ton programme a de l'undefined behavior, alors que ce ne serait pas le cas du programme équivalent en C.

Quelques exemples typiques ici : https://lucumr.pocoo.org/2022/1/30/unsafe-rust/. Et ce qu'on a le droit ou non de faire avec les pointeurs est subtil et en cours d'évolution, cf. par exemple https://www.ralfj.de/blog/2023/06/02/tree-borrows.html.

De manière générale, je ne suis pas vraiment d'accord avec le « tu pourras facilement apprendre Rust si tu connais le C » car c'est un langage avec de vrais concepts nouveaux ou importés du monde fonctionnel (lifetimes, borrow checking, mutabilité intérieure, traits, generalized bounds, etc.), mais c'est sûr que l'expérience en C ou tout autre langage de bas niveau va aider largement.

En fait, une autre chose que je devrais faire, c'est mettre sur le blog mon avatar (l'image qui est en bas à droite du site racine https://jean.abou-samra.fr/ et qui me suit sur LinuxFR comme ailleurs), ce serait plus reconnaissable visuellement. Le truc, c'est que je suis nul en CSS et Web-design (j'ai déjà passé un temps fou sur la page racine, alors pour le blog, je n'avais plus l'énergie de faire autre chose qu'un truc ultra-minimaliste).

Oui, c'est ça, en fait c'est ce que j'essayais d'exprimer avec le préfixe "[Blog]" au début (dans le sens "[Mon blog]" en plus court, mais OK, c'est pourri et incompréhensible, je n'avais juste pas mieux…). Il y a une manière standard de faire que j'ai loupée ?

De l'auto-promo ? Désolé, je ne comprends pas ce que tu veux dire, quel lien avec mon commentaire ?

Euh, ça n'a rien à voir avec ce que je dis.

Comme précisé dans l'intro du billet, je ne prétends pas avoir écrit des choses profondes et originales, hein. Mais dire qu'une question n'a pas de réponse parce que chacun aura son propre point de vue (ton résumé), ce n'est pas la même chose que dire qu'une question n'a pas de réponse parce qu'elle est mal posée et n'a pas de sens (ce que j'ai écrit).

Si jamais c'est ce que tu as en tête, je ne suis pas en train de dire « tout est relatif, tout est culturel, toutes nos pensées sont formatées par nos préjugés, donc on ne peut rien savoir ni rien comparer ». (L'analogie avec la comparaison entre cultures est là pour dire que comparer l'humain à l'IA ne peut pas se faire de manière absolue de même qu'une comparaison entre cultures ne peut pas être absolue. Elle n'est pas là pour dire que le point de vue sur l'IA serait culturel, et je ne trouve pas que ce serait un angle pertinent.)

Le résumé en trois mots, c'est plutôt que la comparaison des humains aux IA n'est pas absolue parce que nous jugeons en partie les progrès de l'IA sur la capacité des IA à nous ressembler de plus en plus. Et que ça tempère l'angoisse « les IA vont-elles remplacer les humains » parce que, tautologiquement, rien ne peut ressembler plus à un humain qu'un humain.

Je lis

• un certain nombre de blogs,
• LinuxFR,
• trois réseaux sociaux : Mastodon, Bluesky et (oui) X.

Dans les blogs, et aussi sur LinuxFR, je trouve régulièrement des articles, parfois longs voire de dizaines de pages, qui m'intéressent vraiment, dont je ressors en ayant appris des choses, changé ma perception de ceci ou de cela, bref, en étant moins bête.

Sur les réseaux sociaux, c'est parfois le cas, mais la forme très courte limite énormément l'expression (la limite de caractères est un peu moins pire sur Mastodon, mais ça reste inconfortable d'avoir des discussions prolongées). Je suis souvent amusé sur l'instant, mais il est symptomatique que je me rappelle rarement de ce que j'y ai lu quelques jours après. Le principal intérêt que j'y trouve est surtout de dénicher des liens vers des contenus plus développés qui m'intéressent.

Et quand une recherche sur le Web me renvoie des résultats sur Medium et autres dev.to, j'ai tendance à ne les lire qu'en dernier recours parce c'est presque toujours plat et peu informatif (« Xxx is a simple yet powerful method for composing reusable frameworks », tutoriels avec juste quelques commandes pas expliquées, etc).

C'est sûr qu'en écrivant dans un blog, tu auras moins d'audience que sur les réseaux sociaux. D'un autre côté, tu auras plus de liberté sur la longueur et la forme, sans non plus rajouter les bannières d'inscription distrayantes de Medium. Et l'audience n'est pas la fonction d'utilité ultime. À toi de voir, ça dépend fortement du type de contenu.

Personnellement, sauf quelques fois où j'ai posté ici directement, pour tout ce que je veux développer un peu, j'écris dans mon blog. Je me dis que je préfère une personne qui lit un point de vue réellement argumenté à cent personnes qui lisent un résumé archi-condensé tant bien que mal dans une limite de caractères étroite. En revanche, j'annonce chaque billet sur les réseaux sociaux (et dans les Liens ici, en fonction du sujet).

On peut également citer SourceHut (concept assez particulier), ou Pagure (utilisée dans le projet Fedora).

Ce journal n'aurait-il pas davantage sa place comme question dans la section Forum ?

Non, ce n'est très probablement pas un antivirus. D'abord, quel antivirus ? Tu es sûr d'avoir un antivirus ? Sous Linux, contrairement à Windows, il n'y a pas une habitude d'exécuter des installeurs téléchargés de n'importe où, donc on n'a quasiment pas besoin d'antivirus. Et puis les paquets viennent de la distribution, ils sont vérifiés et approuvés, donc il n'y aurait vraiment aucune raison de les bloquer, ce serait complètement absurde.

Je répète la question : peux-tu copier le message d'erreur complet ?

Ce genre de choses peut arriver, par exemple, si tu avais installé un paquet qui a été supprimé dans la nouvelle version.

Peux-tu copier le message d'erreur complet ?

Je suis fasciné par l'énergie qui a été investie dans ce problème, la passion qu'il a déchaînée, et le fait que la résolution fasse la une de Quanta Magazine et le tour des réseaux sociaux (en tous cas tous mes contacts habituels sur Mastodon et Bluesky).

Pourquoi ? Parce que les valeurs exactes de la fonction castor affairé me paraissent parfaitement inintéressantes :D Notamment parce qu'elles dépendent fortement de choix purement techniques sur la forme des machines de Turing, qui n'ont généralement aucune importance parce toutes les variantes des machines de Turing sont interconvertibles, mais qui influencent le nombre exact d'états et donc la fonction castor affairé : le nombre de symboles de l'alphabet (un alphabet binaire est le plus courant, mais on permet généralement des alphabets plus gros, et on s'en sert même parfois vraiment, cf. space speedup theorem en complexité), le nombre de bandes (une seule dans la variante la plus simple, mais parfois deux avec une bande d'entrée/sortie et une bande de travail, et en complexité toujours trois, entrée + travail + sortie, car c'est ce qui permet de mesurer l'espace pris par un algorithme sans compter l'entrée ni la sortie), et aussi la manière de gérer les blancs (est-ce que la machine a le droit de se déplacer à l'intérieur des blancs après l'entrée en les laissant écrits ?), etc., etc.

Cela dit, c'est vrai que formaliser ça en Coq est assez impressionnant.

Quand on regarde le retour du cargo tree sur tera, regex-syntax v0.8.4 apparaît plusieurs fois.
La même lib (avec la même version) est utilisée par plusieurs dépendances de tera, pourtant tu n'auras qu'une seule lib installée.

C'est vrai. Note toutefois que ces doublons ne sont pas décomptés dans mon total de 126 (j'ai juste fait rg "name =" Cargo.lock | wc -l).

Et je ne dis pas que les dépendances sont « mal » (au contraire, c'est un soulagement d'avoir enfin un langage de bas niveau où c'est facile d'utiliser des dépendances). Je critique plus une certaine culture d'en ajouter sans prendre en compte leur coût. Je suis tout à fait prêt à utiliser tokio, ou regex, ou pulldown-cmark, ou toml. Je suis sceptique sur Tera parce que les dépendances me paraissent excessives rapportées au service rendu.

Cargo est parfaitement capable de créer et d'utiliser des librairies dynamiques, mais en gros les seuls qui le font sont ceux qui ont besoin de FFI avec d'autres langages (souvent C, mais aussi tout langage capable de comprendre l'ABI C, comme C++ ou Python).

Déjà, le principe même de vouloir mettre à jour une librairie dynamique sans recompiler ses dépendants est fondamentalement en conflit avec la monomorphisation des génériques, c'est-à-dire le fait qu'une même fonction dans la librairie peut être appelée avec des types différents dans le dépendant, non connus à l'avance, ce qui nécessite de la recompiler une fois par type avec lequel elle est utilisée dans le dépendant. C'est la même chose en C++ avec les templates. Toute tentative de créer une librairie dynamique à l'ABI stable se heurte à ce problème, qui rend le code pas du tout idiomatique parce que les génériques sont partout dans le langage.

Il y a une issue pour ça : https://github.com/rust-lang/rust/issues/69684

Le souci, c'est que les cas simples (comme le mien) sont faciles à implémenter, mais fournir une API qui couvre à peu près bien tous les cas intéressants est beaucoup, beaucoup plus compliqué. Il faut notamment penser à : ce qui se passe quand on rencontre un symlink vers un dossier, ce qui se passe quand on n'a pas les permissions, proposer une manière de limiter la profondeur de recherche, ou de filtrer des dossiers au fur et à mesure qu'ils sont lus (pour éviter de descendre dedans), etc. Donc je peux comprendre que ce soit trop pour la stdlib, même si ça se discute.

Je suppose que dans les 50 lignes produites par l'auteur, il y a plus que ça.

Non, il n'y a vraiment rien de plus que la base de la base (OK, 40 lignes, pas 50) :

use anyhow::Result;

struct WalkDir {
    stack: Vec<std::fs::ReadDir>,
}

impl WalkDir {
    fn new(dir: &Path) -> Result<Self> {
        Ok(Self { stack: vec![std::fs::read_dir(dir)?]  })
    }
}

impl Iterator for WalkDir {
    type Item = Result<std::fs::DirEntry>;
    fn next(&mut self) -> Option<Self::Item> {
        macro_rules! iter_try {
            ($expr:expr) => {
                match $expr {
                    Ok(x) => x,
                    Err(e) => return Some(Err(e.into())),
                }
            }
        }
        loop {
            let Some(top) = self.stack.last_mut() else {
                return None;
            };
            let Some(next) = top.next() else {
                self.stack.pop();
                continue;
            };
            let next = iter_try!(next);
            if iter_try!(next.file_type()).is_dir() {
                self.stack.push(iter_try!(std::fs::read_dir(next.path())));
            } else {
                return Some(Ok(next));
            }
        }
    }
}

C'est juste que les itérateurs sont un poil verbeux, mais rien de très notable.

Il y en a qui ne peuvent plus allumer la lumière chez eux à cause de ça :

https://x.com/bortzmeyer/status/1806760064302072050

(désolé, je n'ai pas trouvé l'info ailleurs que sur 𝕏).

Les engins JavaScript modernes sont des monstres d'optimisation JIT. Cette fonction est extrêmement simple et se compile très bien. Il n'y a aucun polymorphisme, aucune branche, juste une boucle et des calculs flottants.

Il faut se garder d'en tirer des conclusions générales sur la performance de JavaScript, vu que la plupart du code réel ne passe pas la majorité de son temps dans des calculs numériques comme ça.

Au passage, voici une manière de ramener le code Python au même ordre de grandeur de performance que C et JavaScript :

import numpy

WINDOW_SIZE = 10_000

def wallis(n):
    a = 1.0
    for i in range(n//WINDOW_SIZE + 1):
        A = numpy.arange(i*WINDOW_SIZE + 1, min((i+1)*WINDOW_SIZE, n) + 1)
        B = 4.0*A**2
        C = B / (B-1)
        a *= C.prod()
    return a*2

print(wallis(10**9))

Je confirme. Mon propre serveur (pour https://lilypond.community) a été en blacklist dès le premier message (pourquoi tant de haine ?) et j'ai dû les relancer de multiples fois et refuser d'accepter plusieurs réponses « désolés, notre bullshit automatisé a déterminé que nous ne pouvions pas répondre favorablement à votre demande » avant d'obtenir le déblacklistage.

Même système (Fedora 40). J'ai cloné ton dépôt et fait sudo dnf install libshumate-devel meson; meson setup build; cd build; ninja. Pas d'erreur, j'obtiens un exécutable qui affiche une jolie carte.

Tu as passé des options particulières à Meson ? Tu as des réglages particuliers de pkg-config ? (env | grep PKG_CONFIG)