Verbose

comprendre ce qui se passe vraiment

Une serie d'articles educatifs sur la compilation native. Du code source au binaire ELF, chaque etape expliquee, chaque octet justifie.

  1. #1
    De l'idée au binaire

    Premier article de la série 'Verbose — comprendre ce qui se passe vraiment'. Parcours complet du source factorial au binaire ELF : parse, vérification, émission native x86-64, exécution. Chaque instruction machine annotée. Aucun prérequis assembleur.

  2. #2
    38 octets de sécurité

    Les 38 octets de bounds-check annotés instruction par instruction : mov r10 + cmp + jcc, l'abort tail, le backpatching, et pourquoi verbose est plus petit ET plus sûr que le C équivalent.

  3. #3
    Comment verbose prouve que votre programme se termine

    Phase C : le compilateur vérifie mécaniquement que les règles récursives convergent — preuve structurelle, champ décroissant, champ croissant. Le breadcrumb de l'article #1 est enfin résolu.

  4. #4
    Les registres et la pile

    Les 16 registres x86-64, la pile qui grandit vers le bas, le prologue/epilogue, call/ret, et pourquoi le stack overflow existe. Tout ce que les articles #1 a #3 supposaient sans l'expliquer.

  5. #5
    SHA-256 sans bibliothèque

    Comment verbose calcule un SHA-256 qui matche sha256sum octet pour octet, des primitives bit à bit jusqu'aux blocs multiples, en code machine natif sans aucune bibliothèque. Et la formule arithmétique qui rend le binaire plus petit en gérant plus de données.

  6. #6
    TLS 1.3 sans bibliothèque

    Un vrai navigateur ouvre une page HTTPS servie par un binaire dont toute la cryptographie (échange de clés, signature, chiffrement, hash) est du code machine émis par verbose. Pas d'OpenSSL. Et le navigateur ne voit pas la différence.

  7. #7
    AES sans bibliothèque

    Comment verbose implémente le chiffrement qui protège les données dans TLS : la S-box, l'arithmétique GF(2⁸) de MixColumns, les 10 tours déroulés, et le passage du bloc à l'AEAD GCM — validé bit pour bit contre les vecteurs NIST.

  8. #8
    Ed25519 sans bibliothèque

    Comment verbose signe et vérifie une identité avec Ed25519 : la multiplication scalaire sur courbe d'Edwards (récursive, avec preuve de terminaison), les signatures déterministes (zéro aléa, et pourquoi c'est plus sûr), validé contre les vecteurs RFC 8032.

  9. #9
    Un programme, c'est un arbre

    Ouverture de l'arc self-hosting : un compilateur verbose écrit en verbose. Avant tout, un compilateur doit transformer du texte en arbre (un AST). Comment verbose représente un arbre — des types sommes récursifs dans une arène indexée — et pourquoi c'est la brique qui rend tout le reste possible.

  10. #10
    Le tokenizer

    Chapitre 2 de l'arc self-hosting. Avant de comprendre un programme, il faut le découper en mots : c'est le tokenizer. On suit « x + 42 » octet par octet à travers le tokenizer écrit en verbose, on découvre pourquoi l'indentation est un casse-tête, et comment une pile de colonnes le résout.

  11. #11
    Le parser

    Descente récursive et l'échelle de priorité des opérateurs

    a venir
  12. #12
    Le compilateur qui attrape tes erreurs

    Cinq analyses statiques et des erreurs localisées au bon octet

    a venir
  13. #13
    La pointe : verbosec, en verbose

    Le front end complet, compilé en un binaire natif de 60 Ko

    a venir