Linux (fr)

  • Migrer Windows 10 d'un disque BIOS/MBR, vers un SSD en mode UEFI/GPT avec des logiciels libres (Journaux LinuxFR)

    Sommaire

    Introduction

    Ce tutoriel vous guide pas à pas pour migrer votre installation de
    Windows qui est actuellement sur un disque dur de votre PC vers un
    nouveau disque, en l'occurrence un SSD. A vrai dire, vous pouvez aussi
    bien migrer vers un autre HDD.

    La spécificité de ce tutoriel est qu'elle utilise les outils fournis par
    Microsoft avec Windows ainsi que des logiciels libres (Clonezilla
    principalement, mais si quelque chose devait mal tourner vous pouvez avoir
    besoin d'utiliser fdisk, gdisk ou testdisk pour ne citer qu'eux). Quand
    j'ai voulu faire cette migration je n'ai pas trouvé de tutoriel
    expliquant de bout en bout comment faire cette migration juste avec les
    outils de Microsoft et des logiciels libres.

    Typiquement, vous pouvez avoir envie/besoin de faire cela car vous avez
    acheté un nouveau disque pour remplacer l'ancien (par exemple car
    l'ancien montre des signes de faiblesse, ou vous voulez améliorer la
    réactivité de votre système).

    En plus de la migration du système d'exploitation, ce tutoriel vous
    explique comment passer d'un démarrage en mode BIOS/MBR à un démarrage
    en mode UEFI/GPT.

    Succinctement la démarche est la suivante, d'abord installer le nouveau
    disque dans le PC, et initialiser la table de partition selon les normes
    Microsoft. Puis cloner/dupliquer la partition contenant le système
    d'exploitation à l'aide de Clonezilla. Ensuite et avant de redémarrer
    dans le clone de Windows sur le SSD, faire quelques modifications dans
    le registre pour que la lettre de lecteur C: pointe vers la bonne
    partition et éventuellement modifier le mode SATA en AHCI si vous le
    modifiez aussi dans le UEFI/BIOS. Après cela, on va préparer la
    partition système EFI/ESP pour que le PC puisse démarrer dessus et qu'il
    démarre sur le Windows du SSD. Finalement, une fois dans le Windows du
    SSD, on va réactiver l'"environnement de récupération de Windows".

    Mise en garde : Faites une sauvegarde de vos données avant toute
    opération. Personne n'est à l'abri d'une mauvaise manipulation ou d'une
    erreur.

    Prérequis

    Compétences

    Niveau de difficulté : Difficile.

    Vous devez être à l'aise au niveau de l'utilisation de la ligne de
    commande dans Windows, mais aussi assez à l'aise pour gérer les
    partitions de votre disque. Savoir modifier le paramétrage de votre
    Firmware UEFI/BIOS et aussi nécessaire. Ce tutoriel guide pas à pas pour
    la majorité des opérations. Certaines n'ont pas été détaillées par souci
    de simplicité et d'efficacité.

    Matériel

    Le PC où vous voulez installer le SSD. Il faut qu'il soit en état de
    marche. De plus il doit avoir un firmware UEFI. S'il n'a que un BIOS
    standard, sans UEFI, ce tutoriel n'est pas adapté.

    Clé(s) USB ou plusieurs CD/DVD sur lequel vous aurez mis
    Clonezilla, System rescue
    CD
    et un environnement de démarrage
    Windows PE, ou Windows RE, ou le DVD/Disque d'installation de Windows.

    Le disque SSD (testé avec Samsung SSD 860 EVO 250GB). Il doit avoir une
    taille suffisante pour contenir votre partition de Windows. Dans tous
    les cas, la taille de la partition qui contiendra Windows sur le SSD
    doit être au moins égale à la taille de la partition Windows du HDD que
    vous voulez cloner. Au besoin, pour remplir ce critère, réduisez la
    taille de votre partition Windows avec le gestionnaire de disque de
    Windows par exemple (ou un autre outil de gestion de partition, comme
    gparted, sur le System Rescue CD). Cherchez sur internet si vous ne
    savez pas comment faire.

    Logiciel

    Windows 10 installé (en version 64 bits) (testé avec Win10 v1709)

    Windows 10 PE ou support d'installation de Windows 10 (clé USB ou DVD) -
    En Version 64 bits (testé avec un support d'installation de Win10 v1804)

    System rescue CD (version 5.2.2 par
    exemple)

    Clonezilla installé sur une clé ou un CD.
    Bien vérifier avant que votre système arrive à démarrer dessus. (Testé
    avec Clonezilla 2.5.5-38)

    Nomenclature

    SSD : désigne le nouveau SSD

    HDD : désigne votre disque actuel, sur lequel est installé Windows

    WinPE : un environnement de démarrage Windows PE, ou Windows RE, ou le
    DVD/Disque d'installation de Windows. Il doit être sur un support
    amovible (USB, CD ou DVD)

    S: La lettre de lecteur affectée à la partition Système EFI qui sera sur
    le nouveau SSD (parfois appelée ESP, EFI_System_Partition ou encore
    SYSTEM, ou EFI)

    N: Le clone de Windows, sur le SSD

    O: Le Windows cloné, sur le HDD

    C: La partition dans laquelle est installée Windows, lorsqu'on est dans
    Windows (que ce soit le windows cloné, ou le clone)

    Les commandes doivent être lancées en tant qu'administrateur.

    Procédure de base

    • Fixer et brancher le SSD dans l’ordinateur

    • Désactiver Windows FastStart (cf votre moteur de recherche préféré)

    • Initialiser et partitionner le disque à l'aide de Windows

      • Démarrer sur le Windows installé ou WinPE
      • Pour initialiser le disque, d'abord créer une table de partition, puis partitionner le disque. Pour ce faire :
        • Suivre les instructions de partitionnement UEFI/GPT selon Microsoft. Ci-dessous mon exemple, mais peut-être avez-vous besoin d'une partition "recovery" aussi, ou votre configuration nécessite quelques aménagements. Dans ce cas, voir les instructions de Microsoft et adapter pour vos besoins.
        • Par exemple: une partition EFI de 260Mo, une partition Microsoft Reserved (MSR) de 16Mo, une partition pour Windows (taille au moins égale à la taille de la partition de Windows à cloner). Pour informations, dans diskpart, les tailles que vous donnez en MB/Mo sont en réalité des MiB/Mio (220 = 10242 octets).
          • Ouvrir une invite de commande en mode administrateur et lancer diskpart . Et une fois dans diskpart :
            • list disk pour lister les disques et connaître le n° du SSD.
            • select disk # avec le numéro du SSD à la place de #
            • clean Supprime le contenu du disque / l'initialise
            • convert gpt Définit que le disque aura une table de partition GPT
            • create partition efi size=260 Crée une partition EFI de 260MiB
            • format quick fs=fat32 label="System" Formater la partition EFI au format FAT32
            • assign letter="S" Lui donner la lettre S
            • create partition msr size=16 Créer une partition Microsoft Reserved de 16MiB
            • create partition primary Créer la partition pour Windows (l'équivalent du C: )
            • format quick fs=ntfs label="Windows" Formater la partition pour Windows au format NTFS
            • assign letter="N" Lui donner la lettre N
            • list volume Liste les volumes. Permet de voir la table de partition.
            • exit Quitte diskpart
    • Cloner le Windows installé sur le HDD. Ceci sera fait à l'aide de
      Clonezilla

      • Redémarrer dans Clonezilla
      • Une fois dans clonezilla, et si vous êtes confortable avec les lignes de commande Linux, éventuellement supprimer de la partition Windows du HDD les fichiers pagefile.sys , hyberfil.sys (désactiver windows faststart avant), swapfile.sys .
      • Cloner la partition Windows du HDD vers le SSD (de préférence, partition de même taille, et de toutes façons, la partition de destination doit être plus grande que la source. Si ce n'est pas le cas, réduisez d'abord la taille de votre partition Windows depuis Windows). Dans clonezilla, utiliser le mode Partition vers Partition, et en mode Export. Utiliser les options -e1 auto (automatically adjust file system geometry for a ntfs boot partition if exists) -e2 (sfdisk uses CHS of hard drive from EDD (for non grub loader) -r (resize filesystem to fit partition size of target) -m (do NOT clone boot loader) -v (verbose)
      • Optionnellement cacher la partition contenant le windows source de la table de partition du disque source (si vous ne savez pas à quoi ça sert, passez votre chemin). Pour cela modifier le type de partition de la partition NTFS de windows (en principe, NTFS a un id de « 7 ». On peut utiliser id 17 pour la partition cachée : 17 correspond à « IFS Hidden »). Utiliser cfdisk ou fdisk pour faire ce changement (ce sont des programmes linux).
    • Dans le Firmware UEFI (ou BIOS-UEFI), on peut en profiter pour passer
      du mode SATA "IDE" vers "AHCI". Windows n'aime pas ce changement et
      il faut donc faire une opération dans le registre qui est
      détaillée ci-dessous. Tant que vous ne le faites pas, vous aurez un
      écran de plantage bleu de windows au démarrage (BSOD).

    • Si vous voulez être sûr de ne pas faire de bêtise dans le Windows que
      vous venez de cloner, je vous conseille d'éteindre l’ordinateur & de
      débrancher l’ancien disque. Ainsi vous ne risquez pas de modifier le
      mauvais fichier de registre (en l'occurrence celui de votre Windows
      sur le HDD)

    • Effectuer quelques opérations sur le Windows de destination (celui
      sur le SSD) avant qu'on ne démarre dessus. En particulier corriger le
      registre pour affecter la lettre de lecteur C: à la bonne partition,
      et si le paramétrage du Firmware UEFI (BIOS-UEFI) a été modifié pour
      passer de SATA Mode PCI vers AHCI, on va aussi faire ce changement
      pour que ca fonctionne.

      • Redémarrer dans WinPE (en Mode UEFI, pas MBR !)
        • Tout d'abord déterminer la lettre de lecteur affectée au clone de Windows, celui qui est sur le SSD. Ou, s'il n'y a pas de lettre affectée, lui en donner une, par exemple N: (lettre utilisée dans les exemples qui suivent)
          • Pour cela, lancer dans diskpart
            • list volume
              Ce qui retourne la liste des volumes avec la lettre de lecteur qui a été affectée à chacun.
          • Si aucune lettre de lecteur n'est affectée, il faut alors lui en affecter une. Pour cela, lancer dans diskpart
            • select volume # (avec # étant le numéro du volume qui contient le nouveau windows)
            • assign letter=N
              S'il n'est pas possible d'utiliser select volume alors faire comme ceci
            • list disk
            • select disk # (# étant le numéro affecté au SSD)
            • list partition
            • select partition # (# étant le numéro affecté à la partition de Windows sur le SSD, probablement 3)
            • assign letter=N
        • Faire un CHKDSK /F sur la lettre du nouveau Win
        • Pour que la partition C: utilisée par Windows soit celle du SSD et pas celle de l’ancien disque, modifier une clé de registre du nouveau Windows :
          • Lancer REGEDIT et dans le registre HKEY_LOCAL_MACHINE monter la ruche N:\Windows\System32\Config\SYSTEM . Lui donner le nom "NewWin" On s’intéresse à HKEY_LOCAL_MACHINE\NewWin\MountedDevices . Ce sont là les valeurs qui sont dans le registre " HKEY_LOCAL_MACHINE\SYSTEM\MountedDevices " lorsqu'on est dans l'installation de Windows.
            • Dans HKEY_LOCAL_MACHINE\NewWin\MountedDevices modifier la lettre de lecteur C: en renommant \DosDevices\C: par \DosDevices\O: (car la valeur fait référence à la partition de l'ancien Windows sur le HDD et on ne veut pas, en démarrant, utiliser cette partition mais celle de son clone qui est sur le SSD). Ainsi, lorsqu'on démarrera dans le nouveau Windows, la partition contenant le Windows sur le HDD aura la lettre O:, et la partition contenant le Windows sur le SSD aura la lettre C:
            • Créer une nouvelle valeur binaire nommée \DosDevices\C: et lui donner comme contenu celui de \DosDevices\N: qui est renseignée dans le registre WinPE, c'est-à-dire là HKEY_LOCAL_MACHINE\SYSTEM\MountedDevices ( C: étant la lettre qu'utilisait le Windows du HDD comme partition où il y a le dossier \Windows )
            • ATTENTION: Bien vérifier que la copie a fonctionné et qu'il y a les bonnes valeurs, car dans mes essais, j'ai du m'y reprendre à 2 fois car le 1er "coller" ne collait pas ce que je voulais.
            • En principe c'est tout. Mais d'après certaines sources, il y aurait une clé \\?\Volume{GUID} ayant le même contenu que le \DosDevices\O: qu’on vient de modifier. Chez moi ce n'était pas le cas. Si vous avez une telle valeur, alors il faut lui donner le contenu de \DosDevices\N: depuis le registre WinPE
        • Si en même temps que la migration on veut aussi passer du mode SATA IDE vers AHCI alors il faut encore faire ceci. Cela a été repris du site tomshardware.co.uk
          • Toujours dans REGEDIT avec la ruche montée en HKEY_LOCAL_MACHINE\NewWin
          • Aller à HKEY_LOCAL_MACHINE\NewWin\ControlSet000\Services\storahci\StartOverride
          • Changer la valeur DWORD de 3 à 0.
          • Au redémarrage, si ça n'a pas été fait, changer la paramétrage du contrôleur SATA de IDE à AHCI. Au redémarrage, Windows devrait directement démarrer correctement et sans plantage (BSOD).
        • Rendre le disque bootable en installant les outils EFI de microsoft et configurant le Magasin BCD (BCD Store)
          • D'abord assigner une lettre de lecteur à la partition ESP
            • MOUNTVOL S: /S
              Si ca n'a pas fonctionné, faire comme ceci dans diskpart
            • list disk
            • select disk # (# est le numero du SSD retourné par list disk)
            • list partition
            • select partition # (# est probablement 1)
            • assign letter=S
          • Puis lancer bcdboot N:\windows /l fr-fr /s S: /f UEFI
            • N:\Windows est le répertoire contenant le clone de Windows sur le SSD)
            • S: = partition EFI
    • Redémarrer, et avant le lancement de Windows vérifier votre UEFI
      (ou BIOS-UEFI). Il faut qu'il soit configuré pour démarrer par défaut
      en mode UEFI et pas en mode BIOS. Penser aussi à corriger le
      paramétrage SATA si cela a été modifié dans le registre de Windows.

      Le paramétrage du démarrage avec
      bcdboot N:\windows /l fr-fr /s S: /f UEFI a normalement créé le
      magasin BCD, mis tous les fichiers EFI sur la partition SYSTEME (ESP,
      partiton EFI, la 1ère du SSD) et dit au firmware UEFI qu'il doit
      automatiquement démarrer avec le gestionnaire de démarrage
      (boot manager) de Windows.

    • Une fois qu’on a réussi à démarrer dans la copie de Windows

      • Réactiver le "FastBoot"
      • Réactiver l'environnement de récupération de Windows en lançant, depuis une ligne de commande avec les droits administrateur, la commande reagentc.exe /enable . Vérifier avec reagentc.exe /info . Et s'il y a une erreur essayer avec reagentc.exe /enable /setreimage /path C:\Recovery\WindowsREC:\Recovery\WindowsRE est le dossier où se trouve le fichier Winre.wim
      • Vérifier que tout est en ordre. Eventuellement donner un nouveau nom à votre partition C: (pour la différencier de celle sur le HDD) en lançant: LABEL [drive:][label]
      • Redémarrer encore une fois en laissant le processus de démarrage se faire tout seul pour vérifier que tout est ok.
    • Réinsérer l'ancien disque dur.

    • Normalement, il devrait être possible de redémarrer dans l'ancien
      Windows, du moment que vous savez comment booter en MBR, et sous
      réserve de ne pas avoir modifié le mode SATA dans le UEFI/BIOS. SI
      c'est le cas, vous pouvez envisager de modifier le registre du
      Windows du HDD, ou de modifier le paramétrage du UEFI/BIOS.

      Si vous avez aussi Linux d'installé sur le HDD, il devrait toujours
      être possible de le démarrer en mode BIOS

    • On peut diminuer/augmenter la taille de la partition C: du SSD (Pour
      un SSD TLC ou VNAND, on peut par exemple laisser de l’espace libre à
      la fin ~10 % de la capacité du disque d'après le logiciel Samsung
      Magician, pour un SSD 860 EVO)

    • En principe, puisqu’on boot en EFI on peut enlever sur le clone
      Windows sur le SSD les fichiers \bootmgr et \Boot\BCD puisque ce
      sont ceux qui étaient utilisés pour un boot en mode BIOS/MBR et que
      désormais on est en EFI. Vous pouvez d'abord les renommer et vérifier
      que ca ne change rien au prochain boot, plutôt que de les supprimer
      tout de suite.

    Quelques pistes si ça ne fonctionne pas…

    • Faire un chkdsk sur la nouvelle partition
    • Recréer le bootsector du NTFS avec testdisk (dispo sur System Rescue CD, mais peut être aussi dans Clonezilla ? Je n'ai pas vérifié)
    • Vérifier le BCD:
    • Vérifier que la partition EFI est bien initialisée (présence des fichiers \EFI , \EFI\Boot\ , \EFI\Microsoft\ …) Si ce n'est pas le cas, il y a eu un problème avec bcdboot N:\windows /l fr-fr /s S: /f UEFI
    • Vérifier le boot manager du bios (démarrage en UEFI ou MBR ? Gestionnaire de démarrage par défaut ? Présence du gestionnaire de démarrage de Windows ?)
    • A priori, pas utile : Commandes à lancer dans WinPE
      • Pour recréer le boot sector de la partition systeme (EFI): bootrec /fixboot
      • Pour chercher les OS sur le disque et les mettre dans le bootloader bootrec /scanos
    • Quelques commandes de bcdedit pour modiser la valeur de certains éléments du magasin BCD. Inutile car le BCD Store qui est utilisé lorsqu'on démarre en mode EFI n'est pas le même que celui utilisé dans un démarrage en mode MBR. Donc, pas besoin de chercher à modifier le BCD. Je garde pour info : les lettres sont celles telles que définies dans le système où on est (WinPE par ex). Doc BCDEDIT
      • bcdedit /set {bootmgr} device \Device\HarddiskVolume1
      • bcdedit /set {default} device \Device\HarddiskVolume3
      • bcdedit /set {default} osdevice \Device\HarddiskVolume3
      • Ou à la place de \Device\HarddiskVolume1 mettre les lettres de lecteur :
      • bcdedit /set {bootmgr} device partition=S:
      • bcdedit /set {default} device partition=C:
      • bcdedit /set {default} osdevice partition=C:

    Documentation, pour aller plus loin…

    A propos du EFI/UEFI:

    A propos de l'entrée MountedDevices du registre:
    http://diddy.boot-land.net/firadisk/files/mounteddevices.htm

    Si on veut y accéder, par défaut les fichiers du BCD sont cachés. Pour
    les rendre visibles:

    • attrib bcd -s -h -r
    • mv bcd bcd.bak
    • bootrec /rebuildbcd

    Documentation bcdedit:

    MBR Partition ID

    A propos des disk ID (=Disk signatures):

    Si besoin de supprimer du registre les entrées de disques qui ne sont
    pas connectés ou sans lettre assignée lancer: mountvol /R. Ce
    programme permet aussi de lister les lettres de volumes avec leur GUID
    (GUID pour ce système uniquement, il n’est pas stocké dans la partition,
    ni ailleurs sur le disque, il est assigné par windows pour un couple
    (signature de disque/partition offset) dans une instance de windows
    alors que dans une autre instance de windows la même partition sur le
    même disque aura ce GUID différent)

    Changer le label du volume: commande LABEL [drive:][label]

    Historique de révisions

    • Vous trouverez la dernière version de ce tutoriel sur ma page perso
      de tutoriels informatique
      .
      Vous y trouverez aussi la version HTML, PDF et TXT.

    • 2018-06-17 : Ajout d'une note indiquant que ce tutoriel utilise des
      logiciels libres

    • 2018-06-11 : Correction de la forme et de fautes d'orthographe

    • 2018-05-28

    Commentaires : voir le flux atom ouvrir dans le navigateur

  • [C++14 ] Expressions template pour les nuls (Journaux LinuxFR)

    Sommaire

    Expression Templates pour les nuls

    Après un contact prolongé avec Joël Falcou, et pas mal de nœuds aux cerveaux pour arriver à émuler le comportement du broadcasting de Numpy avec des expression templates dans Pythran, j'ai eu l'envie soudaine, un peu folle peut-être, de réécrire un moteur d'expressions template en C++14, mais pour faire simple et didactique.

    Mais de quoi zy parle

    Les expressions templates sont une maintenant assez vieille technique de C++ qui permet par exemple d'éviter de créer des objets intermédiaires lourds quand on calcule sur des tableaux en utilisant des expressions complexes.

    Par exemple, pour le type std::vector<double>, si on surcharge naïvement (et de façon fort risquée, pas touche aux conteneurs de la lib standard comme ça) les opérateurs +, * etc avec un code du genre :

    std::vector<double> operator+(std::vector<double> const& left, std::vector<double> const& right) {
        assert(left.size() == right.size() && "same size");
        std::vector<double> out(left.size());
        std::transform(left.begin(), left.end(), right.begin(), out.begin(),
                       std::plus<double>());
        return out;
    }

    et bien l'évaluation d'une expression du genre a + b * c va créer un tableau inutile (le résultat de b * c) et la move semantic ne nous sauve pas totalement. Et on va faire deux boucles, une par opération.

    Avec les expressions template, on va plutôt écrire :

    add<std::vector<double>, std::vector<double>> operator+(std::vector<double> const& left, std::vector<double> const& right) {
        return {left, right};
    }

    Avec :

    template<typename L, typename R>
    struct add {
        L const& left_;
        R const& right_;
        add(L const& left, R const& right) : left-(left), right_(right) {}
        // ...
    };

    Ce qui nous donnera comme type de retour de l'expression a + b * c :

    add<std::vector<double>,
        mul<std::vector<double>,
            std::vector<double>
           >
       >

    En ajoutant un opérateur [] aux types add<...> et mul<...> qui fait suivre l'appel aux fils, et une fonction membre size() qui renvoie, par exemple, la plus petite des tailles des deux fils :

    template<typename L, typename R>
    struct add {
        L const& left_;
        R const& right_;
        add(L const& left, R const& right) : left-(left), right_(right) {}
        auto operator[](size_t i) const { return  left_[i] + right_[i]; }
        auto size() const { return std::min(left_.size(), right_.size(); }
    };

    on peut alors écrire le code bâtard mais néanmoins relativement facile à comprendre :

    auto expr = a + b * c;
    auto n = expr.size();
    std::vector<double> res(n);
    for(size_t i = 0; i < n; ++i)
      res[i] = expr[i];

    Et voilà, on a une unique boucle, pas de tableau intermédiaire, c'est la fête et vive les expressions template. Cette technique est très largement utilisée :

    Mais elle est assez lourde à mettre en œuvre avec les outils pre-C++11. Je vous propose une solution que je croyais innovante, mais après discussion avec mon mentor sus-nommé, elle n'est qu'ingénieuse, ce qui est somme toute déjà pas mal.

    Expressions template à la sauce C++14

    Le parcours de l'arbre d'expression de bas en haut à coup d'appels récursifs, ça rappelle fury le design pattern visitor. C'est d'ailleurs une des options proposées par Boost.Proto, le gros pavé pour ceux qui aiment manger des expressions template avec de la crème le matin.

    Du coup, proposition didactique (pleins de détails et optimisations possibles sont écartés pour la clarté du propos) : on va associer à chaque type de nœud de notre arbre un tag (une structure vide, un type) et une fonction générique dont le but sera de lancer la mécanique de parcours de l'arbre. Exemple :

    struct add_tag {};
    template<class A, class B>
    auto add(A&& a, B&& b) {
      return [=](auto visitor) { return visitor(add_tag{}, a(visitor), b(visitor));};
      }

    Bon ça parait un peu mystérieux comme ça, le gain en clarté n'est pas (clair ?) évident, mais on renvoie juste, quand on fait appel à la fonction add, une fonction générique capable d'appliquer un visitor sur les fils, de bas en haut.

    On peut faire la même chose pour les feuilles de l'arbre, ici en distinguant les références vers des objets complexes et les constantes :

    struct cst_tag {};
    template<class T>
    auto cst(T expr) {
     return [=](auto visitor) { return visitor(cst_tag{}, expr); };
    }
    
    struct ref_tag {};
    template<class T>
    auto ref(T& expr) {
     return [&](auto visitor) { return visitor(ref_tag{}, expr); };
    }

    Ça fait peu ou prou la même chose, mais avec un tag différent.

    Maintenant que la mécanique est en place, on peut code de façon élégante nos visiteurs ! Par exemple pour obtenir le i-ème élément:

    struct evaluator {
      evaluator(size_t i) : i_(i) {}
    
      template<class T>
      auto operator()(lazy::cst_tag, T c) { return c; }
    
      template<class T>
      auto operator()(lazy::ref_tag, T& r) { return r[i_]; }
    
      template<class A, class B>
      auto operator()(lazy::mul_tag, A a, B b) { return a * b; }
    
      template<class A, class B>
      auto operator()(lazy::add_tag, A a, B b) { return a + b; }
    
      private:
      size_t i_;
    };

    On utilise le tag pour spécialiser l'appel et déterminer le nœud à visiter. L'appel se fait simplement par :

    auto expr = add(cst(12), mul(ref(a), ref(b)));
    auto expr_0 = expr(evaluator(0));

    On peut même spécifier un comportement par défaut, en jouant sur l'ordre de résolution des surcharges :

    struct size {
    
      template<class T>
      auto operator()(lazy::cst_tag, T c) { return std::numeric_limits<size_t>::max(); }
    
      template<class T>
      auto operator()(lazy::ref_tag, T& r) { return r.size(); }
    
      template<class T, class A, class B>
      auto operator()(T, A a, B b) { return std::min(a,  b); }
    
    };

    À la différence de la première approche, plus besoin de modifier les types proxy add, mul etc. On peut mettre toute la logique à un endroit, et l'étendre de manière non intrusive. Au final, si on sait vouloir stocker notre expression finale dans un std::vector<...>, on peut même écrire de façon assez élégante :

    template<class E>
    auto eval(E const & expr) {
      size_t n = expr(size());
      std::vector<decltype(expr(evaluator(0)))> res(n);
      for(size_t i = 0; i < n; ++i)
        res[i] = expr(evaluator(i));
      return res;
    }

    qui fait le bonheur des petits et des grands :

    auto expr = add(cst(12), mul(ref(a), ref(b)));
    auto evaluated = eval(expr);

    Performance

    Un petit coup de clang++ -std=c++14 -Ofast -march=native sur un code utilisant l'expression précédente a fait apparaitre cette séquence d'assembleur:

    400ab0:       c4 c1 7a 6f 0c 1e       vmovdqu (%r14,%rbx,1),%xmm1
    400ab6:       c4 c1 7a 6f 54 1e 10    vmovdqu 0x10(%r14,%rbx,1),%xmm2
    400abd:       c4 c1 7a 6f 5c 1e 20    vmovdqu 0x20(%r14,%rbx,1),%xmm3
    400ac4:       c4 c1 7a 6f 64 1e 30    vmovdqu 0x30(%r14,%rbx,1),%xmm4
    400acb:       c4 c2 71 40 0c 1f       vpmulld (%r15,%rbx,1),%xmm1,%xmm1
    400ad1:       c4 c2 69 40 54 1f 10    vpmulld 0x10(%r15,%rbx,1),%xmm2,%xmm2
    400ad8:       c4 c2 61 40 5c 1f 20    vpmulld 0x20(%r15,%rbx,1),%xmm3,%xmm3
    400adf:       c4 c2 59 40 64 1f 30    vpmulld 0x30(%r15,%rbx,1),%xmm4,%xmm4
    400ae6:       c5 f1 fe c8             vpaddd %xmm0,%xmm1,%xmm1
    400aea:       c5 e9 fe d0             vpaddd %xmm0,%xmm2,%xmm2
    400aee:       c5 e1 fe d8             vpaddd %xmm0,%xmm3,%xmm3
    400af2:       c5 d9 fe e0             vpaddd %xmm0,%xmm4,%xmm4
    400af6:       c4 c1 7a 7f 4c 1d 00    vmovdqu %xmm1,0x0(%r13,%rbx,1)
    400afd:       c4 c1 7a 7f 54 1d 10    vmovdqu %xmm2,0x10(%r13,%rbx,1)
    400b04:       c4 c1 7a 7f 5c 1d 20    vmovdqu %xmm3,0x20(%r13,%rbx,1)
    400b0b:       c4 c1 7a 7f 64 1d 30    vmovdqu %xmm4,0x30(%r13,%rbx,1)
    400b12:       48 83 c3 40             add    $0x40,%rbx
    400b16:       48 81 fb 00 03 00 00    cmp    $0x300,%rbx
    400b1d:       75 91                   jne    400ab0 <main+0x70>
    

    Ce qui est franchement cool : le code a été vectorisé, déroulé et il est… vachement propre. On retrouve bien là le principe de costless abstraction si cher au C++. J'♥.

    Répéter, c'est apprendre

    La petite lib que j'ai écrite pour tester ces idées n'ira pas sur le grand ninternet, c'était juste pour le lulz. Et puis après coup, Il m'a pointé vers https://isocpp.org/blog/2016/05/cppcon-2015-expression-templates-past-present-future-joel-falcou qui contient bien plus de contenu que ce maigre article, qui ne sera finalement qu'une petite introduction et qui aura eu l'avantage de me forcer de coucher sur le clavier (avant d'aller moi-même me coucher) mes idées. Et n'est-ce pas ça, le but d'un journal ?

    Lire les commentaires

  • Un rachat, un summit et un BIOS qui s'ouvre de plus en plus grâce à linux (Journaux LinuxFR)

    Me revoilà après plusieurs mois de silence. Il faut dire que depuis la fin 2017, mon agenda s'est retrouvé complètement chamboulé. La société que j'ai créée avec Isabelle (ma moitié comme on dit), a été rachetée par une société américaine, un de nos partenaires de longue date. Nous avons créée Splitted-Desktop Systems (SDS) il y a 11 ans avec pour objectif de concevoir des ordinateurs silencieux respectueux de l'environnement en France. On a beaucoup travaillé (vraiment beaucoup), on a beaucoup galéré (vendre des ordinateurs français à des français c'est complexe (mais je tiens a remercier les membres de linuxfr qui ont été nos clients durant ces dernières années !), et le dernier tweet d'oles me laisse d'ailleurs dubitatif (https://twitter.com/olesovhcom/status/1007519400734359552), on est dans un mode hôpital qui se moque un peu de la ch… . Bon quoiqu'il en soit nos technos frenchies ont et intéressent des américains, on a donc décidé de répondre positivement à l'offre et on s'est pris un Tsunami sur la tête, mais voilà c'est fait ! Annonce rachat

    Certains diront qu'on se vend à l'axe du mal, j'aurai tendance à dire qu'on peut y voir pleins de choses positives. La première c'est un des premiers rachats significatif dans le domaine de l'Open Hardware pour les serveurs. On est racheté par un de nos partenaires de longue date qui a valorisé à un niveau trois fois supérieure notre société par rapport aux meilleurs propositions d'investisseurs français, on pérénise nos emplois et on embauche, on va accélérer sur des tonnes de sujets dont linuxboot, FreeCAD et l'impact de l'open hardware sur les modèles d'économie circulaire ce qui est en soit juste genial !

    Ce qui m'ammène à parler du futur summit Open Compute en Europe. Il se tiendra à Amsterdam (ok c'est pas la France, mais c'est pas loin), et j'y animerai une session complète sur linuxboot durant laquelle on présentera des machines qui fonctionnent sous cet environnement, on aura des sessions de hacking et on discutera de la futur roadmap du projet. Pour ceux qui ne suivent pas ce projet, l'objectif de linuxboot est de remplacer UEFI par un kernel linux dans l'optique de mieux maitriser les phases de démarrage des serveurs, simplifier leur provisioning et surtout de les maintenir en condition opérationnelle le plus longtemps possible grace à l'ouverture du code ! Ca fonctionne, c'est un projet qu'on a créée avec Google, Facebook et quelques autres hackers de haut vol. Si vous êtes impliqués dans le déploiement de serveurs et un peu curieux vous ne pouvez pas louper cet événement ainsi que l'osfc organisé par 9elements (osfc).

    A bientôt, et j'espere vous croiser au summit ou en Allemagne !

    vejmarie

    Commentaires : voir le flux atom ouvrir dans le navigateur

  • Rumeurs sur l'hyper-threading - TLBleed (Journaux LinuxFR)

    La peinture de la dépêche sur la faille Lazy FPU save restore n'étais pas encore sèche
    que je tombais sur de curieux messages conseillant de désactiver l'Hyper-threading.

    Suivis de conversations plus ou moins inquiétantes sur Twitter et dans les mailings list.

    Accroche toi au pinceau

    Un commit sur OpenBSD désactive l' Hyper-treading par défaut.
    Le message associé est explicite:

    « Since many modern machines no longer provide the ability to disable Hyper-threading in
    the BIOS setup, provide a way to disable the use of additional
    processor threads in our scheduler. And since we suspect there are
    serious risks, we disable them by default
     »
    Puisque les machines récentes ne donnent plus la possibilité de désactiver l' Hyper-threading depuis le BIOS, trouvez un moyen de désactiver l'utilisation des threads d'un processeur dans notre ordonnanceur.
    Et comme on suspecte que le risque est sérieux, désactivons le par défaut.

    Pour faire plus court, j'avais lu auparavant un laconique:

    ps deactivate Hyper-threading on your server
    Désactivez l'Hyper-threading sur vos serveurs !

    Venant des équipes OpenBSD, il y a de quoi s'interroger.

    J'enlève l'échelle

    La conférence Black Hat qui se déroulera en août prochain, propose au menu:

    « This therefore bypasses several proposed CPU cache side-channel protections. Our TLBleed exploit successfully leaks a 256-bit EdDSA key from libgcrypt (used in e.g. GPG) with a
    98% success rate after just a single observation of signing operation on a co-resident hyperthread and just 17 seconds of analysis time
     »
    En outre, ceci court-circuite plusieurs protections sur le cache. Notre exploit TLBeed a réussi à voler une clef 256-bit EdDSA depuis ligcrypt (utilisée par GPG ) dans 98% des tentatives, après une simple observation des opérations de signature depuis un thread tournant sur le même CPU en seulement 17 secondes d'analyse.

    Colin Percival, auteur en 2005 de:

    1. un papier sur les attaques via les caches, Cache Missing for Fun and Profit
    2. un article qui cible plus particulièrement les risques liés à l'Hyper-threading

    en remet une couche:

    « I think it's worth mentioning that one of the big lessons from 2005 is that side channel attacks become much easier if you're executing on the same core as your victim »
    Je pense qu'il est bon de rappeler cette grande leçon de 2005: une attaque en side channel est tellement plus facile si vous l'exécutez sur le même cœur que votre victime.

    Cuisine

    Intel n'est jamais clairement impliqué; mais je précise, comme ça, en passant, que l'Hyper-Threading est une implémentation Intel du Simultaneous Multi Threading.
    Il s'agit de faire exécuter en parallèle, sur un même cœur, plusieurs unités fonctionnelles ou de calcul.
    Et pour rendre cette technique efficace et moins gourmande en ressource, cette implémentation partage aussi les caches mémoires.

    Keep systems protected, efficient, and manageable while minimizing impact on productivity

    Conclusion

    Toutes les solutions de sécurité aujourd’hui ne sont que des châteaux forts construit sur du sable.

    Si encore une fois, la désactivation de l'Hyper-threading pourrait même avoir des effets positifs sur les performances, autant en finir une fois pour toute.

    Retour aux origines:

    • un partage complet sans protection des ressources
    • plus de mode protégé
    • pas même de segmentation mémoire

    Vos machines iront encore plus vite. Enfin, j'espère.

    Commentaires : voir le flux atom ouvrir dans le navigateur

  • Compilation de VSCode sous Centos 6 (Journaux LinuxFR)

    Il y a quelques mois, le camarade freem< nous avait fait part de ses déception concernant VSCode parce qu'il ne trouvait pas matière à troller de manière satisfaisante.

    J'ai voulu me faire mon propre avis et l'essayer par moi même. Malheureusement, ma machine pro est une Centos 6 et la libc disponible beaucoup trop vielle. Impossible de l'essayer et donc de partager avec vous mes impressions pertinentes et de kalitay :(. Quelques moules m'ont gentiment expliqué que je n'avais qu'à me sortir les doigts du fondement et le compiler moi même, que si je voulais vraiment, je pouvais.

    Plusieurs mois plus tard, j'ai enfin trouvé le temps et la motivation d'essayer. Et à ma grande surprise, ce fut plutôt facile.

    # Installation d'une version décente de GCC, python et git depuis les dépots 
    # Softawre Collections
    sudo yum install centos-release-scl
    sudo yum install devtoolset-7 python27 rh-git29
    
    # Installation de NodeJS et Yarn
    curl --silent --location https://rpm.nodesource.com/setup_6.x | sudo bash -
    curl --silent --location https://dl.yarnpkg.com/rpm/yarn.repo | sudo tee /etc/yum.repos.d/yarn.repo
    sudo yum install nodejs yarm
    
    # Activation de l'environnement de compilation
    scl enable python27 devtoolset-7 rh-git29 bash
    
    # Récupération des sources de VSCode
    git clone https://github.com/Microsoft/vscode.git
    cd vscode
    
    # Augmentation de la limite du nombre de fichiers ouverts à 166384
    # (il peut être nécessaire de modifier /etc/security/limits.conf pour atteindre
    # cette valeur)
    ulimit -n 166384
    
    # Récupération des dépendances
    # (On défini la variable CXX parce que sinon un des makefile utilise 
    # /usr/bin/g++ qui ne supporte pas C++11 )
    CXX=$(which g++) yarn
    
    # Construction du paquet
    yarn run gulp vscode-linux-x64-min
    
    # "Instalation"
    mv ../VSCode-linux-x64 ~/opt/vscode

    Et voilà ! À moi les joies des d'un éditeur moderne !

    $ ~/opt/vscode/bin/code-oss
    /home/killruana/opt/vscode/bin/../code-oss: error while loading shared libraries: libgtk-3.so.0: cannot open shared object file: No such file or directory

    Lourd est le parpaing de la réalité sur la tartelette aux fraises de nos illusions. :'(

    Rendez-vous dans quelques mois pour la suite de mes aventures avec vscode.

    Commentaires : voir le flux atom ouvrir dans le navigateur

  • Agenda du Libre pour la semaine 26 de l'année 2018 (Dépêches LinuxFR)

    Calendrier web, regroupant des événements liés au Libre (logiciel, salon, atelier, install party, conférence), annoncés par leurs organisateurs. Voici un récapitulatif de la semaine à venir. Le détail de chacun de ces 30 événements (1 en Belgique, 29 en France, 0 au Luxembourg, 0 au Québec 0 en Suisse et 0 en Tunisie) est en seconde partie de dépêche.

    Sommaire

    [FR Nantes] Cycle café vie privée Protection de son trafic sur Internet (VPN) - Le lundi 25 juin 2018 de 18h00 à 21h00.

    Protection de son trafic sur Internet

    Pourquoi et comment chiffrer son trafic sur Internet avec un VPN (réseau privé virtuel) ?
    Présentation du fonctionnement d’un VPN, de son intérêt et de sa mise en place.

    Au bar associatif La Dérive https://lajavadesbonsenfantsblog.wordpress.com/

    [FR Grenoble] Contribuer à BANO, la base d’adresse nationale d’OSM - Le lundi 25 juin 2018 de 18h30 à 20h30.

    Le collectif OpenStreetMap Grenoble vous invite à son prochain atelier OSM, La Base Adresses Nationale Ouverte (BANO) est une initiative d’OpenStreetMap France.

    Elle a pour objet la constitution d’une base la plus complète possible de points d’adresse à l’échelle de la France.

    L’objectif est de proposer une couverture d’adresses la plus étendue possible et la plus homogène possible.

    Cela doit permettre de réaliser sur le plus largement possible des opérations de géocodage (Quelle position correspond à cette adresse) et de géocodage inversé (Quelle adresse correspond à cette position).

    Lors de ce mapathon, le collectif OpenStreetMap Grenoble vous propose d’apprendre à contribuer à la BANO.  

    À partir de 18h30 à La Coop-Infolab. 31 rue Gustave Eiffel – 38 000 Grenoble

    BANO ou BAN

    La BAN (Base Adresse Nationale) est la base de référence nationale issue d’une convention signée entre l’IGN, le Groupe La Poste, l’État et OpenStreetMap France.

    BANO est un projet initié par OpenStreetMap France début 2014 et n’a pas encore intégré de données issues de la BAN (chantier en cours). Le contenu de la BAN est plus complet (plus de 20 millions d’adresses) que BANO (15. 5M d’adresses), mais n’intègre(ra) pas de contributions faites sur OpenStreetMap et encore très peu de données opendata diffusées par certaines collectivités.

    C’est quoi OSM

    OpenStreetMap (OSM) est un projet international fondé en 2004 dans le but de créer une carte libre du monde.

    Nous collectons des données dans le monde entier sur les routes, voies ferrées, les rivières, les forêts, les bâtiments et bien plus encore

    Les données cartographiques collectées sont ré-utilisables sous licence libre ODbL (depuis le 12 septembre 2012). Pour plus d’information inscrivez-vous à la liste locale OSM de Grenoble

    [FR Gaillac] Atelier informatique libre - Le lundi 25 juin 2018 de 19h30 à 23h00.

    Un atelier d’informatique libre voit le jour au sein du chinabulle, pour créer un espace temps d’échange autour des solutions informatiques libres.

    [FR Marseille] PGDay France - Le mardi 26 juin 2018 de 08h30 à 17h30.

    Le PGDay France est un moment de rencontres et de conférences pour la communauté francophone de PostgreSQL.

    Les conférences s’adressent à tous les utilisateurs du logiciel étudiants, administrateurs systèmes, DBA, développeurs, chefs de Projets, décideurs.

    [FR Aiglun] Après-midi « Open data » et « Cartopartie » - Fête de l'été - Le mardi 26 juin 2018 de 15h00 à 19h00.

    Démarche participative et collaborative, il s’agit notamment de permettre aux associations, producteurs locaux, habitants et usagers de cartographier les services / activités qui constituent la richesse de notre territoire sur un outil libre (Openstreetmap).

    Les données publiques communales mises en ligne et la création d’un agenda partagé (à destination des associations) seront également valorisées.

    Les organisateurs du marché d’Aiglun proposeront de nombreuses animations à travers la fête l’été. Venez nombreux

    Tout l’après-midi marché bio et des producteurs locaux, animation musicale, balades avec les ânes, jeux, atelier de cartographie libre

    À 15 h, 16 h et 17 h visite du champ de lavande rendez-vous sur la place du marché

    À partir de 17 h dégustations des produits du marché préparés par le restaurant Le Pressoir Gourmand et grillades d’agneau

    À 18 h apéritif local offert par la mairie d’Aiglun, débat sur la cartographie et les données ouvertes

    [FR Quetigny] Découvrir, tester, installer Linux et d’autres logiciels libres - Le mardi 26 juin 2018 de 20h30 à 23h30.

    COAGUL est une association d’utilisateurs de logiciels libres et de GNU Linux en particulier.

    Nous utilisons toutes sortes de distributions GNU / Linux (Ubuntu, CentOs, Fedora, Debian, Arch…) et toutes sortes de logiciels pourvu qu’ils soient libres (VLC, LibreOffice, Firefox, Thunderbird, GPG, Tor, OpenNebula, LXC, Apache…).

    Nous partageons volontiers nos connaissances des logiciels libres et l’entraide est de mise dans nos réunions.

    Les permanences servent à se rencontrer et à partager nos expériences et notre savoir sur le logiciel libre.

    Vous souhaitez nous rencontrer nous vous accueillerons à notre permanence.

    On adore les gâteaux et les chocolats, vous pouvez donc en apporter-)

    [FR Le Mans] Permanence du mercredi après-midi - Le mercredi 27 juin 2018 de 12h00 à 17h00.

    Assistance technique et démonstration concernant les logiciels libres.

    [FR Rennes] Sécuriser son infrastructure - Le mercredi 27 juin 2018 de 18h30 à 21h00.

    La sécurité informatique ne repose pas que sur la qualité du code et le chiffrement (même s’ils sont essentiels), c’est aussi une question d’architecture.

    Vous (re)découvrirez quelques principes de sécurisation des infrastructures informatiques tels que la séparation des flux, la redondance et d’autres éléments pouvant améliorer la protection et la disponibilité des services.

    La conférence sera présentée par
      Thomas MICHEL
      Esprit Libre
      esprit-libre-conseil.com (link is external)

    mercredi 27 juin - 18h30

    FrenchTech Rennes - Saint-Malo
    2 rue de la Mabilais
    Rennes

    >>> S’inscrire

    [FR Montpellier] Rencontres des Groupes OpenStreetMap OSM - Le mercredi 27 juin 2018 de 19h00 à 22h00.

    Ces rencontres mensuelles se veulent être des instants conviviaux pour faire un compte-rendu des activités du mois précédent, mais aussi pour présenter les opérations et rendez-vous à venir que proposent les groupes HérOSM et le Collectif des Garrigues. Naturellement, elles sont également ouvertes à tout public.

    Si vous avez des propositions n’hésitez pas à compléter la page dédiée.

    Proposition de programme

    • En première partie de soirée, une initiation pour les débutants est prévue
    • Possibilité d’initiation à la contribution pour les débutants qui le désire
    • Préparation du dossier pour le budget de l’Opération Libre
    • Préparation de l’Opération Libre à Jacou
    • Travail sur les voies manquantes sur (enjeu évident de géocodage d’adresses, comme celles fournies par SIRENE ou FANTOIR par exemple
    • Petit topo sur la saisie des noms de rues à partir des données cadastre/fantoir par département
    • Propositions au sujet du calcul d’itinéraire multimodal (auto, vélo, piéton) dans les futures discussions

      • La pratique des cartoparties
      • Faut-il prioriser la cartographie de certains endroits (gares et arrêts de tram, par exemple) ?
    • Contributions libres

    Déroulement de la rencontre

    Nous vous présenterons les projets en cours, nous vous vous proposerons de contribuer, faire de la production de données, puis nous passerons à un instant convivial sur la terrasse.
    Comme d’habitude, chacun amène ce qu’il veut à manger et à boire pour un repas partagé.
    N’oubliez pas vos ordinateurs portables pour la séance de saisie

    Le dernier mercredi de chaque mois
    Mercredi 27 septembre 2017 de 19h00 à 22h00
    Mercredi 25 octobre 2017 de 19h00 à 22h00
    Mercredi 29 novembre 2017 de 19h00 à 22h00
    Mercredi 20 décembre 2017 de 19h00 à 22h00
    Mercredi 24 janvier 2018 de 19h00 à 22h00
    Mercredi 28 février 2018 de 19h00 à 22h00
    Mercredi 28 mars 2018 de 19h00 à 22h00
    Mercredi 25 avril 2018 de 19h00 à 22h00
    Mercredi 30 mai 2018 de 19h00 à 22h00
    Mercredi 27 juin 2018 de 19h00 à 22h00

    Mercredi 27 septembre 2017 de 19h00 à 22h00
    Le Faubourg - 15, rue du Faubourg de Nîmes, 34 000 Montpellier

    Tramway lignes 1, 2 et 4 arrêt Corum
    GPS Latitude 43.614186 | Longitude 3.881404
    Carte OpenStreetMap

    Le dernier mercredi de chaque mois.

    [FR Toulouse] Rencontres Tetalab - Le mercredi 27 juin 2018 de 20h30 à 23h30.

    Rencontre hebdomadaire des hackers et artistes libristes Toulousains.

    Ouvert au public tous les mercredi soir.

    Venez nombreux.

    [FR Choisy-le-Roi] Pas Sage en Seine - Du jeudi 28 juin 2018 à 10h00 au dimanche 1 juillet 2018 à 20h00.

    Le festival auto-organisé par vous et l’équipe de Pas Sage En Seine se tiendra du 28 juin au 1er juillet 2017 à Choisy-le-Roi dans et aux abords de la Médiathèque Louis Aragon.

    Nous vous invitons à participer à PSES2018 et venir participer à ses ateliers et conférences bien sûr, mais aussi installations, discussions et autres formes d’interventions.

    Des thèmes sont proposés, pas imposés, pour laisser place à la manifestation d’idées originales.

    Le Festival sera un moment convivial et festif pour décrire nos modes d’organisation, nos outils, nos perspectives, évoquer les usages d’autodéfense numériques faces aux perpétuelles manipulations sécuritaires.

    Le vendredi sera une journée spéciale consacrée au RGPD, et le samedi soir (lors de la micro-nocturne jusqu’à 21h30) vous pourrez assister à un concert de chiptune réalisé par le collectif Chip Bangers.

    L’Hacktiviste naît de cette prise de conscience intégrale. Il ouvre, détourne, invente tous les possibles, ou presque… Être et faire politiquement ensemble sera notre prochaine étape

    Le trajet depuis le centre de Paris prend une petite vingtaine de minutes uniquement (Gare du RER C Choisy-le-Roi).

    [FR Rennes] Conseil d’administration de Gulliver - Le jeudi 28 juin 2018 de 12h00 à 14h00.

    Gulliver tiendra son conseil d’administration à la Maison de la Consommation et de l’Environnement (MCE) le jeudi 28 juin 2018 à partir de 12 h. L’ordre du jour est donné dans le lien ci-dessous.

    Ce conseil d’administration est ouvert à tous. Toute personne, membre ou non membre de Gulliver, peut y assister (sauf CA exceptionnel signalé à l’avance), voir comment fonctionne notre association et y donner son avis.

    La MCE est située 42 bd Magenta à Rennes (plan d’accès). La salle réservée est celle de l’accueil.

    [FR Martigues] Permanence du jeudi de l'ULLM - Le jeudi 28 juin 2018 de 16h30 à 18h30.

    Comment utiliser et les Logiciels Libres.

    avec l’association des Utilisateurs de Logiciels Libres du Pays de Martégal (ULLM).

    28 2018 de 16h30 à 18h30 à la (quai des Anglais).

    Entrée Libre. Tout public.

    [FR Challans] Permanence Linux - Le jeudi 28 juin 2018 de 18h00 à 20h00.

    Chaque dernier jeudi du mois, Linux Challans vous donne rendez-vous à l’Albanera Café, 17 rue du Général Leclerc 85 300 Challans.

    Nous vous proposons lors de ces rendez-vous mensuels d’échanger autour du Libre, des conseils ou une assistance technique.

    Vous pouvez venir pour vous faire aider, ou aider, à installer et paramétrer une distribution GNU/Linux de votre choix ou des logiciels libres sur votre ordinateur.

    Recommandations

    • Sauvegardez vos données avant de venir.
    • Libérez de la place sur le disque dur (20 Go minimum) et défragmentez Windows si vous voulez le conserver.
    • Nous prévenir de votre passage via la messagerie.

    Vous pouvez aussi venir pour une première prise d’informations et de contacts.

    Nous vous attendons toujours plus nombreux

    [FR Bordeaux] Jeudi Giroll - Le jeudi 28 juin 2018 de 18h30 à 20h30.

    Les membres du collectif Giroll, GIROnde Logiciels Libres, se retrouvent une fois par semaine, pour partager leurs  savoir-faire et expériences autour des logiciels libres.

    Le collectif réalise aussi une webradio mensuelle, tous les second mardis du mois, à retrouver en direct sur le site de Giroll.

     Ses rencontres sont ouvertes à tous.

    [FR Peymeinade] Install-Party GNU/Linux - Le jeudi 28 juin 2018 de 19h00 à 21h00.

    Désormais tous les 4ᵉˢ mercredi du mois, Clic Ordi et Linux Azur vous proposent une install-party ouverte à tous et gratuite.

    • Découvrez un monde rempli de Papillons, licornes, mais surtout de manchots
    • Plus besoin de se soucier des virus et autres logiciels malveillants.
    • Le support de Windows Vista s’arrête dans un an, et les principaux logiciels ont déjà arrêté leurs mise à jour, réagissez
    • Ramenez vos ordinateurs obsolètes et donnez leur une seconde vie.

    Nous aimerions développer autour de Handy-Linux (et de sa future mouture avec Debian-Facile) afin de répondre à des besoins simples pour des personnes difficiles à former et pouvant se retrouver en fracture numérique).

    Nous sommes ouverts à tout, y compris à la bidouille sur l’atelier avec le fer à souder.

    Organisé conjointement par http://clic-ordi.com/fr et https://www.linux-azur.org

    [FR Vesseaux] Projection-débat du film « Nothing to hide » - Le jeudi 28 juin 2018 de 19h00 à 22h00.

    Ouverture des portes à 19h pour partager un moment de convivialité, discuter des choses et d’autres comme les logiciels libres, les données personnelles, la vie privée

    Il y a une buvette sur place, et vous pouvez également apporter un plat à partager ou biscuits apéro

    La projection du film documentaire Nothing to Hide aura lieu à 20h30, et sera suivie d’un débat pour répondre à vos questions

    « Dire que votre droit à la vie privée importe peu, car vous n’avez rien à cacher revient à dire que votre liberté d’expression importe peu, car vous n’avez rien à dire. Car même si vous n’utilisez pas vos droits aujourd’hui, d’autres en ont besoin. Cela revient à dire les autres ne m’intéressent pas », Edward Snowden

    Ce documentaire aborde le thème de la vie privée et des données personnelles.

    L’entrée est à prix libre (adhésion à l’association Vesseaux-Mère).

    [FR Paris] Soirée de Contribution au Libre - Le jeudi 28 juin 2018 de 19h30 à 22h30.

    Parinux propose aux utilisateurs de logiciels libres de se réunir régulièrement afin de contribuer à des projets libres. En effet, un logiciel libre est souvent porté par une communauté de bénévoles et dépend d’eux pour que le logiciel évolue.

    Nous nous réunissons donc tous les dans un environnement propice au travail (pas de facebook, pas de télé, pas de jeux vidéos, pas de zombies).

    Vous aurez très probablement besoin d’un ordinateur portable, mais électricité et réseau fournis.

    En cas de difficulté, vous pouvez joindre un des responsables de la soirée, Emmanuel Seyman (emmanuel (at) seyman.fr), Paul Marques Mota mota (at) parinux.org, ou Magali Garnero (Bookynette) tresorier (at) parinux.org.

    Pour obtenir le code d’entrée de la porte cochère, envoyez un mail au responsable.

    On peut amener de quoi se restaurer (Franprix, 8 rue du Chemin Vert, ferme à 22h)

    Regazouillez sur Twitter - Wiki des soirées

    Programme non exhaustif

    • Fedora (sa traduction)
    • Parinux, ses bugs et son infrastructure
    • April, … y a toujours quelque chose à faire
    • Open Food Facts/ Open Beauty Facts, sa base de données, ses contributeurs, sa roadmap
    • Schema racktables, son code
    • Agenda du Libre, mise à jour et amélioration du code
    • Ubuntu-Fr, son orga, ses événements
    • En vente libre, maintenance et commandes
    • Open street map, une fois par mois
    • Linux-Fr sait faire
    • en vente libre

    tout nouveau projet est le bienvenu.

    [FR Montpellier] Atelier du Libre Ubuntu et Logiciels Libres - Le vendredi 29 juin 2018 de 18h00 à 23h00.

    L’équipe de Montpel’libre vous propose une permanence Logiciels Libres, discussions libres et accompagnements techniques aux systèmes d’exploitation libres, pour vous aider à vous familiariser avec votre système GNU/Linux au quotidien.

    Le contenu de l’atelier s’adapte aux problèmes des personnes présentes et permet ainsi l’acquisition de nouvelles compétences au rythme de chacun.

    Vous pourrez y aborder plusieurs thèmes

    • Discussions conviviales entre utilisateurs autour de Linux en général
    • Préinscription aux prochains Cafés Numériques et Install-Party
    • Premières explorations du système
    • Installations et configurations complémentaires
    • Mise à jour et installation de nouveaux logiciels
    • Prise en main, découverte et approfondissement du système

    Les Ateliers du Libre ont lieu à la Mpt Melina Mercouri de Montpellier, tous les derniers vendredis de chaque mois de 18h00 à 20h00, sauf période de vacances.

    Entrée libre et gratuite sur inscription. Une simple adhésion à l’association est possible et auprès de la Mpt.

    Cet événement est proposé par le partenariat qui lie la Mpt Melina Mercouri de Montpellier et Montpel’libre.

    Toute une équipe de passionnés, vous propose l’animation de l’Atelier du Libre par les membres de Montpel’libre. Permanence Logiciels Libres, discussions libres et accompagnements des utilisateurs aux systèmes exploitation libres, Linux, sur le cyberespace de consultations libres.

    En fin de soirée, l’atelier fera progressivement place à un instant très convivial, les RDVL sont des rendez-vous mensuels de discussions sur le thème des logiciels libres, des arts libres, de l’open source et plus généralement de la culture du libre et du numérique.

    Cette soirée, très conviviale, se passe autour d’un repas partagé, chacun porte un plat, entrée, spécialité, dessert, boisson… Ordinateurs et réseaux disponibles.

    Notre équipe vous attend pour répondre à vos questions et satisfaire votre curiosité.

    Maison pour tous Mélina Mercouri 842, rue de la vieille poste, 34 000 Montpellier

    Bus ligne 9, La Ronde arrêt Pinville
    GPS Latitude 43.61354 Longitude 3.908768
    Carte OpenStreetMap

    Rendez-vous mensuel, tous les derniers vendredis, salle jamais le dimanche

    [FR Paris] Apéro April - Le vendredi 29 juin 2018 de 19h00 à 22h00.

    Un apéro April consiste à se réunir physiquement afin de se rencontrer, de faire plus ample connaissance, d’échanger, de partager un verre et manger mais aussi de discuter sur le logiciel libre, les libertés informatiques, fondamentales, l’actualité et les actions de l’April…

    Un apéro April est ouvert à toute personne qui souhaite venir, membre de l’April ou pas.

    N’hésitez pas à venir nous rencontrer.

    Où et quand cela se passe-t-il

    L’apéro parisien aura lieu vendredi 29 juin 2018 à partir de 19h00 dans les locaux de l’April.

    L’adresse
    April, 44/46 rue de l’Ouest, bâtiment 8, 75 014 Paris (entrée possible par la place de la Catalogne, à gauche de la Biocoop, au niveau des Autolib).
    Métros Gaîté, Pernety, Montparnasse. Sonner à « April » sur l’interphone.
    Le téléphone du local 01 78 76 92 80.

    L’Apéro a lieu à Paris notamment parce que le local s’y trouve ainsi que les permanents et de nombreux actifs. Pour les apéros dans les autres villes voir sur le pad plus bas.

    En ouverture de l’apéro nous ferons un court point sur les dossiers/actions en cours.

    Le glou et le miam

    Vous pouvez apporter de quoi boire et manger afin de reprendre des forces régulièrement. Nous prévoirons bien sûr un minimum vital.

    Vous pouvez vous inscrire sur le pad.

    [FR Dijon] Atelier de création numérique et électronique - Le vendredi 29 juin 2018 de 20h30 à 23h59.

    Le fablab et hackerspace l’abscisse vous propose comme tous les vendredis soir un atelier de création numérique et électronique.

    L’atelier est équipé de différents outils perceuse, CNC, Arduino, Raspberry Pi, ordinateurs, oscilloscope, multimètre.

    Une ressourcerie est à disposition, vous y trouverez des composants électroniques et des pièces détachées à prix libre.

    Vous pouvez venir découvrir l’atelier et les usagers du fablab à partir de 20h30.

    Vous pouvez aussi venir pour participer aux travaux numériques en cours, partager vos connaissances et vos savoir-faire.

    Tous nos travaux sont libres et documentés sous licence libre.

    [FR Saint-Jean-de-Védas] Repair Café - Le samedi 30 juin 2018 de 09h00 à 13h00.

    Nous vous proposons ce rendez-vous, où, bricoleurs, acteurs, bénévoles, associations, vous attendent pour vous aider à donner une deuxième vie à vos objets.

    Réparer ensemble, c’est l’idée des Repair Cafés dont l’entrée est ouverte à tous. Outils et matériel sont disponibles à l’endroit où est organisé le Repair Café, pour faire toutes les réparations possibles et imaginables. Vêtements, meubles, appareils électriques, bicyclettes, vaisselle, objets utiles, jouets, et autres. D’autre part sont présents dans le Repair Café des experts bénévoles, qui ont une connaissance et une compétence de la réparation dans toutes sortes de domaines.

    On y apporte des objets en mauvais état qu’on a chez soi. Et on se met à l’ouvrage avec les gens du métier. Il y a toujours quelque chose à apprendre au Repair Café. Ceux qui n’ont rien à réparer prennent un café ou un thé, ou aident à réparer un objet appartenant à un autre. On peut aussi toujours y trouver des idées à la table de lecture qui propose des ouvrages sur la réparation et le bricolage.

    Repair Café est un atelier consacré à la réparation d’objets et organisé à un niveau local, entre des personnes qui habitent ou fréquentent un même endroit, par exemple un quartier ou un village. Ces personnes se rencontrent périodiquement en un lieu déterminé, dans un café, une salle des fêtes ou un local associatif où des outils sont mis à leur disposition et où ils peuvent réparer un objet qu’ils ont apporté, aidés par des volontaires.

    Les objectifs de cette démarche alternative sont divers

    • réduire les déchets
    • préserver l’art de réparer des objets
    • renforcer la cohésion sociale entre les habitants des environs

    Seront présents

    • Autour.com : On se rend des services entre voisins, on partage des infos, on prête, on loue, on donne…
    • L’Accorderie : Est un système d’échange de services entre habitants d’un même quartier ou d’une même ville.
    • La Gerbe : Contribuer à la formation de citoyens éveillés, engagés et solidaires en offrant aux enfants et aux jeunes un espace privilégié d’expression et d’épanouissement Crèche, Centre de loisirs, Scoutisme, Ateliers, chacun peut y trouver un cadre pour son développement grâce au travail d’une équipe de professionnels et de bénévoles.
    • Les Compagnons Bâtisseurs : Prévoient d’amener des outils
    • Les Petits Débrouillards : est un réseau national de culture scientifique et technique, ils viendront avec pleins de conseils et une imprimante 3D.
    • Le Faubourg : Hébergera le Repear Café.
    • Montpel’libre : Sera là avec des pièces informatiques, pour essayer de reconditionner des ordinateurs, dépanner ceux qui ne fonctionnent plus, expliquer comment ça marche, faire comprendre le choix judicieux du logiciel libre, contourner l’obsolescence programmée grâce à GNU/Linux, comment réparer et entretenir son matériel soi-même, nous porterons un jerry.
    • TechLabLR : Accompagne les projets à composantes technologiques afin de les amener au pré-prototype, puis les guider vers les structures d’accompagnements.
    • Violons Dingues : Passionnés de la vie, des autres, de la culture, de l’art, du sport, de la mécanique, de la moto, de la photo, de la musique, des animaux, des insectes, des plantes, de l’environnement, enfin de tout ce qui circule (au propre comme au figuré) sur notre planète.
    • Zéro Waste Montpellier : La démarche « Zéro Waste » est une démarche positive pour aller vers une société zéro déchet et zéro gaspillage.

    • Maison des Associations, 18 bis rue Fon de l’Hospital, Saint-Jean-de-Védas, Occitanie, France

    • Adresse web http://montpel-libre.fr

    • Tags
      montpel-libre, repair-cafe, atelier

    [FR Casseneuil] Install Partie GNU/Linux - Le samedi 30 juin 2018 de 10h00 à 17h00.

    Le Samedi 30 Juin les bénévoles d’aGeNUx sont invités dans les locaux d’Avec 2L pour une Install-party.

    Venez découvrir et partager le monde du logiciel libre en toute sérénité.

    Animation Libre et non payante.

    Auberge Espagnole le midi.

    Avec 2L se situe derrière la poste de Casseneuil

    [FR Wintzenheim] Réunion du Club Linux - Le samedi 30 juin 2018 de 13h00 à 19h00.

    Comme tous les 3 samedis, le Club Linux de la MJC du Cheval Blanc se réunit et accueille toutes les personnes qui souhaitent découvrir ou approfondir Linux et les Logiciels Libres. Aucune compétence n’est demandée.  

    Pendant ces rencontres, informelles,

    • nous accueillons celles et ceux qui cherchent une réponse ou souhaitent découvrir Linux et les Logiciels Libres,
    • nous installons Linux sur des ordinateurs, la plupart des fois en « dual boot »(*), ce qui permet de conserver l’ancien système (par exemple Windows) et d’utiliser quand même, en choisissant au démarrage,
    • nous partageons nos recherches et nos découvertes, les nouveautés.

    Le Club Linux est également impliqué dans une démarche de libération des GAFAM (Google Apple Facebook Amazon Microsoft) et de promotion de solutions libres comme, entre autres, Wikipedia, Openstreetmap, les Framatrucs (*), les Chatons (*) et beaucoup d’autres.

    (*) : mais on vous expliquera

    [FR Villefranche-sur-Saône] Repaircafé - Le samedi 30 juin 2018 de 13h30 à 17h30.

    Dernier Repaircafé caladois mensuel de la saison avant les vacances.

    Avec la participation habituelle de la CAGULL.

    [FR Marseille] Install Party GNU/Linux - Le samedi 30 juin 2018 de 14h00 à 19h00.

    L’association (CercLL d’Entraide et Réseau Coopératif autour des Logiciels Libres) vous invite à une install party GNU/Linux, le, dans la salle du Foyer du Peuple 50 rue Brandis 13 005 Marseille.

    Vous avez envie de découvrir un système d’exploitation libre, simple d’utilisation, stable, rapide et sécurisé. Une nouvelle façon d’utiliser votre ordinateur.

    Vous vous sentez une affection naissante pour le Gnou et le, les mascottes de

    Au programme

    DÉCOUVERTE de l’univers des logiciels libres.

    INSTALLATION d’un environnement GNU/ Linux, ainsi que le meilleur des logiciels libres.

    Venez avec votre ordinateur, nous installerons ensemble une distribution avec un ensemble de et pour une utilisation quotidienne.

    Ouvert à tous – accessible aux débutant-e-s

    Une participation de 2 euros est demandée.

    L’adhésion à l’association est de 20 euros annuelle.(L’adhésion n’est pas obligatoire).

    Plan d’accés

    [BE Liège] Linux Install Party - Le samedi 30 juin 2018 de 14h00 à 18h00.

    Une Linux Install Party a lieu tous les derniers samedis du mois de septembre à juin, dans les locaux du Cyber Seniors Énéo de Grivegnée, où je suis animateur.

    L’accès et la participation à l’Install Party est ouvert à tous et est gratuit.

    Vous venez avec votre ordinateur et on y installe le Linux que vous désirez.

    Les installations commencent à 14h et finissent à 18h.
    Prévoyez de venir avant 17h, parfois ça peut durer longtemps.

    [FR Ivry sur Seine] Cours de l’Ecole du Logiciel Libre - Le samedi 30 juin 2018 de 14h30 à 18h30.

    Présentation de l’E2L

    Quel est le rôle de l’école du logiciel libre

    Tout d’abord, ce n’est pas une école comme les autres. Elle n’a pas d’établissement fixe, pas de cours de récréation, pas de carte d’étudiant, ni de diplôme de fin d’année.

    Comme toutes les écoles, son rôle est d’apprendre à ses élèves les logiciels libres, c’est-à-dire

    • comment en trouver de bons parmi les nombreux sites qui en proposent,
    • comment en prendre possession en fonction des licences,
    • comment les installer en fonction de ses besoins,
    • comment les tester et les utiliser,
    • comment en comprendre le fonctionnement pour ensuite les modifier,
    • comment écrire ses propres logiciels libres.

    En fait, l’école du logiciel libre est une université populaire, comme celles qui ont vu le jour en France à partir du 19ᵉ siècle, et dont le but est de transmettre des connaissances théoriques ou pratiques à tous ceux qui le souhaitent. Et pour atteindre ce but, sa forme juridique est de type " association à but non lucratif ".

    Comment fonctionne l’école

    Cette école étant une association, elle possède, comme toutes les autres, un bureau, élu chaque année en assemblée générale, pour l’administrer. Mais elle a aussi des responsables pédagogiques dont le rôle est essentiel, car ce sont eux qui établissent les programmes des cours en fonction des souhaits des adhérents, valident les candidatures des enseignants et affectent les sessions.

    Les membres du bureau et les responsables pédagogiques forment « l’encadrement de l’école ». Tous les membres « encadrants » doivent être membres de l’association.

    Les locaux où se déroulent les cours seront ceux que l’on veut bien nous prêter une salle des fêtes, un théâtre, une salle de réunion publique, un amphi dans une école publique, ou autre.

    Les thèmes des cours sont définis par les adhérents en fonction de leurs envies, de leurs besoins. Les cours sont ensuite décidés par les responsables pédagogiques de l’école en fonction des enseignants disponibles.

    Afin de permettre au plus grand nombre de participer et d’assister aux cours, les sessions se tiennent essentiellement le samedi. Une première de 9h à 12h30, et une autre de 14h à 17h30.

    Programme détaillé sur le site http://e2li.org

    [FR Courbevoie] Assemblée Générale annuelle de l'association StarinuX - Le samedi 30 juin 2018 de 14h30 à 17h00.

    L'association GULL StarinuX vous invite à  son

    ASSEMBLÉE GÉNÉRALE annuelle

    le samedi 30 juin 2018 à 14h30,

    48 rue de Colombes 92 400 Courbevoie

    (SNCF Gare de Courbevoie,  Saint Lazare <=> La Défense).

    Seuls les adhérent(e)s peuvent voter, mais les discussions restent ouvertes à tous les présents.

    Un déjeuner facultatif aura lieu à 12h30.

    Au plaisir de nous rencontrer à l’AG 2018

    Le Bureau de StarinuX

    [FR Poucharramet] Festival AgitaTerre - Le dimanche 1 juillet 2018 de 09h30 à 23h00.

    L’association 3PA Formation vous invite à la cinquième édition du Festival AgitaTerre Nous vous donnons rendez-vous le dimanche 1er juillet au coeur du village de Poucharramet (31), entre la place des Marronniers et La Maison de la Terre

    Venez découvrir des alternatives durables, locales et citoyennes qui font vivre notre territoire. Cette année, le festival investit le thème des Communs venez en apprendre plus

    Un événement gratuit et tout public

    9h30-18h

    Marché de producteurs et artisans-créateurs locaux
    Forum associatif & Village des Communs

    Conférences
    Expositions « C’est quoi les Communs »
    Ateliers tous publics

    Expositions d’artistes sculpteurs sur bois
    Mur d’expression libre
    Vannerie géante collective

    Concerts
    Spectacles et animations

    Buvette & Restauration
    Espace enfants

    20h30 Grand concert en plein air avec notre partenaire La Maison de la Terre

    Programmation et exposants sur www.agitaterre.fr

    Infos agitaterre@3paformation.fr // 3PA 05.61.08.11.30

    Parking sur place
    Adapté aux personnes à mobilité réduite

    Commentaires : voir le flux atom ouvrir dans le navigateur

  • 3 outils pour développeur : MailHog, Tokei et Pandoc (Dépêches LinuxFR)

    Dans cette dépêche, je vais vous présenter trois outils que j'utilise de temps en temps et qui pourrait servir à d'autres développeurs :

    • MailHog permet d'attraper des courriels pour les examiner ;
    • Tokei compte les lignes de code d'un projet ;
    • Pandoc est un couteau suisse pour manipuler des fichiers et les transformer d'un langage de markup à un autre.

    MailHog

    MailHog (sous licence MIT) permet d'attraper des courriels envoyés par une plateforme de développement et de les afficher dans une interface web. Pour cela, il fournit un serveur SMTP et un remplaçant du binaire sendmail, libre à vous de choisir le moyen qui vous convient le mieux. Il offre également, en option, la possibilité de transférer vers un vrai serveur SMTP les courriels et un outil de type chaos-monkey pour tester les cas d'erreurs d'envoi de courriels.

    L'interface web de MailHog avec 3 courriels capturés

    Je m'en sers quand je développe sur la partie serveur de Cozy Cloud. Cela permet de tester des fonctionnalités qui nécessitent l'envoi de courriels sans avoir à se compliquer la vie à configurer un vrai serveur d'envoi de courriels. En bonus, on évite de prendre le risque d'envoyer des courriels vers des vrais comptes d'autres personnes et on ne perd pas de temps à attendre que le courriel arrive, en attente d'un traitement anti-spam.


    Tokei

    Pour estimer la taille d'un projet, le nombre de lignes de code peut être une métrique intéressante. Il existe plusieurs projets pour faire ça, celui que je trouve le plus pratique est Tokei (sous licence Apache ou MIT). Voici ce qu'il affiche pour le dépôt principal de code de LinuxFr.org :

    -------------------------------------------------------------------------------
     Language            Files        Lines         Code     Comments       Blanks
    -------------------------------------------------------------------------------
     CoffeeScript           10          770          642           31           97
     Dockerfile              1           70           49            4           17
     HTML                   24         2660         2161            4          495
     JavaScript             11         2686         2025          394          267
     Markdown                1          187          187            0            0
     Rakefile                2           33           24            3            6
     Ruby                  262        11593         8338         1500         1755
     Ruby HTML               1           47           46            0            1
     Sass                   47        27317        23467         1583         2267
     Shell                   4           68           50            4           14
     SVG                    41        10886        10865           17            4
     TeX                     1           53           43            0           10
     Plain Text             44          531          531            0            0
     XML                     1           11           11            0            0
     YAML                    4          173          160            4            9
    -------------------------------------------------------------------------------
     Total                 454        57085        48599         3544         4942
    -------------------------------------------------------------------------------

    Par rapport à cloc, Tokei a plusieurs avantages :

    • il est beaucoup plus rapide (0,03 seconde pour Tokei contre 3,2 secondes pour cloc sur le dépôt principal de LinuxFr.org) ;
    • il est plus précis : cloc utilise des expressions rationnelles alors que Tokei a de vrais parsers (en particulier, un début de commentaire dans une chaîne de caractères comme printf("/*") peut bien induire en erreur cloc) ;
    • il ignore par défaut les fichiers listés dans .gitignore (par exemple, quand j'ai lancé cloc sur l'exemple ci-dessus, il a compté les fichiers dans tmp/cache et j'ai du le relancer avec des options pour qu'il fasse ce que j'en attendais).

    Pandoc

    Il existe de nombreux langages de markup : HTML, Markdown, reStructuredText, textile, DocBook, \LaTeX, MediaWiki markup, OrgMode, Epub, etc. Et ces langages ont parfois plusieurs variantes (exemple : CommonMark et GitHub Flavored Markdown pour le Markdown). Bref, ce n'est pas toujours facile de connaître les différents langages et de passer de l'un à l'autre. Pandoc (sous licence GPLv2 ou plus) permet de convertir un texte de la plupart de ces langages vers un autre langage, ou d'autres choses comme du PDF ou du LibreOffice.

    Je m'en sers, par exemple, pour écrire des présentations en markdown et en générer une version PDF via la classe Beamer pour \LaTeX. Ça m'a également servi, par le passé, pour convertir un wiki d'un format à un autre.

    Commentaires : voir le flux atom ouvrir dans le navigateur

  • Inventaire de matos (Journaux LinuxFR)

    Bonjour

    Je suppose que je suis mauvais pour trouver des logiciels qui correspondent à mon besoin. Il y a quelques semaines j’avais besoin de retranscrire une interview, je ne trouvais pas de logiciel pour le faire sur le coup, or il existe le site otranscribe ou le logiciel Parlatype, j’ai découvert ces deux possibilités quelques jours après avoir galéré avec mpv et gedit…

    Je travaille dans une UMR (un institut de recherche) et j’avais besoin d’inventorier notre matériel (lasers, photodiode, filtre, analyseur, lunettes de protection,…). Je ne trouvais rien qui réponde vraiment à mon besoin. J’ai fini par commettre INVENTAIRE.

    Mon besoin est le suivant :
    - outil en ligne pour être accessible depuis n’importe quel poste (intranet, pour l’instant, tout le monde à tous les droits)
    - associer directement différents documents (data-sheet, caractérisation,…)
    - gérer les différents entretiens (nettoyage, calibration,…) avec des icônes en fonction du temps restant
    - un journal disponible pour chaque composant listé (pour suivre les aventures de laser22 et la fabuleuse calibration d’analyseur_de_spectre12)
    - plusieurs inventaires peuvent être créés (plusieurs équipes ou domaines par exemple…)
    - des sections « administratif » et « technique » clairement différenciées pour permettre de remplir uniquement une partie si on le souhaite.
    - Si on affiche une seule catégorie, il est possible de trier en fonction des caractéristiques spécifiques à celle-ci

    Ça donne un listing :
    listing

    Une page réussissant toutes les infos pour chaque composant :
    detail

    D’autres captures d’écran sur https://github.com/yeKcim/inventaire/

    Je ne suis pas développeur, le code (php, mysql) est donc très certainement crade, mais je me dis que cela peut
    - soit rendre service à quelqu’un d’autre et avoir des avis
    - soit avoir un commentaire m’expliquant que je viens d’inventer la roue octogonale alors que la roue circulaire existe depuis longtemps.

    Lire les commentaires

  • Toulouse Hacking Convention : 9 mars 2018 (Dépêches LinuxFR)

    Le 9 mars 2018, l’ENSEEIHT de Toulouse accueillera la seconde édition de la Toulouse Hacking Convention.

    Il s’agit d’une journée de conférences tournant autour de la sécurité, suivie par une soirée/nuit de capture du drapeau (Capture The Flag ou CtF) constituée d’épreuves dans de multiples domaines (cryptographie, ingénierie inverse, exploitation de vulnérabilités, failles Web…). Le tout dans une ambiance conviviale et avec des membres de la communauté du Libre. :)

    Il s’agit de la seconde édition, la première ayant été un franc succès puisque nous avons accueilli autour de 150 participants aux conférences, et 80 participants au CTF.

    Les conférences de l’année dernière allaient de la rétro‐ingénierie de puces en regardant leurs transistors, à la désobfuscation automatique de code, en passant par un jeu de rôle de sensibilisation à la sécurité informatique. Les vidéos sont d’ailleurs disponibles sur YouTube.

    Inscrivez‐vous rapidement, les inscriptions vont fermer d’ici peu !

    Le programme de cette année n’est, à ce jour, pas finalisé ; mais il sera annoncé sous peu. Vous pouvez déjà trouver une première version sur le site.

    Lire les commentaires

  • Falkon 3 le nouveau navigateur pour KDE (Dépêches LinuxFR)

    Vous souvenez‐vous de Qupzilla, petit projet commencé par le tout jeune David Rosca pour apprendre Qt, puis devenu un excellent navigateur WebKit ? En juillet 2017, pendant la réunion annuelle du projet KDE, l’Akademy, David Faure a proposé de remplacer Konqueror par Qupzilla.
    Après quelques mois d’incubation, le bébé sort des éprouvettes : Falkon 3.01 est disponible depuis le 8 mai 2018. C’est un navigateur moderne, dont les onglets tournent dans des processus séparés, en utilisant QtWebEngine, lui‐même basé sur Chromium pour le rendu.
    Logo du navigateur Falkon
    Il n’y a pas de grosses différences avec la dernière version de Qupzilla 2.2.6, c’est essentiellement une transposition vers le système de construction de KDE. Il faut bien commencer.

    Les utilisateurs de Konqueror seront en terrain familier pour la partie Web et le menu de configuration, en revanche la navigation de fichiers n’est pas encore intégrée. Il faut bien commencer (bis).

    Falkon protège bien votre vie privée (gestion des Cookies, de JavaScript, de HTML 5, Do Not Track), vous propose un greffon Flash (Pepper Flash), plusieurs moteurs de recherche (Duck Duck Go par défaut), un gestionnaire de sessions, des onglets avec indicateurs, un traducteur de pages Web, un validateur de code, des thèmes, une page « Speed Dial » facile à gérer, retrouve le contenu du formulaire quand on fait « précédent » — je reprends ma respiration, regardez les images :

    Les indicateurs (cliquables) sur les onglets :
    Onglets avec indicateurs
    Le (très pratique) gestionnaire de sessions :
    Gestionnaire de sessions dans Falkon
    Le (sympathique) menu déroulant « clic droit » :
    Le menu contextuel de Falkon

    Et comme il est jeune et crashe un peu, Falkon recharge automatiquement tous les onglets ouverts. À ce stade, vous le constatez sans doute, c’est dans l’esprit de KDE : un mélange de simplicité et de « super‐pouvoirs » à portée de configuration.

    Quelques extensions disponibles :

    • AdBlock, (San Ku Kaï c’est la bataille) contre les pubs ;
    • KWallet Passwords, un portefeuille pour les gérer tous ;
    • Vertical Tabs, les onglets bien dégagés sur les oreilles ;
    • AutoScroll, pour les claustros qui craignent les ascenseurs ;
    • Flash Cookie Manager, protège plus que plus la vie privée ;
    • GreaseMonkey, soyez le maîîîître du navigateur (scripts dispos sur http://openuserjs.org/) ;
    • ImageFinder, qui recherche par l’image, par l’image trouvera ;
    • Mouse Gesture, pour les souriceaux maniaques ;
    • PIM, pour jouer dans les formulaires ;
    • StatusBar Icons, oh que c’est zouli ces petites friandises là en bas !
    • Tab Manager, « Onglets ! Au rapport ! »

    Les WebExtensions qui sont déjà gérées par Chrome/Chromium, Firefox, Edge et Opera ont encore un long chemin à parcourir.

    L’extension ImageFinder en menu déroulant :
    Recherche par l’image sur Falkon
    L’extension Vertical Tabs en mode hiérarchique :
    Onglets verticaux dans Falkon

    D’ores et déjà, Falkon est un navigateur à mon goût : avec toutes les extensions, plusieurs onglets et trois fenêtres ouvertes, il tourne comme un charme sans charger le système ; je n’ai pas de problème sur les sites Web, ou alors tellement mineurs que je fais avec.

    Falkon est disponible pour GNU/Linux dans vos distributions et aussi en AppImage et Flatpak (via le dépôt KDE), sous Windows (à partir de Win 7) et macOS (à venir).

    Commentaires : voir le flux atom ouvrir dans le navigateur

  • La gestion de l'authentification sous Linux avec PAM (Laboratoire Linux SUPINFO)

    La gestion de l'authentification sous Linux avec PAM

     

    Note: ce document est le second d'un cycle de trois articles sur l'authentification sur les systèmes Linux. Le premier se trouvant ici et le troisième .

    Il est possible de personnaliser finement tous les aspects de l'authentification des utilisateurs Linux et ce pour chaque application du système.

     

    Linux-PAM

    En effet, il a été choisi de centraliser le mécanisme d'authentification système sous Linux pour plusieurs raisons :

    • afin d'éviter de réimplémenter les mêmes schémas d'authentification dans tous les logiciels.
    • ne pas avoir à recompiler toutes les applications lors du changement des méthodes d'authentification.
    • permettre à l'administrateur de choisir quel mécanisme d'authentification chaque application utilise.

    Ces raisons ont conduit à la naissance de Linux-PAM (pour Pluggable Authentication Modules, soit en français Modules d'Authentification Enfichables).

    Avant PAM, pour pouvoir authentifier un utilisateur, une application faisait appel aux bibliothèques du système (via getpwnam() par exemple) qui la plupart du temps (à moins que NSS ne lui dise d'utiliser une autre source ailleurs) regardaient dans les fichiers /etc/passwd et /etc/shadow pour vérifier l'existence de l'utilisateur et la validité de son mot de passe. Cette technique fonctionnait mais n'était pas très souple pour les raisons évoquées précédemment.

    Dorénavant, une application compatible PAM délègue cette tâche à Linux-PAM (via un appel à la PAM-API), et celui-ci, suivant les directives inscrites dans ses fichiers de configuration, autorise ou non l'authentification.

    Mais PAM ne s'occupe pas seulement de la vérification du mot de passe. Il offre un total de six primitives d'authentification grâce à des modules fournissant certaines fonctions. Ces primitives sont regroupés dans les quatre catégories que voici :

    account
    • Gère la disponibilité du compte. Cette disponibilité regroupe l'accès au serveur sur lequel est stocké le compte, mais aussi si l'utilisateur est autorisé à utiliser ce compte à ce moment donné et par ce moyen. Par exemple on pourra spécifier qu'il n'est autorisé à se connecter qu'entre 8h30 et 17h00 et seulement en console.
    auth
    • Premièrement, c'est dans cette catégorie que l'on vérifie le moyen d'authentification (le mot de passe, le jeton, etc).
    • Ensuite c'est ici que l'on affecte les credentials de l'utilisateur, c'est à dire ses privilèges et les groupes auxquels il appartient.
    password
    • Les modules classés dans cette catégorie permettent simplement de mettre à jour le jeton d'authentification de l'utilisateur. Cela peut être parce que ce jeton à expiré, ou, si c'est un mot de passe, parce que l'utilisateur veut le modifier.
    session
    • Mise en place de la session
    • Fermeture de la session
    Pour ces deux aspects, cela prend en compte l'écriture dans les journaux système, l'affichage d'un message personnalisé, l'assignation des variables d'environnement, ou bien encore le montage/démontage de certains lecteurs.

     

    Les fichiers de configuration

    La configuration de PAM peut se faire de deux façon différentes. Soit dans un fichier unique nommé /etc/pam.conf ou soit dans une série de fichiers situés dans le répertoire /etc/pam.d. À noter que la présence de ce répertoire fait que PAM ignorera le fichier pam.conf.
    La façon la plus claire de faire et aussi la plus répandue est l'utilisation du dossier pam.d et c'est cette méthode que je vais détailler ici.

    Chaque fichier du répertoire pam.d gère la configuration du service homonyme. Par exemple le fichier /etc/pam.d/sudo configure l'authentification faite par l'intermédiaire de l'outil sudo.
    Il y a cependant une exception à cela. Le fichier /etc/pam.d/other contient la configuration pour les services n'ayant pas leur propre fichier.

    Ensuite, ces fichiers sont tous organisés suivant le même schéma. Ils sont composés d'une suite d'instructions qui constituent ce que l'on nomme une pile. Chaque instruction est inscrite sur une ligne et chaque ligne est organisée comme ci-dessous :

    catégorie contrôle chemin-du-module arguments-du-module

    Ces lignes sont donc empilées les unes au-dessus des autres pour combiner les actions des modules qui les composes. On pourra par exemple avoir une ligne ayant un module d'authentification vers un serveur LDAP, suivi d'une autre avec un module d'authentification vers un serveur Kerberos pour enchaîner ces deux méthodes.

    Dans l'instruction d'exemple ci-dessus, la catégorie est choisie parmi celles décrites dans la section précédente (account, auth, password ou session).

    Le contrôle est le comportement que la PAM-API doit adopter lorsque le module échoue à sa tâche. Il peut soit prendre la forme d'un simple mot clé, ou soit une forme plus compliquée composée d'une suite de valeur=action entourées de crochets.

    Voici les valeurs que peut prendre ce contrôle lorsque c'est un simple mot clé :

    required Si un module required échoue, un statut d'erreur sera retourné par la PAM-API, mais seulement après avoir exécuté les autres instructions du fichier ayant la même catégorie.
    requisite Comme pour required un statut d'erreur est retourné si un module requisite échoue, mais cependant la main est directement redonné à l'application appelante sans exécuter les modules suivants de la pile. Le statut d'erreur retourné est celui du premier module required ou requisite à échouer.
    sufficient Si aucun module précédent n'a échoué et l'exécution de ce module est un succès, les autres instructions de la pile ne sont pas exécutés et la main est redonnée à l'application en lui signalant la validation de l'authentification.
    Si le module échoue, son statut de retour est ignoré et le reste des instructions de la pile est exécuté.
    optionnal Le succès ou l'échec d'un tel module n'est important que s'il est le seul module de la pile de cette catégorie, sinon son statut de retour est ignoré.

     

    Quant à la syntaxe complexe du contrôle, elle a la forme suivante :

    [valeur1=action1 valeur2=action2 ...]

    valeurN correspond au code de retour de la fonction invoquée dans le module. Ce code de retour dépend des modules et est l'un des suivants (pour connaître ceux que peut renvoyer un module, se reporter à la page de manuel de celui-ci) :

    success Succès de l'établissement de la session.
    open_err Le module ne peut pas être ouvert (par exemple il peut ne pas être trouvé).
    symbol_err Un objet nécessaire au module (par exemple un fichier) est introuvable.
    service_err Une erreur interne au module est survenue.
    system_err Une erreur système est survenue (par exemple si l'appel à la PAM-API n'est pas formaté correctement).
    buf_err Une erreur mémoire est survenue.
    perm_denied Une permission d'accès à été refusée à l'utilisateur.
    auth_err L'authentification à échouée. Cette erreur arrive généralement car le jeton (ou mot de passe) est invalide.
    cred_insufficient Pour une raison quelconque l'application n'a pas les privilèges nécessaires pour authentifier l'utilisateur.
    authinfo_unavail Les informations d'authentification sont inaccessibles. Par exemple si ces informations sont sur un serveur LDAP et qu'il y a une coupure réseau, ce statut sera retourné.
    user_unknown L'utilisateur est inconnu.
    maxtries Le nombre maximal d'essais pour l'authentification à été atteint.
    new_authtok_reqd Le compte utilisateur est valide mais le jeton à expiré. L'action généralement faite par l'application suite à ce statut est de demander à l'utilisateur de changer son jeton.
    acct_expired Le compte utilisateur à expiré.
    session_err L'établissement de la session à échouée.
    cred_unavail Impossible de retrouver les credentials de l'utilisateur.
    Les « credentials » sont tout ce qui identifie de manière unique l'utilisateur, comme par exemple son numéro identifiant, les groupes auquel il appartient, etc.
    cred_expired Les credentials de l'utilisateur ont expirés.
    cred_err Impossible d'assigner ses credentials à l'utilisateur.
    no_module_data Des données spécifiques au module n'ont pas été trouvées.
    conv_err Erreur de conversation.
    authtok_err Le module n'a pas été capable d'obtenir un nouveau jeton d'authentification (par exemple lors du changement de celui-ci).
    authtok_recover_err Le module n'a pas été capable de retrouver l'ancien jeton.
    authtok_lock_busy Le module n'a pas été capable de changer le jeton d'authentification car celui-ci était verrouillé.
    authtok_disable_aging Le vieillissement du jeton (en vue de son expiration) à été désactivé.
    try_again Les tests préalables au changement du jeton d'authentification ont échoués, réessayer plus tard. Ces tests peuvent être par exemple le bon accès au serveur Kerberos si le jeton est un ticket Kerberos.
    ignore Ignorer le résultat de ce module. Il ne participera donc pas au code de retour de la pile de modules.
    abort Erreur critique, sortie du module immédiate.
    authtok_expired Le jeton d'authentification a expiré.
    module_unknown Le module est inconnu.
    bad_item L'application a essayée de définir ou d'accéder à un objet non disponible (un fichier par exemple).
    conv_again  
    incomplete  
    default Toute valeur précédemment listée non mentionnée explicitement.

     

    Quant à actionN il peut prendre une des formes suivantes :

    ignore Lorsqu'utilisé sur une pile de modules (donc que ce n'est pas le seul module de cette catégorie), le statut de retour de ce module ne participera pas au choix du code de retour envoyé à l'application.
    bad Cette action indique que le code de retour doit être considéré comme indicatif si le module échoue. Si ce module est le premier de la liste à échouer, sa valeur sera utilisée comme valeur de retour après l'exécution des autres instructions.
    die Équivalent à bad avec comme effet de quitter immédiatement la pile de modules (sans exécuter les modules suivants) et redonner la main à l'application.
    ok Cette action dit à PAM que le statut de retour de ce module doit contribuer directement au code de retour global renvoyé par la PAM-API après avoir lu la pile de modules. Autrement dit, si le statut renvoyé initialement devait être PAM_SUCCESS, le statut de retour du module remplacera cette valeur. À noter tout de même, si l'état initial de la pile était un code d'échec, cette valeur ne serait pas remplacée.
    done Équivalent à ok avec comme effet de quitter immédiatement la pile de modules (sans exécuter les modules suivants) et redonner la main à l'application.
    N (un entier non signé) Équivalent à ok avec comme effet de sauter les N modules suivants de la pile. Un N égal à 0 n'est pas permis (et serait égal à ok).
    reset Efface le statut de retour de la pile de modules et recommence avec le prochain module.

     

    En sachant cela, les quatre mots clés de la forme simple (required, requisite, sufficient et optionnal) peuvent se représenter de la façon suivante avec la syntaxe complexe :

    • required : [success=ok new_authtok_reqd=ok ignore=ignore default=bad]
    • requisite : [success=ok new_authtok_reqd=ok ignore=ignore default=die]
    • sufficient : [success=done new_authtok_reqd=done default=ignore]
    • optionnal : [success=ok new_authtok_reqd=ok default=ignore]

    L'élément suivant des instructions est le chemin-du-module qui peut être soit le chemin complet vers le module, ou soit le chemin relatif depuis le dossier par défaut des modules (cela peut être par exemple /lib/security, /lib64/security, /lib/x86_64-linux-gnu/security/, etc).

    Enfin, on termine les instructions par les argument-du-module. Pour les connaître, il faut consulter la page de manuel du module en question. Les arguments étant séparés par des espaces, afin de pouvoir placer un espace dans un argument, il faut entourer celui-ci de crochets.

     

    Les modules

    Les modules sont au cœur du système PAM. C'est grâce à eux que l'on peut définir le schéma d'authentification. Ils s'occupent chacun de la gestion d'un mécanisme d'authentification spécifique.
    Voici une liste des modules les plus communs :

    Nom Catégories compatibles Description courte
    pam_access.so Toutes Détermine l'endroit depuis lequel l'utilisateur à le droit de se connecter (en local, depuis telle adresse IP, etc...)
    pam_debug.so Toutes Aide à débugger le comportement de PAM en renvoyant le code de retour demandé par l'utilisateur.
    pam_deny.so Toutes Refuser l'accès de l'utilisateur. On invoque généralement ce module après avoir essayé les autres méthodes d'authentification.
    pam_echo.so Toutes Retourne un message texte personnalisé.
    pam_env.so Auth
    Session
    Permet de définir les variables et de supprimer les variables d'environnement de la session utilisateur.
    pam_exec.so Toutes Exécute une commande personnalisée.
    pam_faildelay.so Auth Change le délais d'attente avant de considérer l'authentification comme un échec pour une application.
    pam_filter.so Toutes Peut se placer pour filtrer les entrées/sorties entre l'utilisateur et l'application. Il peut par exemple forcer les minuscules surt tout ce que l'utilisateur écrira une fois loggé. Ne fonctionne cependant que pour les tty et les applications basées sur stdin/stdout.
    pam_ftp.so Auth Permet de se connecter à un serveur FTP.
    pam_getenv.so   Récupère les variables d'environnement depuis le fichier /etc/environment.
    pam_group.so Auth Assigne à l'utilisateur les groupes auquel il appartient.
    pam_issue.so Auth Affiche le contenu d'un fichier issue (par défaut /etc/issue) avant le prompt de l'utilisateur.
    pam_krb5.so Toutes Permet l'authentification via un serveur Kerberos.
    pam_lastlog.so Session Affiche une ligne d'information sur la dernière connexion de l'utilisateur.
    pam_ldapd.so Toutes Permet l'authentification via un serveur LDAP.
    pam_limits.so Session Permet de limiter l'usage des ressources système à l'utilisateur (charge CPU, nombre maximal de processus, etc).
    pam_listfile.so Toutes Accepte ou refuse l'authentification des utilisateurs en fonction du contenu d'un fichier.
    pam_localuser.so Toutes N'accepte que les utilisateurs listés dans le fichier /etc/passwd.
    pam_loginuid Session Applique l'UID de l'utilisateur au processus demandant l'authentification.
    pam_mail.so Auth
    Session
    Affiche un message si l'utilisateur a de nouveaux emails.
    pam_mkhomedir.so Session Créé le répertoire de l'utilisateur ci celui-ci n'existe pas.
    pam_motd.so Session Affiche le message du jour (par défaut le contenu du fichier /etc/motd).
    pam_mount.so Auth
    Session
    Donne la possibilité de monter un disque local ou distant à l'ouverture de la session utilisateur.
    pam_mysql.so ? Permet l'authentification via un serveur MySQL.
    pam_namespace.so Session Créé un espace de nommage pour la sessions (voir plus de détails dans la page de manuel du module).
    pam_nologin.so Account
    Auth
    Empêche les utilisateurs non-root de se connecter.
    pam_permit.so Toutes Module qui autorise tout le temps l'accès. À utiliser avec précaution pour des raisons de sécurité.
    pam_pwhistory.so Password Retient les anciens mots de passe des utilisateurs pour forcer à en avoir un différent lors du renouvellement de celui-ci.
    pam_rhosts.so Auth Permet l'authentification des utilisateurs sur la machine locale par SSH.
    pam_rootkok.so Auth Authentifie l'utilisateur sans avoir besoin de rentrer un mot de passe, du moment que son UID est 0 (l'UID de l'utilisateur Root).
    pam_securetty.so Auth Restreint la connexion de Root aux tty (terminaux) listés dans /etc/securetty.
    pam_selinux.so Session Met en place le contexte de sécurité pour la session qui s'ouvre.
    pam_sepermit.so Account
    Auth
    L'authentification est permise seulement si l'utilisateur possède une entrée dans fichier /etc/security/sepermit.conf.
    pam_shells.so Account
    Auth
    Autorise l'authentification seulement depuis les shells listés dans /etc/shells.
    pam_succeed_if.so Toutes Valide l'authentification suivant des tests faits sur les caractéristiques de l'utilisateur (nom, UID, GID, shell, home, etc).
    pam_tally2.so Account
    Auth
    Maintient un compteur du nombre d'essais d'authentifications. Ce compteur est réinitialisé lorsque l'authentification réussie. Utile pour bloquer un compte après un certain nombre de tentatives ratées.
    pam_time.so Account Permet de restreindre l'accès de l'utilisateur suivant l'heure de la journée, le jour de la semaine, le service sur lequel il se connecte et le terminal depuis lequel il se connecte.
    pam_timestamp.so Auth
    Session
    Permet de valider automatiquement l'authentification sans demander de mot de passe si la dernière authentification réussie est inférieur à une certaine date.
    pam_tty_audit.so Session Permet d'activer l'enregistrement de ce que l'utilisateur écrira dans un tty.
    pam_umask.so Session Définie l'umask sur la création des fichiers pour la session qui s'ouvre.
    pam_unix.so Toutes Authentification via les mécanismes standard, c'est à dire en faisant appel aux bibliothèques du système (ces dernières regardant par défaut dans les fichier /etc/passwd et /etc/shadow).
    pam_userdb Account
    Auth
    Authentification via une base de données Berkeley DB.
    pam_warn.so Toutes Module qui inscrit dans les logs l'authentification de l'utilisateur.
    pam_wheel.so Account
    Auth
    Autorise l'accès seulement aux utilisateurs du groupe wheel (ou du groupe au GID 0 si le groupe wheel n'existe pas).
    pam_winbind.so Toutes Permet l'authentification via un serveur Active Directory.
    pam_xauth.so Session Permet de conserver les clés xauth (cookies du serveur X) lors du changement de session.

     

    Il existe bien d'autres modules qui permettent d'utiliser tout types de serveurs pour l'authentification ou d'autres types de jetons (comme par exemple des cartes magnétiques). Mais vu qu'ils sont utilisés plus rarement, je vous laisse les découvrir par vous même.

     

    Conclusion

    PAM est un mécanisme très puissant pour la gestion de l'authentification sous Linux. Bien qu'assez complexe sur certains aspects, il permet à l'administrateur d'avoir un total contrôle de l'accès au système par les utilisateurs. C'est aussi un point clé lorsque l'on veut centraliser l'authentification des machines d'un réseau.

     

    Ressources supplémentaires

     

  • Rumeurs sur l'hyper-threading - TLBleed (Journaux LinuxFR)

    La peinture de la dépêche sur la faille Lazy FPU save restore n'étais pas encore sèche
    que je tombais sur de curieux messages conseillant de désactiver l'Hyper-threading.

    Suivis de conversations plus ou moins inquiétantes sur Twitter et dans les mailings list.

    Accroche toi au pinceau

    Un commit sur OpenBSD désactive l' Hyper-treading par défaut.
    Le message associé est explicite:

    « Since many modern machines no longer provide the ability to disable Hyper-threading in
    the BIOS setup, provide a way to disable the use of additional
    processor threads in our scheduler. And since we suspect there are
    serious risks, we disable them by default
     »
    Puisque les machines récentes ne donnent plus la possibilité de désactiver l' Hyper-threading depuis le BIOS, trouvez un moyen de désactiver l'utilisation des threads d'un processeur dans notre ordonnanceur.
    Et comme on suspecte que le risque est sérieux, désactivons le par défaut.

    Pour faire plus court, j'avais lu auparavant un laconique:

    ps deactivate Hyper-threading on your server
    Désactivez l'Hyper-threading sur vos serveurs !

    Venant des équipes OpenBSD, il y a de quoi s'interroger.

    J'enlève l'échelle

    La conférence Black Hat qui se déroulera en août prochain, propose au menu:

    « This therefore bypasses several proposed CPU cache side-channel protections. Our TLBleed exploit successfully leaks a 256-bit EdDSA key from libgcrypt (used in e.g. GPG) with a
    98% success rate after just a single observation of signing operation on a co-resident hyperthread and just 17 seconds of analysis time
     »
    En outre, ceci court-circuite plusieurs protections sur le cache. Notre exploit TLBeed a réussi à voler une clef 256-bit EdDSA depuis ligcrypt (utilisée par GPG ) dans 98% des tentatives, après une simple observation des opérations de signature depuis un thread tournant sur le même CPU en seulement 17 secondes d'analyse.

    Colin Percival, auteur en 2005 de:

    1. un papier sur les attaques via les caches, Cache Missing for Fun and Profit
    2. un article qui cible plus particulièrement les risques liés à l'Hyper-threading

    en remet une couche:

    « I think it's worth mentioning that one of the big lessons from 2005 is that side channel attacks become much easier if you're executing on the same core as your victim »
    Je pense qu'il est bon de rappeler cette grande leçon de 2005: une attaque en side channel est tellement plus facile si vous l'exécutez sur le même cœur que votre victime.

    Cuisine

    Intel n'est jamais clairement impliqué; mais je précise, comme ça, en passant, que l'Hyper-Threading est une implémentation Intel du Simultaneous Multi Threading.
    Il s'agit de faire exécuter en parallèle, sur un même cœur, plusieurs unités fonctionnelles ou de calcul.
    Et pour rendre cette technique efficace et moins gourmande en ressource, cette implémentation partage aussi les caches mémoires.

    Keep systems protected, efficient, and manageable while minimizing impact on productivity

    Conclusion

    Toutes les solutions de sécurité aujourd’hui ne sont que des châteaux forts construit sur du sable.

    Si encore une fois, la désactivation de l'Hyper-threading pourrait même avoir des effets positifs sur les performances, autant en finir une fois pour toute.

    Retour aux origines:

    • un partage complet sans protection des ressources
    • plus de mode protégé
    • pas même de segmentation mémoire

    Vos machines iront encore plus vite. Enfin, j'espère.

    Commentaires : voir le flux atom ouvrir dans le navigateur

  • Tutoriel 3D - 2D découpe au laser, le retour du tux (Journaux LinuxFR)

    Sommaire

    Tranche de pingouin

    Chose promise, cause perdue. Voici comment transformer un modèle 3D en tranches de bois pour découpe laser. Et en bonus, mon essai initial de découpe en création originale.

    Les outils que j’ai utilisé sont blender et inkscape, et ce juste parce que je les connaissais et donc plus facile pour expérimenter.

    Note aux amateurs de freecad, j’ai commencé à regarder comment ça marche, au cas où ce serait plus simple avec, si jamais je trouve une idée et le courage de refaire un tuto, ça me fera un zeugma.

    Au début était le cube

    Ouvrir un nouveau fichier dans blender et mettre la scène en métrique, car sinon les mesures ne sont pas fixées par taille réelle. Notez que à chaque étape du tuto on aura des soucis de conversion de dimensions, donc en fait… mais bon faut pas en profiter pour être négligent.

    où trouver le changement metrique

    Retirer le cube et ajouter le Tux à la scène. Vous pouvez le trouver ainsi que toutes les licences à Tuuuuuuux

    • Faire face au tux (1 au pavé num)
    • Mettre la vue iso (5 au pavé num)
    • sélectionner le tux
    • passer en editor mode (tab)
    • Sélectionner le dessous des pattes (B) qui est rond
    • Niveler (SZ0)
    • sélectionner les deux centres des pattes, (S) Snap cursor to selected
    • rebasculer en object mode (tab) , transform origine to 3d cursor (object/transform)

    Maintenant, le tux est calé pour avoir le plancher des pattes en comme origine, à la verticale du pseudo centre de gravité que nous venons de choisir.

    mettre la bête en Z 0.

    Il est gros vot manchot ?

    Il nous faut choisir une taille, suffisamment grosse pour que ce soit cool, et pas trop gros pour limiter le prix. Comme l’objet c’est aussi tester une bonne quantité d’épaisseurs pour voir comment ajuster la taille théorique d’une planche par rapport à sa taille réelle (il reste du vide, la colle ça épaissit, les planches sont pas forcément pile à la taille).

    Une planche 2mm chez sculpteo (chez qui je teste la découpe laser) fait 94cm*59cm, il faut aussi essayer de rester dans une seule planche avec tous les morceaux. Le tux est presque aussi large que haut, du coup on cherche une approximation de cube découpé en tranches et étalé fait la même surface en gardant un peu de marge. ça fait 55 tranches, donc une hauteur de 116.875mm

    Et si on l’écartelait ?

    Il nous faut séparer les pattes du corps du tux (ce sont des objets distincts dans le modèle de base en fait et elles s’interconnectent :

    Tux pattes interconnectées

    Il faut les réunir par booléen union au corps pour avoir un seul objet avec un intérieur/extérieur propre.

    tux vue pattes melees

    On peut maintenant appliquer une subdivision sur le tux CTRL+3, parce que le tux aime la douceur, et pas que celle angevine.
    c'est mieux avec les pattes creuses, c'est comme les heures à l'edf

    Lui sculpter des yeux plus sympa, parce que même si tout le monde ne veut pas l’avouer, pour avoir l’air cool faut quand même avoir un peu l’air con.

    tux sculptation des yeux (ou sculptage selon les régions)

    la même en couleur

    Mais quand est-ce qu’on coupe ?

    Patience, il faut regarder un peu avant de couper. Placer un plan plus grand que le tux au sol, genre 20cmx20cm et lui appliquer un booléen d’intersection avec le tux. Et regarder en bougeant le plan sur Z comment seront les tranches.

    On voit deux endroits à problème, les ailes et la queue qui auront des tranches avec plus que un morceau, ce qui est plus complexe à coller.

    par ex les ailes :

    ailes dissociées

    Ce sera lourd à coller ensuite, on peut mais pourquoi…

    autant relier les ailes au tronc le plus légèrement possible, avec un lien de 1mm de large.

    idem au niveau de la queue :

    queue perdue

    J’ajoute un bloc en union au niveau de la queue, le plus ajusté possible par un booléen union.

    jointure queue

    Cela vous permettra de facilement coller, il sera toujours possible de le limer après collage.

    Il faut bien nettoyer le résultat de l’union à l’intérieur du tux, ne pas laisser de cloisons internes, c’est à dire éviter d’avoir des plan à l’intérieur des plans :

    retirer les morceaux à l’intérieur des autres

    Finir de nettoyer en retirant les doublons de vertices, boucher les trous, assurer les normales pour que ce soit clair ce qui est à l’intérieur et à l’extérieur.

    Et si on l’empalait ?

    Pensons au support central qui va nous permettre de facilement positionner et coller les tranches de tux, il va être en trapèze et ressembler à ça au niveau d’une tranche :

    plan des tranches

    Le choix de la découpe sera donc toujours du côté le plus grand, en bas. Donc notre référence pour le positionnement des plans de découpe doit être la face basse de chaque tranche.

    Replaçons le plan à 0.01mm en Z (pour éviter le chevauchement parfait des surface avec les pattes Z=0), pensez à remettre tous les éléments avec scale=1 (Ctrl+A scale and rotation) pour la suite.

    Faire une array de 50 plans en Z espacés de 2.125mm, faire le booléen intersection avec le tux. Lors de la réalisation de mon bureau réel avec des tux, j’ai constaté que l’empilage de x tranches de 2mm n’a pas un résultat de x*2mm, mais avec l’air restant et la colle environ 2.125. Je vais affiner avec ce tux cette estimation mais déjà on part de 2.125mm par tranche.

    On voit les tranches et on voit des petits problèmes

    problème de tranche

    Une tranche qui manque en haut et le cul qui a une mini tranche en bas.

    Diminuer le overlap thresold du booléen pour que le problème du haut disparaisse :

    option thresold

    Remonter le point du bas du tux pour supprimer le second problème et non, ce n'est pas lui mettre un doigt dans le cul car ça ne doit pas rentrer :

    trou du cul de tux

    Nickel !

    bonnes tranches

    Simulons une épaisseur des tranches pour avoir un aperçu du résultat réel, ajoutons au plan un modifier solidify 2mm avec l’offfet à +1 (vers le haut) pour suivre le plan d’avoir la face basse comme référence :

    simul résultat final

    Le résultat est conforme, retirez le solidify, il ne doit pas interférer avec l’étape de création du lien central.

    On l’empale plus ?

    Mais si, mais si. En fait ce n’est pas obligatoire, mais ça facilite le positionnement des étages, et on peut aussi le garde sans le coller. Le lien central doit avoir une forme de trapèze et être parfaitement vertical, car pour l’instant sculpteo ne fait pas de découpe oblique.

    Il doit faire une épaisseur égale à celle du bois. Pour mon exemple je suis resté sur mon approximation (2.125mm) mais normalement il faut prendre 2mm et ajuster avec l’épaisseur du kerf qui est la taille du laser laissant un vide de découpe autour du trait de coupe. En pratique lors de mon premier essai j’ai eu des soucis d’épaisseur et j’ai du poncer mon trapèze. Du coup comme ce n’est pas nécessaire d’ajuster. Je surestime cette fois-ci la taille du trapèze.

    trapeze

    Il faut ajuster sa position pour qu’il traverse tout le tux, coup de chance c’est possible sur ce modèle en plaçant la traverse au centre de la dernière tranche du tux. Mais sinon on l’aurait simplement fait avec deux trapèzes sur deux hauteurs.

    Ajustez la taille en X et la hauteur de la partie haute pour faire joli, elle va dépasser un peu et même arrondir sa tête (note postérieure en pratique le trapèze sera toujours trop court, il faut juger les tranches encore un peu plus grand que 2.125mm).

    tete de tux

    En dessous ajuster aussi la taille en X pour donner un beau trapèze

    mise en trapeze

    On voit que c’est moche au niveau du pied

    tux chaplin

    On va donc remodeler un peu le trapèze pour qu’il soit plus joli à cet endroit.

    remodelage du pied

    aspect final

    Parlons peu, parlons kerf

    Le kerf c’est la partie du bois éliminée par le laser, en pratique la découpe est plus petite que le plan car le laser à une taille non ponctuelle. la découpe de la traverse dans les tranches sera donc un peu plus grande que prévu, et la traverse découpée plus court aussi que prévu.

    Dans ce modèle, on peut ignorer le kerf et accepter les différences, elles seront minimes et les pièces collées seront bien ajustées.

    appliquons donc le booléen différence entre le plan des tranches et la traverse

    Le résultat est difficile à voir mais en vue fil de fer c’est visible

    vue fil de fer du tux trapeziste

    C’est la lutte finale

    On peut passer à la phase finale, on réalise les “modifier” sur les planches, puis on aplati le trapèze en retirant les vertices d’un côté.

    En mode éditeur, on sépare toutes les tranches (P+loose parts en mode édition) et on les étale dans le bon ordre en vue du dessus. Attention, les numéros générés lors de la réalisation de l’array ne sont pas forcément dans l’ordre de Z…

    Pour ne pas me planter, je me met dans une vue adaptée et je bouge une par une les tranches avec des gx0.1 … Je vérifie bien que tout est dans l’ordre puis je met tout le monde à plat (sélectionner tout A puis SZ0)

    Nous allons avoir des soucis de conversion de taille entre blender puis Inkscape puis sculpteo… on commence par poser un étalon dans blender, un plan au sol de 1cm sur 90cm

    90cm etalon

    Le petit oiseau va sortir

    Enfin presque, il faut encore à faire la photo !

    Il existe une option de rendering qui génère du svg.

    Mettons la caméra au dessus en mode orthographique, d’abord une résolution 100% sur un ratio approximatif de mon rectangle incluant tout.

    100 pourcent

    puis placer la caméra assez bien au dessus de la scène et changez les paramètres :

    ortho

    L’échelle orthographique est ce qui correspond au zoom, ajustez la valeur pour que tout rentre au plus juste

    Tout doit rentrer dans la fenêtre de rendering :

    serrez les rangs

    Maintenant depuis les user pref, activez le svg freestyle exporter :

    options rendering

    Et activez les deux options freestyle et svg export depuis les options rendering

    option rendering activee

    Pressez F12, une image svg sera générée dans le répertoire indiqué dans output nommé 0001.svg,

    Ouvrez le dans Inkscape, dégroupez et sélectionnez l’étalon. mettez lui une épaisseur de contour à 0 pour ne pas fausser la taille et regardez sa taille. Dans mon cas je tombe sur 35.719cm.

    Je vais donc changer la résolution de l’image pour ajuster la taille d’un facteur de 90/35.719=2.52

    Je change dans blender le render pour :

    retailler

    Re F12 et vérification.

    Mon étalon fait maintenant 1cm sur 90.01cm.

    aller, on essaie avec un pixel de moins en Y :), on tombe sur 89.987. C’est moins bon, retour en arrière.

    Maintenant que l’on a les bonnes tailles dans Inkscape, il faut nettoyer. Parce que le freestyle a introduit des pixels de temps en temps.

    Je prends donc chaque découpe pour la repositionner au mieux et aussi supprimer les traces.

    points artefacts

    Pour m’aider et aussi servir d’étalon entre Inkscape et sculpteo je place un cadre dans une autre couleur qui délimite ma sélection, 53.5cm de large sur 75cm de haut.

    Et je fais tout rentrer dedans.

    Je vérifie chaque pièce pour assurer qu’il n’y a pas de défaut, et j’assure les contours à 1px et mon cadre avec une couleur différente

    C’est prêt.

    planche à découper

    Pour ceux qui sont plus observateurs que moi, vous verrez que j’ai oublié de grouper une fente dans une tranche. Moi je vais le voir au montage plus tard…

    TuxOlaser

    J’upload chez sculpteo.

    Deux couleurs sont détectées, l"une correspond au noir et l’autre au rouge du cadre. Les mesures n’ont pas été conservées, je ne sais pas pourquoi… mais mon cadre me permet de choisir un ajustement de taille à 26.5% qui me redonne les bonnes dimensions.

    Je peux alors désactiver le cadre rouge dans sculpteo (style 2 sur aucun et voila !

    prêt à couper.

    Livraison comprise il vous en coûtera 53.33€.

    Pour info, les tux du bureau ont coûté moins cher, ils étaient en une seule livraison et un peu plus petits, 72€ les 3.

    Déboitage du tux et montage

    Je hais les video de unboxing, et me voilà moi même à déboiter…

    Bon, puisqu’il faut :

    la boite est bien protégée

    boite

    et la planche dans la mousse

    planche entourée de mousse

    Les pièces sont tenues par du scotch, il faudra faire attention en retirant le scotch de ne pas casser les pièces fragiles.

    scotch sur les pieces

    Je numérote mes pièces avant de défaire, c’est moins cher que de faire des numéros au laser.

    sans scotch à numéroter

    Ensuite on empile jusqu’à la fameuse pièce 33 qu’il faudra redécouper.

    debut d'empilage

    piece 33

    redecoupe de la 33

    piece 33 empilee

    Tadaaaa

    Entrer une description pour l'image ici

    A propos de licences

    J’ai fouillé pour trouver les licences attachées au modèle de base, les voici :

    https://opengameart.org/content/tux

    https://opengameart.org/sites/default/files/license_images/gpl.png

    http://www.gnu.org/licenses/gpl-3.0.html

    https://opengameart.org/sites/default/files/license_images/cc-by.png

    http://creativecommons.org/licenses/by/3.0/

    Les fichiers

    Voila les fichiers sources blender et le inkscape (piece 33 corrigée)

    fichier blender

    fichier svg

    Commentaires : voir le flux atom ouvrir dans le navigateur

  • Mageia 6 est sortie (Dépêches LinuxFR)

    La très attendue Mageia 6 est enfin disponible. Des problèmes de compatibilité avec des périphériques pas très libres — mais très utilisés — sont la cause principale de ce retard.

    En attendant cette sortie, la communauté des développeurs avait publié la robuste version 5.1 qui sera maintenue pendant encore trois mois. L’enjeu était de faire mieux et d’éviter les régressions.

    De nombreux testeurs utilisent au quotidien cette version depuis la parution de la version candidate. Elle semble tenir toutes ses promesses :

    • passage à Wayland par défaut pour GNOME (X.org reste disponible) et vous pouvez l’essayer avec KDE Plasma ;
    • ajout du média autonome (live) avec l’environnement Xfce, aux côtés des classiques KDE Plasma et GNOME, le tout sous GRUB 2 remplaçant de GRUB 1 ;
    • ajout de dnf2 en tant que gestionnaire de paquetages alternatif au classique urpmi et de l’interface graphique dnfdragora en plus du classique rpmdrake ;
    • prise en charge d’AppStream pour ajouter des méta‐données aux outils comme GNOME Logiciels (GNOME Software) et Plasma Discover pour découvrir des logiciels à installer ;
    • retour de la portabilité sur processeur ARM (pour les plus aventureux).

    Sommaire

    Les nouveautés principales de Mageia 6

    Bien qu’il ne s’agisse pas d’une nouvelle fonctionnalité, Mageia 6 prend en charge plus de 25 environnements de bureau et gestionnaires de fenêtres (les détails seront disponibles lors d’une prochaine publication sur le blog) ! Que ce soit KDE Plasma 5.8.7 (LTS), GNOME 3.24.2, MATE 1.18, Cinnamon 3.2.8, Xfce 4.12.1, LXQt 0.11…

    KDE Plasma

    Le passage de Qt 4 à Qt 5 permet d’alléger notablement KDE Plasma, que l’on ne peut plus qualifier de lourd.
    Presque toutes les applications KDE 4 ont été migrées vers Plasma, de sorte que vous bénéficierez d’une belle expérience unifiée.

    GNOME

    Le serveur d’affichage Wayland est activé par défaut, l’utilisation de X.Org reste possible au besoin, si votre matériel est défaillant. Sur les processeurs graphiques Intel (voire AMD et sans doute NVIDIA), l’interface HDMI est gérée de base pour envoyer la vidéo vers un écran LCD ; le Bluetooth aussi, pour envoyer l’audio sur votre chaîne Hi‐Fi.

    Les extensions GNOME Shell les plus classiques sont disponibles en paquets de base : hibernate-status, alternate-tab, apps-menu, auto-move-windows, common, drive-menu, launch-new-instance, native-window-placement, onboard, overrides, places-menu, screenshot-window-sizer, user-theme, window-list, windowsNavigator et workspace-indicator, permettant d’utiliser GNOME au clavier efficacement tout en conservant quelques fonctionnalités utiles.

    Xfce et les autres…

    Une version autonome (live) est distribuée en ISO aux côtés de KDE Plasma et GNOME pour permettre de tester un environnement plus léger. Vous pouvez tester sur clef USB ou DVD. Voici la gamme complète des images ISO de Mageia :

    • installation classique DVD pour 32 bits ;
    • installation classique DVD pour 64 bits ;
    • DVD autonome GNOME 64 bits ;
    • DVD autonome Plasma 64 bits ;
    • DVD autonome Xfce 32 bits ;
    • DVD autonome Xfce 64 bits.

    En synthèse des mises à jour

    Tous les logiciels dans les dépôts ont été reconstruits et mis à jour pour inclure les derniers et les plus importants logiciels de l’écosystème libre, vous trouverez ci‐dessous quelques‐uns des principaux composants inclus dans cette version :

    • système de base : noyau Linux 4.9.35 (LTS), systemd 230, X.org 1.19.3, Wayland 1.11.0, Mesa 17.1.4 ;
    • bibliothèques graphiques : Qt 5.6.2 (LTS), GTK+ 3.22.16 ;
    • environnements de bureau : Plasma 5.8.7 (LTS), GNOME 3.24.2, MATE 1.18, Cinnamon 3.2.8, Xfce 4.12.1, LXQt 0.11 ;
    • applications : LibreOffice 5.3.4.2, Firefox 52.2.0 ESR, Thunderbird 52.2.1, Chromium 57.

    Dans le détail des nouveautés de Mageia 6

    Prise en charge de Wayland

    Wayland est un protocole de serveur d’affichage plus simple et plus efficace que l’architecture de X.Org qui utilise un gestionnaire de fenêtres composite fonctionnant de concert avec le système X Window.

    Avec l’introduction des compositeurs (permettant des effets de transparence, d’ombre portée, etc.), X.Org ne peut plus être performant, car il constitue une étape supplémentaire entre l’application et le compositeur, ainsi qu’entre le compositeur et le matériel.

    Wayland a été proposé pour succéder à X11 : un serveur Wayland joue à la fois le rôle de compositeur (gestionnaire de fenêtres) et de serveur d’affichage.

    Wayland est donc une évolution majeure dans l’architecture GNU/Linux, même si elle n’est que peu visible pour la majorité des utilisateurs. Une couche logicielle est fournie pour faire fonctionner les anciennes applications, via une version spéciale du serveur X.Org fonctionnant au‐dessus de Wayland : XWayland.
    Une conséquence possible de la disponibilité de Wayland devrait être la disponibilité de jeux nécessitant un affichage performant.

    MCC : le Centre de contrôle Mageia

    Cet utilitaire qui permet de configurer le système contribue fortement à la réputation de Mageia. Il est hérité de Mandrake, puis de Mandriva Linux, et s’est perfectionné au fil des années et des versions. Il a bénéficié d’une heureuse cure de jouvence. De nouvelles icônes ont joliment amélioré la convivialité de MCC.

    Exemple de menu du MCC
    Cette illustration vient de la version anglaise mais, rassurez‐vous, Mageia vous propose une version française lors de l’installation. Mageia est certainement la plus française des grandes distributions.

    Ajout de DNF2

    Proposé par Fedora, dnf a été logiquement intégré à Mageia. Il est disponible en plus de l’outil classique d’installation urpmi.

    Les apports d’AppStream

    Les utilisateurs bénéficient de l’outil dnfagora dans la continuité de rpmdrake, pour une interface graphique améliorée et cohérente. Cela permet à l’utilisateur de rechercher un logiciel correspondant à son besoin, en se basant sur des méta‐données consolidées entre distributions.
    C’est un apport en complément du travail de Debian pour http://madb.mageia.org, avec les copies d’écran des applications graphiques. Il y a aussi la possibilité de participer à l’assurance qualité de Mageia

    Mageia 6 pour l’architecture ARM

    Le portage ARM (re‐)prend vie : démarré avec Mageia 1, il est désormais disponible sur les miroirs pour architecture armv5tl et armv7hl (respectivement ARMv5 et ARMv7, ce qui inclut le Raspberry Pi). Attention, cela reste réservé aux aventureux, des images d’installation pourront être disponibles par la suite, si suffisamment de personnes se montrent intéressées.

    Par exemple, les serveurs de base de données PostgreSQL 9.4 et 9.6 sont disponibles : http://madb.mageia.org/package/list/t_group/68/application/0/arch/armv7hl/page/2.
    Pour ceux intéressés, vous pouvez aussi suivre le statut des paquets inclus selon l’architecture : https://pkgsubmit.mageia.org/arm-status.html.

    Participer à l’activité de Mageia et de sa communauté

    Nos amis francophones de MLO sont très actifs dans le soutien en français aux utilisateurs de la distribution avec tutoriels et forums officiels pour Mageia.

    Pour autant, la difficulté à sortir une distribution dans les temps a pesé pour certains :

    • Mageia 5 est sortie en juin 2015 ;
    • Mageia 5.1 est sortie en décembre 2016 ;
    • Mageia 6 arrive enfin en juillet 2017, pour une date initiale (re‐)planifiée en mars ou mai 2017, mais initialement prévue en août 2016, reportée à décembre 2016 pour diverses raisons ;
    • entretemps Cauldron (la version de dév’) a continué d’évoluer, pris en compte Wayland notamment, des mises à jour de beaucoup de logiciels (et de jeux) sur le mode de la publication continue — rolling release — (« jouez aux dés », si vous en avez envie, c’est votre choix, cela a été le nôtre pendant toute cette période).

    C’est un vrai travail de motivation et de recrutement, d’accueil de nouveaux contributeurs qui a permis la sortie de cette version Mageia 6. En bref, vous êtes les bienvenus à rejoindre le projet et à le faire perdurer (ce qui nous tient à cœur et nous motive, pouvant permettre à chacun d’apprendre beaucoup plus qu’il n’en aurait espéré de son passage sous GNU/Linux). Les contributeurs à Mageia sont présents sur la plupart des événements du Libre : FOSDEM, RMLL, JDLL, POSS, premiers samedis, Kernel Recipes, etc. N’hésitez pas à venir à notre rencontre !

    Comme Mageia 5 est bien maîtrisée, vous avez au moins jusqu’au 31 octobre 2017 pour passer à Mageia 6 qui, elle, vous permettra d’être tranquille jusqu’au 16 janvier 2019. :-)

    Bon passage à Mageia 6 ! _o/*

    Lire les commentaires

  • Un petit tour des systèmes de build (Journaux LinuxFR)

    Sommaire

    Parlons un peu de systèmes de build.

    Mon métier consiste à programmer des jeux vidéos destinés aux plates-formes mobiles Android et iOS. Ce qui est commun aux deux plates-formes, c’est-à-dire la plus grosse partie de l'application, est écrit en C++, et ce qui est spécifique à la plate-forme est en Java ou en Objective-C. L'intérêt principal de tout faire en C++ est que les développeurs peuvent lancer l'application directement sur leur poste de travail, sous Linux ou OSX, et tester leurs modifs sans payer le prix d'un émulateur ou du transfert sur un appareil mobile.

    L'inconvénient est que l'on se retrouve à gérer des builds sur quatre plates-formes.

    Pour compiler une application pour iOS il faut nécessairement un projet Xcode, bien que les bibliothèques puissent être compilées classiquement en ligne de commande. Cela signifie qu'il faut maintenir un fichier de projet Xcode ou alors avoir un outil pour le générer.

    Côté Android la compilation du code C++ se fait avec l'outil ndk-build, qui est en réalité une interface à GNU Make. Du coup les fichiers de projet sont évidemment des makefiles mais utilisant des variables et fonctions d'une sorte de framework dans le langage de Make. Là encore il faut maintenir des makefiles pour le projet, ou avoir un outil pour les générer.

    Pour Linux et OSX la compilation peut se faire avec des outils plus classiques mais évidemment pas avec les fichiers de build iOS ou Android. Et encore une fois il faut maintenir ces fichiers de build.

    À moins qu'on ait un outil pour les générer tous…

    Quelques systèmes de build

    Le problème de la gestion de la compilation d'un projet a été posé bien avant ta naissance ; c'est pour cela qu'il n'existe qu'une seule méthode pour le faire, qui fait consensus depuis des décennies.

    Ha ! Ha ! Ha !

    Je peux te citer déjà douze outils de tête. Voyons un peu la présentation faite sur leurs sites respectifs et essayons de rester de bonne foi.

    Make

    D'après le site :

    GNU Make est un outil qui contrôle la génération d'exécutables et autres fichiers non-source d'un programme à partir des fichiers source du programme.

    J'ai mis la description du site de GNU Make mais la première version de Make date d'avril 1976. Elle précède ainsi le projet GNU de sept ans.

    Le principe de base de Make est assez simple, on lui passe un fichier Makefile qui indique « voilà le fichier que je veux créer, il dépend de ces autres fichiers, et voilà les commandes à exécuter pour le créer ». Avec le mécanisme des dépendances l'outil se débrouille pour créer les cibles dans l'ordre.

    Il m'arrive encore de créer des petits Makefiles manuellement mais c'est vite pénible. Par exemple, si un binaire app est créé à partir d'un fichier a.cpp qui inclut un fichier b.hpp qui inclut lui-même un fichier c.hpp, en toute rigueur je dois lister ces trois fichiers en dépendances de la cible app pour que la compilation soit refaite quand l'un d'eux est modifié. On fait ça une fois puis on cherche un truc pour que les dépendances soient gérées automatiquement.

    Un autre point difficile à gérer concerne la dépendance au fichier Makefile lui-même. Par exemple, si j'ajoute une option qui concerne l'édition des liens, celle-ci ne sera pas refaite par défaut.

    Autotools

    [Le premier objectif des Autotools] est de simplifier le développement de programmes portables. Le système permet au développeur de se concentrer sur l'écriture du programme, simplifiant de nombreux détails de portabilité entre systèmes Unix et même Windows, et permettant au développeur de décrire comment construire le programme via des règles simples plutôt que des Makefiles complexes.

    Si vous avez déjà utilisé les autotools vous êtes probablement morts de rire en lisant ce paragraphe. Cette suite d'outils qui se présente comme simple et portable est en réalité ce qu'il y a de plus complexe en système de build et n'est portable que sur les systèmes Unix en évitant soigneusement Windows, le plus déployé des systèmes des trente dernières années.

    Sans doute révolutionnaire à sa création, cet outil a extrêmement mal vieillit. Pour ma part j'ai eu l'occasion de compiler des logiciels tiers sous Windows avec ça et c'était tout simplement l'enfer. J'ai aussi tenté de l'utiliser pour mes propres projets et je me suis arrêté dans le tuto. Depuis je suis convaincu que ces outils sont faits pour les développeurs qui aiment transpirer.

    SCons

    SCons est un outil Open Source de construction de logiciel—plus précisément, une nouvelle génération d'outil de construction. Voyez SCons comme un substitut amélioré et multi-plateforme pour l'utilitaire Make classique avec des fonctionnalités intégrées similaires à autoconf/automake et aux caches de compilation tels que ccache. Pour faire court, SCons est un moyen plus facile, plus fiable et plus rapide de construire un logiciel.

    Wow, là c'est carrément le futur.

    Les fichiers SCons s'écrivent directement en Python, ce qui est assez sympa puisqu'on se retrouve avec un vrai langage et un a accès à un tas de bibliothèques pour décrire le projet.

    J'ai compilé quelques projets en SCons il y a une quinzaine d'années et je crois que je n'ai jamais rien vu d'aussi lent. Et pas seulement parce que c'est du Python…

    Il faut dire que le comportement par défaut de l'outil est de détecter les modifications des fichiers sources en calculant un md5 des fichiers, pour éviter de recompiler des fichiers dont seule la date a changé. Quand on voit le prix d'un md5 je trouve ce choix très discutable. Ce comportement peut être modifié via une option mais même en passant sur une comparaison de timestamps et en appliquant toutes les astuces connues pour le rendre plus rapide, ça reste hyper lent.

    Premake

    Un système de configuration de construction puissamment simple
    Décrivez votre logiciel qu'une seule fois, via la syntaxe simple et facile à lire de Premake, et construisez-le partout.
    Générez des fichiers de projets pour Visual Studio, GNU Make, Xcode, Code::Blocks, et plus sous Windows, Mac OS X et Linux. Utilisez l'intégralité du moteur de script Lua pour que la configuration de la construction devienne du gâteau.

    Pfiou, ça claque ! Ce n'est que le quatrième dans la liste et ça promet déjà de tout résoudre

    Avec Premake les scripts de builds sont écrits en Lua et, à l'instar de SCons, cela permet de « programmer » son build en profitant de tout un tas de bibliothèques.

    Sur le papier c'est très sympa, en pratique ça ne marche pas trop comme attendu. Il s'avère que la syntaxe de Premake est déclarative et ne se mélange pas bien avec le procédural de Lua. Par exemple, si j'écris

    project "P"
    
    if false then
        files
        {
          "file.cpp"
        }
    end
    

    On pourrait croire que le fichier file.cpp ne fera pas partie du projet P, et bien pas du tout, le if ne change rien du tout ici. Difficile de programmer dans ces conditions.

    Nous utilisons Premake depuis presque quatre ans au boulot. Le choix s'est fait en sa faveur bien que l'outil était en alpha car il permettait de générer des fichiers pour Xcode et ndk-build via deux plugins indépendants, en plus des Makefiles classiques. Aussi, il avait l'air facile à hacker ce qui était rassurant.

    Maintenant j'essaye de le remplacer autant que possible.

    Parmi les problèmes récurrents le plus pénible est certainement le message error: (null), sans autre info, que l'outil affiche parce qu'une erreur s'est glissée dans un script. Bonne chance pour déboguer ça. J'aime aussi beaucoup le message Type 'premake5 --help' for help qui s'affiche quand je fais une faute de frappe sur la ligne de commande. Là encore il n'y a aucune information utile et il faut se débrouiller pour trouver où on s'est trompé. Autre souci : il n'y a pas moyen de mettre des propriétés de link spécifiques à une bibliothèque. C'est embêtant quand on a besoin d'un -Wl,--whole-archive.

    Le développement de Premake en lui-même a l'air très laborieux. Quatre ans après il est toujours en alpha, avec une release datant d'août 2017. Le module Xcode a été intégré mais ne gère que OSX. Il a fallu réappliquer toutes nos modifs pour iOS. Quant au module pour le NDK il ne fonctionne plus suite à des changements dans Premake (hey, c'est une alpha…). Là encore il a fallu repatcher.

    Il y a de nombreux contributeurs, dont des gros, mais chacun a l'air d'aller dans sa propre direction sans qu'il y ait d'objectif commun. Il y a par exemple deux générateurs de Makefiles, gmake et gmake2 (j'attends impatiemment yagmake). Il y a des fonctionnalités qui ne marchent qu'avec Visual Studio, d'autres trucs qui fonctionnaient il y a quatre ans et qui ne fonctionnent plus. Ça m'a l'air d'être typiquement le projet qui veut tout faire parfaitement et qui au final ne fait rien de bien. Bref, le produit n'est pas à la hauteur du pitch.

    CMake

    CMake est une suite d'outils open source et multi-plateforme conçus pour construire, tester et empaqueter des logiciels. CMake est utilisé pour contrôler le processus de compilation du logiciel via des fichiers de configuration indépendants du compilateur et de la plate-forme, et il génère des fichiers Makefiles natifs ou des projets qui peuvent être utilisé avec l'environnement de compilation de votre choix.

    CMake est tout simplement mon outil de build préféré de ces quinze dernières années.

    Tout est dit.

    Bon OK, j'explique. CMake lit des fichiers CMakeLists.txt qui décrivent les projets à compiler dans un langage qui lui est propre. À partir de cela il génère des fichiers Makefile ou autres (des projets Xcode ou Visual Studio par exemple) qui permettent de construire le projet.

    Ce qui m'a convaincu dans cet outil est qu'il est plutôt rapide (bien qu'il ne soit pas le plus rapide) et qu'il gère parfaitement les règles de reconstruction des cibles. Par exemple, si j'ajoute un paramètre de ligne de commande pour l'édition des liens, alors l'édition des liens va être refaite. Si je modifie un fichier CMakeLists.txt et que j'exécute make sans relancer CMake, alors CMake se relance tout seul (les Makefiles ont une règle de dépendance vers les CMakeLists.txt, pas con!) Je peux aussi simplement définir les répertoires d'entêtes, options de compilation et autres paramètres spécifiques à chaque projet, en précisant s'il le paramètre doit être visible des projets dépendants ou non.

    L'outil est assez bien fichu et est très populaire dans le milieu du C++.

    Un des points les plus souvent reprochés à CMake est son langage, notamment à l'époque de la version 2 de l'outil qui était excessivement verbeuse et en plus en ALL CAPS. On avait l'impression de se faire crier dessus à longueur de fichier. Aujourd'hui ces soucis sont résolus et le problème semble surtout être que cela fait un langage de plus à apprendre et qui ne sert à rien d'autre (contrairement à SCons et Premake par exemple). Perso je n'y vois pas de difficulté, c'est un bête langage à macros avec des mécanismes bien pratique pour nommer des groupes de paramètres.

    Comme d'habitude la qualification « indépendants du compilateur et de la plate-forme » des fichiers de configuration est très discutable dans la mesure où il y a tout ce qu'il faut pour glisser des commandes système dans le build.

    Les principaux problèmes que j'ai pu rencontrer avec une version récente de CMake concernent l'export de projet. En effet il y a une commande install(EXPORTS) qui permet de créer un fichier de configuration CMake pour inclure la cible en tant que dépendance dans un projet tiers. Malheureusement cette commande exporte par défaut les chemins absolus des dépendances de la cible et il faut bricoler pour exporter les dépendances proprement (en les enrobant dans des cibles importées par exemple).

    Un autre souci est que CMake génère plein de fichiers intermédiaires et qu'avec la pratique généralisée de lancer le build à la racine du projet on se retrouve à polluer toute l'arborescence. Idéalement il faudrait que l'outil refuse de faire un build in-source.

    Ninja

    Ninja est un petit système de construction se concentrant sur la vitesse. Il est différent des autres systèmes de construction sur deux aspects majeurs : il est conçu pour que ses fichiers d'entrées soient générés par un système de construction de plus haut niveau, et il est aussi conçu pour exécuter les builds le plus rapidement possible.

    Ah cool, encore un outil qui se veut rapide, c'est exactement ce qu'il nous manquait. En plus quand on voit SCons et Premake qui se prétendent déjà les plus rapides, on a tout de suite confiance. Cela dit, contrairement à SCons et Premake, Ninja n'est pas un générateur de script de build. Il serait plutôt à comparer à Make.

    Je n'ai jamais utilisé Ninja mais si jamais mes builds devenaient très lents je n'hésiterais pas à y jeter un coup d'œil. À moins que je ne passe à Meson.

    Meson

    Meson est un système open source de construction voulant être à la fois extrêmement rapide et, encore plus important, aussi accessible que possible.

    Bon là je désespère. Encore un outil qui veut être le plus rapide et toujours pas d'outil qui prétend fonctionner correctement.

    Je n'ai jamais utilisé Meson mais on m'a dit que c'est-nouveau-c'est-bien-tu-devrais-essayer.

    Pourquoi pas, enfin moi je cherche surtout un truc qui me génère de quoi faire un build iOS, Android, OSX et Linux. Un truc qui juste marche quoi.

    FASTbuild

    FASTBuild est un système de construction open source et de haute performance supportant une haute montée en charge de la compilation, la mise en cache et la distribution sur le réseau.

    Non mais franchement…

    Là encore je n'ai pas utilisé cet outil. La promesse est sympa mais je ne vois pas trop l'intérêt par rapport aux deux mille autres outils du même genre.

    Sharpmake

    Sharpmake est un générateur de projets et solutions pour Visual Studio. Il est similaire à CMake et Premake, mais il est conçu pour être rapide et passer à l'échelle.

    Celui-ci est développé par Ubisoft initialement en interne et libéré en septembre 2017. Apparemment il n'y a plus d'activité dans le dépôt depuis octobre de la même année. Comme son nom l'indique, les scripts de build sont écrits en C#.

    D'après la doc il sait aussi générer des projets pour Xcode et des Makefiles. J'ai longtemps considéré l'utiliser en remplaçant de Premake mais d'une part c'est écrit en C#, donc c'est mort pour l'utiliser sous Linux, et d'autre part je sens bien que tout ce qui n'est pas Windows et Visual Studio va être bancal.

    Maven

    Apache Maven un outil de compréhension et de gestion de projet logiciel. Basé sur le concept de modèle d'objet de projet, Maven peut gérer la construction, le compte-rendu et la documentation d'un projet depuis un élément central d'information.

    Je ne sais pas vous mais moi je comprends à peine le descriptif. C'est peut-être ma traduction qui est foireuse.

    Maven est un outil du monde Java. J'ai pu l'utiliser un peu via des scripts déjà prêts et il n'y a pas grand-chose à lui reprocher de ce point de vue. Ça m'a l'air assez cool pour la gestion des dépendances.

    C'est un outil qui a l'air très professionnel. Ah mais attend… c'est pour ça qu'on comprend rien au descriptif ! La première version date de 2004 et c'est donc tout naturellement que le langage le plus populaire du début du siècle a été choisi pour les scripts de build, je parle bien sûr du 🎉 XML 🎉.

    Ant

    Apache Ant est une bibliothèque Java et un outil en ligne de commande dons la mission est de piloter des processus décrits dans des fichiers de construction en tant que cibles et points d'extensions dépendant les uns des autres.

    Là encore ça sent le professionnalisme. Les fichiers Ant sont des sortes de Makefiles mais écrits en XML. Faut-il le préciser, Ant est lui aussi un outil du monde Java.

    Gradle

    Accélérez la productivité des développeurs
    Depuis les applications mobiles aux micro-services, des petites startups aux grandes entreprises, Gradle aide les équipes à construire, automatiser et livrer de meilleurs logiciels, plus rapidement.

    Je te laisse deviner à quel langage est destiné cet outil.

    Gradle est l'outil de référence pour les builds des applications Android et c'est donc dans ce cadre que j'ai pu l'utiliser. Les scripts Gradle sont écrits en Groovy, un langage que je n'ai jamais utilisé par ailleurs. Perso je trouve pas ça génial mais c'est peut-être simplement parce ce que c'est loin de ce que l'on fait en C++.

    Les trucs qui me fatiguent le plus avec Gradle sont d'abord le temps de compilation. La compilation du projet Java de nos jeux, une partie qui contient pourtant peu de code, prend quasiment une minute. L'autre souci est de trouver de la doc claire et facile à digérer. La doc officielle représente à peu près 24% du web[référence nécessaire], ce qui fait que la moindre interrogation demande déjà plusieurs heures de lectures, et les exemples de StackOverflow et divers blogs sont assez disparates.

    Que choisir

    Déjà douze outils et rien n'a l'air de dominer le marché :/ Sans doute faudrait-il inventer un nouvel outil pour les remplacer tous, quelque chose d'hyper rapide, évolutif, mais aussi adapté aux processes de déploiement intraprocéduraux sur concentrateur décentralisés pour les plus professionnels d'entre nous, avec des scripts dans un langage populaire, type GOTO++.

    Malgré tout ce choix je n'ai rien trouvé qui résolve mon problème : générer un projet pour iOS, Android, Linux et OSX avec un seul script. Si vous avez une idée, ça m'intéresse.

    Commentaires : voir le flux atom ouvrir dans le navigateur

  • Intégration du rendu français d'OpenStreetMap dans KDE Marble (Journaux LinuxFR)

    Bonjour,

    La communauté française d'OpenstreetMap a réalisé un rendu très pratique pour les francophones :
    http://tile.openstreetmap.fr/

    Notamment on y trouve les traductions en Français des noms étrangers, des icônes adaptées (la Poste, SNCF, etc.) et une gestion du zoom mieux adaptée que sur le rendu par défaut.

    Perso je l'utilise pas mal avec le globe virtuel Marble, de KDE. Il s'agit d'un logiciel pour naviguer sur des cartes, assez pratique et moins consommateur en ressource puisqu'il garde un cache local des tuiles, au lieu de les télécharger à chaque fois.

    C'est assez utile par exemple suivre l'actualité: situer la fameuse usine Lafarge-Holcim en Syrie, la ZAD de Notre-Dames des Landes ou encore la Corée du Nord…

    Il y a quelques années j'avais fait une intégration de OSM-FR dans marble, j'ai enfin trouvé la motivation pour le mettre sur github:
    https://github.com/adrien-github/osmfr

    Je me suis dit que ça pouvait peut-être intéresser des gens ici.

    Lire les commentaires

  • Écrire des diagrammes de séquences (Dépêches LinuxFR)

    Les diagrammes de séquences sont très utiles pour représenter le déroulement d’événements au fil du temps. Ils sont par exemple très utilisés pour décrire des protocoles de communication, où les paquets d’information se croisent, se perdent, passent du temps dans les tuyaux.

    Dans la seconde partie de la dépêche, après avoir expliqué leur principe de ces diagrammes, quelques logiciels existants seront listés et un nouveau venu sera présenté.

    Les diagrammes de séquences sont très utiles pour représenter le déroulement d’événements au fil du temps. Ils sont par exemple très utilisés pour décrire des protocoles de communication, où les paquets d’information se croisent, se perdent, passent du temps dans les tuyaux.

    Ces diagrammes comportent :

    • des acteurs, avec leur ligne de vie (un acteur peut représenter une personne, une machine, un processus, un fil d’exécution…). La spécification UML utilise le terme de « participant » ;
    • des messages échangés entre acteurs.

    On fait ces dessins au tableau, puis on les efface, mais parfois on voudrait les inclure dans une page d’un document, ou les envoyer par courriel.

    Logiciels existants

    Des outils logiciels existent, pour générer de tels diagrammes :

    • éditeur de texte (ASCII art) ;
    • Mscgen (http://www.mcternan.me.uk/mscgen) ;
    • éditeurs dits UML ;
    • éditeurs SDL (Specification and Description Language) ;
    • éditeurs de diagrammes : Dia, LibreOffice, Microsoft Visio, etc. ;
    • outils d’ingénierie système (Capella…).

    Mais pour le moment, je ne suis pas satisfait de ceux que j’ai utilisés. Je voudrais les possibilités suivantes :

    • créer un acteur ou le détruire au cours du temps ;
    • croiser les échanges de messages ;
    • perdre un message ;
    • indiquer l’expiration d’un temps imparti (timeout) ;
    • faire une mise en page du dessin sans dessiner (j’entends par là que je ne veux pas passer trop de temps à déplacer à la souris les éléments pour les aligner ou les relier, et puis tout décaler un par un parce que j’ai inséré un nouvel acteur en plein milieu…) ;
    • avoir un logiciel libre et gratuit.

    Si quelqu’un connaît un tel logiciel, je suis preneur.

    Et alors ?

    En attendant, j’ai fait un prototype d’un tel logiciel, que j’appelle pour le moment meseq sur le principe de mscgen :

    • on écrit un fichier texte décrivant le scénario ;
    • meseq génère une image PNG à partir de ce fichier.

    L’avantage de cette approche est la simplicité et la rapidité de développement de l’outil, mais l’inconvénient est que c’est moins ergonomique qu’un éditeur avec rendu WYSIWYG.

    J’ai mis au point une syntaxe rudimentaire pour le fichier d’entrée. Je sais déjà que je vais la modifier pour la rendre plus évolutive.
    Voici un exemple pour illustrer cette syntaxe (fichier .msq) :

    [init]
    actors w3client proxy "" w3server
    
    [scenario]
    
    w3client   ->   proxy   CONNECT
    w3client   <-   proxy   OK
    w3client   ->   proxy   bytes
    proxy      ->   w3server bytes
    :
    w3client  <->   w3server "TLS Handshake\nwhat follows is ciphered"
    :
    :
    w3client   ->    proxy   "GET /index.html"
    proxy      ->   w3server "GET /index.html"
    proxy      <-   w3server "200, index.html"
    w3client   <-    proxy   "200, index.html"
    

    Et voici l’image générée par meseq (plus complète que l’exemple ci‐dessus) :

    example_web.msq.png

    Autre exemple, avec flèches qui se croisent, etc. :

    example_piggyback.msq.png

    Show me the prototype

    Ce prototype est là pour étudier la faisabilité, présenter mes idées et expérimenter.
    Bon, il est codé vite et mal : non documenté, bogué, mal structuré… Bref, un vrai code de goret.

    Ce prototype et les exemples sont sur Github : https://github.com/goeb/meseq.

    On utilise les bibliothèques Cairo et Pango pour dessiner, écrire le texte, puis générer l’image. Elles sont relativement simples à utiliser.

    Il existe d’autres bibliothèques pour dessiner, que je n’ai pas étudiées (et je ne suis pas sûr qu’il existe un moyen simple de les utiliser en Python) :

    • libgd, utilisée par mscgen ;
    • les bibliothèques sous‐jacentes de Graphviz (dont le rendu est agréable).

    Pour la suite

    Les améliorations à faire sont :

    • améliorer le rendu (diagramme plus compact verticalement, réduire les conflits de textes qui se superposent…) ;
    • ajouter des visuels (bloc de commentaire, couleurs…) ;
    • augmenter la qualité de code ;
    • choisir une licence libre.

    Par la suite, je porterai peut‐être ce programme en C ou C++, afin qu’il soit plus facile d’accès pour les personnes ne disposant pas de Python sur leur poste (je pense aux personnes lambda sur système d’exploitation Windows).

    Afin d’orienter les choix qui restent à faire, je serais intéressé par les avis éclairés des lecteurs de LinuxFr.org :

    • utilisez‐vous les diagrammes de séquences ?
    • quels éléments visuels trouvez‐vous indispensables, et pour représenter quoi ?
    • faut‐il rester en Python ou passer en C ou C++ ?

    N. D. M. : voici une liste des liens apparus dans les commentaires du journal :

    Lire les commentaires

  • De la différence entre PAM et NSS (Laboratoire Linux SUPINFO)

    De la différence entre PAM et NSS

     

    Note: ce document est le dernier d'un cycle de trois articles sur l'authentification sur les systèmes Linux. Les premier se trouvant ici et le deuxième .

    Lorsque l'on aborde l'authentification sous Linux, on est vite confronté aux deux mécanismes que sont PAM et NSS. Et à ce moment là une question peut venir à l'esprit : Quelle est la différence entre PAM et NSS qui permette de choisir l'une ou l'autre de ces solutions ?
    C'est donc à cette question que je vais essayer de répondre ici.

     

    Il est vrai qu'au premier abord ces mécanismes semblent faire la même chose, à savoir pouvoir s'authentifier sur un système Linux en utilisant différents services (fichiers plats locaux, serveur LDAP, serveur Active Directory, etc).

    Mais en regardant de plus près, on peut s'apercevoir qu'ils n'ont qu'une petite partie commune.
    En effet, il suffit simplement de s'intéresser à leurs noms pour comprendre leur fonction réelle.
    Pour PAM, Pluggable Authentification Modules, on se rend bien compte que son rôle est l'authentification des utilisateurs. Par contre, pour NSS, Name Service Switch, c'est une autre histoire. NSS est, comme son nom l'indique, une série d'interrupteurs pour choisir les services de données du système. Ces données peuvent être les utilisateurs, et dans ce cas là cela peut rentrer en compte pour l'authentification, mais ils peuvent être aussi beaucoup d'autres choses comme des noms de domaines, des listes d'alias d'adresses email, des correspondances entres des numéros de port et des services, etc. Le rôle de NSS est en fait de gérer les sources qui alimenteront la liste de ces types de données.

    Afin de mieux comprendre à quel moment PAM et NSS peuvent se chevaucher, il suffit de s'intéresser à l'évolution de l'authentification sur les systèmes Linux.

    À l'origine, les applications authentifiaient l'utilisateur en faisant appel aux bibliothèques du système. Ces dernières allaient alors regarder dans les fichiers /etc/passwd et /etc/shadow afin de vérifier l'existence de l'utilisateur et la conformité du mot de passe entré.
    On peut schématiser ce processus ainsi :

    Schéma du processus d'authentification basique sous Linux

    Ensuite, avec l'arrivée de NSS, on a pu élargir le nombre de sources pour les données du système. Concrètement, au lieu d'aller chercher les données seulement dans les fichiers plats, les bibliothèques système ont pu utiliser d'autres sources comme un serveur LDAP, une base de données SQL, un serveur Active Directory, etc. Mais ce sont toujours ces bibliothèques qui gardent le rôle d'authentifier l'utilisateur et donc cette authentification se fait sur le système local.
    Cela a au final changé notre précédent schéma ainsi :

    Schéma du processus d'authentification sous Linux avec NSS

    Enfin, lorsque les distributions Linux ont implémenté PAM, l'authentification n'a plus forcément été faite par les bibliothèques du système. C'est PAM qui à ce moment là choisit comment se fait l'authentification, suivant les modules qui sont activés. Si le module est pam_unix.so, l'authentification sera toujours gérée par les bibliothèques système en fonction des données fournies par NSS. Au contraire, si le module est pam_ldap.so ou pam_krb5.so, l'authentification se fera via un serveur LDAP ou Kerberos. C'est à dire que dans ce dernier cas, c'est au serveur externe que sera déléguée la vérification du jeton (ou mot de passe) et non plus sur le système local.
    En reprenant notre schéma, on arrive à ce résultat :

    Schéma du processus d'authentification sous Linux avec PAM et NSS

    On se rend maintenant compte pourquoi on peut avoir l'impression que PAM et NSS se chevauchent dans leur rôle.

    Les principales différences que l'on peut noter entre ces deux mécanismes sont donc les suivantes :

    • Avec NSS l'authentification est gérée par le système local, alors qu'avec PAM elle est délégué à un serveur externe (lorsque le module choisit n'est pas pam_unix.so). L'avantage qui en découle pour PAM est que le mécanisme d'authentification sera le même sur toutes les machines du réseau.
      Au contraire, cela pouvait poser problème avec NSS car chaque machine vérifiait le mot de passe suivant son propre mécanisme. En effet, si les machines d'un parc utilisent NSS et qu'une de celles-ci créé un utilisateur avec un mot de passe chiffré en MD5 qui est ensuite stocké dans un serveur LDAP, l'utilisateur ne pourra pas se connecter sur un machine chiffrant ses mots de passe en SHA-2 car la vérification sera fausse.
    • PAM est réellement dédié à l'authentification contrairement à NSS qui lui gère les sources qui alimenteront une liste de données. PAM permet donc d'effectuer diverses actions en plus de la simple vérification du jeton. Il peut par exemple limiter l'accès de l'utilisateur à certains horaires ou certains moyens (console, interface graphique) ou empêcher l'authentification après un certain nombre d'échecs.
      C'est aussi parce qu'il est dédié à l'authentification que PAM peut authentifier un utilisateur via Kerberos contrairement à NSS. En effet Kerberos utilise des jetons, ce qui ne sert à rien à NSS pour alimenter les listes de données qu'il a à gérer.

    Pour conclure, le choix entre PAM et NSS est une question qui a déjà été évoquée sur le Web, mais sans obtenir de réponse précise et développée. J'espère donc avoir pu éclairer les utilisateurs qui se retrouvent un jour confrontés au système d'authentification de Linux.

     

    Ressource supplémentaire :

     

  • Un petit tour des systèmes de build (Journaux LinuxFR)

    Sommaire

    Parlons un peu de systèmes de build.

    Mon métier consiste à programmer des jeux vidéos destinés aux plates-formes mobiles Android et iOS. Ce qui est commun aux deux plates-formes, c’est-à-dire la plus grosse partie de l'application, est écrit en C++, et ce qui est spécifique à la plate-forme est en Java ou en Objective-C. L'intérêt principal de tout faire en C++ est que les développeurs peuvent lancer l'application directement sur leur poste de travail, sous Linux ou OSX, et tester leurs modifs sans payer le prix d'un émulateur ou du transfert sur un appareil mobile.

    L'inconvénient est que l'on se retrouve à gérer des builds sur quatre plates-formes.

    Pour compiler une application pour iOS il faut nécessairement un projet Xcode, bien que les bibliothèques puissent être compilées classiquement en ligne de commande. Cela signifie qu'il faut maintenir un fichier de projet Xcode ou alors avoir un outil pour le générer.

    Côté Android la compilation du code C++ se fait avec l'outil ndk-build, qui est en réalité une interface à GNU Make. Du coup les fichiers de projet sont évidemment des makefiles mais utilisant des variables et fonctions d'une sorte de framework dans le langage de Make. Là encore il faut maintenir des makefiles pour le projet, ou avoir un outil pour les générer.

    Pour Linux et OSX la compilation peut se faire avec des outils plus classiques mais évidemment pas avec les fichiers de build iOS ou Android. Et encore une fois il faut maintenir ces fichiers de build.

    À moins qu'on ait un outil pour les générer tous…

    Quelques systèmes de build

    Le problème de la gestion de la compilation d'un projet a été posé bien avant ta naissance ; c'est pour cela qu'il n'existe qu'une seule méthode pour le faire, qui fait consensus depuis des décennies.

    Ha ! Ha ! Ha !

    Je peux te citer déjà douze outils de tête. Voyons un peu la présentation faite sur leurs sites respectifs et essayons de rester de bonne foi.

    Make

    D'après le site :

    GNU Make est un outil qui contrôle la génération d'exécutables et autres fichiers non-source d'un programme à partir des fichiers source du programme.

    J'ai mis la description du site de GNU Make mais la première version de Make date d'avril 1976. Elle précède ainsi le projet GNU de sept ans.

    Le principe de base de Make est assez simple, on lui passe un fichier Makefile qui indique « voilà le fichier que je veux créer, il dépend de ces autres fichiers, et voilà les commandes à exécuter pour le créer ». Avec le mécanisme des dépendances l'outil se débrouille pour créer les cibles dans l'ordre.

    Il m'arrive encore de créer des petits Makefiles manuellement mais c'est vite pénible. Par exemple, si un binaire app est créé à partir d'un fichier a.cpp qui inclut un fichier b.hpp qui inclut lui-même un fichier c.hpp, en toute rigueur je dois lister ces trois fichiers en dépendances de la cible app pour que la compilation soit refaite quand l'un d'eux est modifié. On fait ça une fois puis on cherche un truc pour que les dépendances soient gérées automatiquement.

    Un autre point difficile à gérer concerne la dépendance au fichier Makefile lui-même. Par exemple, si j'ajoute une option qui concerne l'édition des liens, celle-ci ne sera pas refaite par défaut.

    Autotools

    [Le premier objectif des Autotools] est de simplifier le développement de programmes portables. Le système permet au développeur de se concentrer sur l'écriture du programme, simplifiant de nombreux détails de portabilité entre systèmes Unix et même Windows, et permettant au développeur de décrire comment construire le programme via des règles simples plutôt que des Makefiles complexes.

    Si vous avez déjà utilisé les autotools vous êtes probablement morts de rire en lisant ce paragraphe. Cette suite d'outils qui se présente comme simple et portable est en réalité ce qu'il y a de plus complexe en système de build et n'est portable que sur les systèmes Unix en évitant soigneusement Windows, le plus déployé des systèmes des trente dernières années.

    Sans doute révolutionnaire à sa création, cet outil a extrêmement mal vieillit. Pour ma part j'ai eu l'occasion de compiler des logiciels tiers sous Windows avec ça et c'était tout simplement l'enfer. J'ai aussi tenté de l'utiliser pour mes propres projets et je me suis arrêté dans le tuto. Depuis je suis convaincu que ces outils sont faits pour les développeurs qui aiment transpirer.

    SCons

    SCons est un outil Open Source de construction de logiciel—plus précisément, une nouvelle génération d'outil de construction. Voyez SCons comme un substitut amélioré et multi-plateforme pour l'utilitaire Make classique avec des fonctionnalités intégrées similaires à autoconf/automake et aux caches de compilation tels que ccache. Pour faire court, SCons est un moyen plus facile, plus fiable et plus rapide de construire un logiciel.

    Wow, là c'est carrément le futur.

    Les fichiers SCons s'écrivent directement en Python, ce qui est assez sympa puisqu'on se retrouve avec un vrai langage et un a accès à un tas de bibliothèques pour décrire le projet.

    J'ai compilé quelques projets en SCons il y a une quinzaine d'années et je crois que je n'ai jamais rien vu d'aussi lent. Et pas seulement parce que c'est du Python…

    Il faut dire que le comportement par défaut de l'outil est de détecter les modifications des fichiers sources en calculant un md5 des fichiers, pour éviter de recompiler des fichiers dont seule la date a changé. Quand on voit le prix d'un md5 je trouve ce choix très discutable. Ce comportement peut être modifié via une option mais même en passant sur une comparaison de timestamps et en appliquant toutes les astuces connues pour le rendre plus rapide, ça reste hyper lent.

    Premake

    Un système de configuration de construction puissamment simple
    Décrivez votre logiciel qu'une seule fois, via la syntaxe simple et facile à lire de Premake, et construisez-le partout.
    Générez des fichiers de projets pour Visual Studio, GNU Make, Xcode, Code::Blocks, et plus sous Windows, Mac OS X et Linux. Utilisez l'intégralité du moteur de script Lua pour que la configuration de la construction devienne du gâteau.

    Pfiou, ça claque ! Ce n'est que le quatrième dans la liste et ça promet déjà de tout résoudre

    Avec Premake les scripts de builds sont écrits en Lua et, à l'instar de SCons, cela permet de « programmer » son build en profitant de tout un tas de bibliothèques.

    Sur le papier c'est très sympa, en pratique ça ne marche pas trop comme attendu. Il s'avère que la syntaxe de Premake est déclarative et ne se mélange pas bien avec le procédural de Lua. Par exemple, si j'écris

    project "P"
    
    if false then
        files
        {
          "file.cpp"
        }
    end
    

    On pourrait croire que le fichier file.cpp ne fera pas partie du projet P, et bien pas du tout, le if ne change rien du tout ici. Difficile de programmer dans ces conditions.

    Nous utilisons Premake depuis presque quatre ans au boulot. Le choix s'est fait en sa faveur bien que l'outil était en alpha car il permettait de générer des fichiers pour Xcode et ndk-build via deux plugins indépendants, en plus des Makefiles classiques. Aussi, il avait l'air facile à hacker ce qui était rassurant.

    Maintenant j'essaye de le remplacer autant que possible.

    Parmi les problèmes récurrents le plus pénible est certainement le message error: (null), sans autre info, que l'outil affiche parce qu'une erreur s'est glissée dans un script. Bonne chance pour déboguer ça. J'aime aussi beaucoup le message Type 'premake5 --help' for help qui s'affiche quand je fais une faute de frappe sur la ligne de commande. Là encore il n'y a aucune information utile et il faut se débrouiller pour trouver où on s'est trompé. Autre souci : il n'y a pas moyen de mettre des propriétés de link spécifiques à une bibliothèque. C'est embêtant quand on a besoin d'un -Wl,--whole-archive.

    Le développement de Premake en lui-même a l'air très laborieux. Quatre ans après il est toujours en alpha, avec une release datant d'août 2017. Le module Xcode a été intégré mais ne gère que OSX. Il a fallu réappliquer toutes nos modifs pour iOS. Quant au module pour le NDK il ne fonctionne plus suite à des changements dans Premake (hey, c'est une alpha…). Là encore il a fallu repatcher.

    Il y a de nombreux contributeurs, dont des gros, mais chacun a l'air d'aller dans sa propre direction sans qu'il y ait d'objectif commun. Il y a par exemple deux générateurs de Makefiles, gmake et gmake2 (j'attends impatiemment yagmake). Il y a des fonctionnalités qui ne marchent qu'avec Visual Studio, d'autres trucs qui fonctionnaient il y a quatre ans et qui ne fonctionnent plus. Ça m'a l'air d'être typiquement le projet qui veut tout faire parfaitement et qui au final ne fait rien de bien. Bref, le produit n'est pas à la hauteur du pitch.

    CMake

    CMake est une suite d'outils open source et multi-plateforme conçus pour construire, tester et empaqueter des logiciels. CMake est utilisé pour contrôler le processus de compilation du logiciel via des fichiers de configuration indépendants du compilateur et de la plate-forme, et il génère des fichiers Makefiles natifs ou des projets qui peuvent être utilisé avec l'environnement de compilation de votre choix.

    CMake est tout simplement mon outil de build préféré de ces quinze dernières années.

    Tout est dit.

    Bon OK, j'explique. CMake lit des fichiers CMakeLists.txt qui décrivent les projets à compiler dans un langage qui lui est propre. À partir de cela il génère des fichiers Makefile ou autres (des projets Xcode ou Visual Studio par exemple) qui permettent de construire le projet.

    Ce qui m'a convaincu dans cet outil est qu'il est plutôt rapide (bien qu'il ne soit pas le plus rapide) et qu'il gère parfaitement les règles de reconstruction des cibles. Par exemple, si j'ajoute un paramètre de ligne de commande pour l'édition des liens, alors l'édition des liens va être refaite. Si je modifie un fichier CMakeLists.txt et que j'exécute make sans relancer CMake, alors CMake se relance tout seul (les Makefiles ont une règle de dépendance vers les CMakeLists.txt, pas con!) Je peux aussi simplement définir les répertoires d'entêtes, options de compilation et autres paramètres spécifiques à chaque projet, en précisant s'il le paramètre doit être visible des projets dépendants ou non.

    L'outil est assez bien fichu et est très populaire dans le milieu du C++.

    Un des points les plus souvent reprochés à CMake est son langage, notamment à l'époque de la version 2 de l'outil qui était excessivement verbeuse et en plus en ALL CAPS. On avait l'impression de se faire crier dessus à longueur de fichier. Aujourd'hui ces soucis sont résolus et le problème semble surtout être que cela fait un langage de plus à apprendre et qui ne sert à rien d'autre (contrairement à SCons et Premake par exemple). Perso je n'y vois pas de difficulté, c'est un bête langage à macros avec des mécanismes bien pratique pour nommer des groupes de paramètres.

    Comme d'habitude la qualification « indépendants du compilateur et de la plate-forme » des fichiers de configuration est très discutable dans la mesure où il y a tout ce qu'il faut pour glisser des commandes système dans le build.

    Les principaux problèmes que j'ai pu rencontrer avec une version récente de CMake concernent l'export de projet. En effet il y a une commande install(EXPORTS) qui permet de créer un fichier de configuration CMake pour inclure la cible en tant que dépendance dans un projet tiers. Malheureusement cette commande exporte par défaut les chemins absolus des dépendances de la cible et il faut bricoler pour exporter les dépendances proprement (en les enrobant dans des cibles importées par exemple).

    Un autre souci est que CMake génère plein de fichiers intermédiaires et qu'avec la pratique généralisée de lancer le build à la racine du projet on se retrouve à polluer toute l'arborescence. Idéalement il faudrait que l'outil refuse de faire un build in-source.

    Ninja

    Ninja est un petit système de construction se concentrant sur la vitesse. Il est différent des autres systèmes de construction sur deux aspects majeurs : il est conçu pour que ses fichiers d'entrées soient générés par un système de construction de plus haut niveau, et il est aussi conçu pour exécuter les builds le plus rapidement possible.

    Ah cool, encore un outil qui se veut rapide, c'est exactement ce qu'il nous manquait. En plus quand on voit SCons et Premake qui se prétendent déjà les plus rapides, on a tout de suite confiance. Cela dit, contrairement à SCons et Premake, Ninja n'est pas un générateur de script de build. Il serait plutôt à comparer à Make.

    Je n'ai jamais utilisé Ninja mais si jamais mes builds devenaient très lents je n'hésiterais pas à y jeter un coup d'œil. À moins que je ne passe à Meson.

    Meson

    Meson est un système open source de construction voulant être à la fois extrêmement rapide et, encore plus important, aussi accessible que possible.

    Bon là je désespère. Encore un outil qui veut être le plus rapide et toujours pas d'outil qui prétend fonctionner correctement.

    Je n'ai jamais utilisé Meson mais on m'a dit que c'est-nouveau-c'est-bien-tu-devrais-essayer.

    Pourquoi pas, enfin moi je cherche surtout un truc qui me génère de quoi faire un build iOS, Android, OSX et Linux. Un truc qui juste marche quoi.

    FASTbuild

    FASTBuild est un système de construction open source et de haute performance supportant une haute montée en charge de la compilation, la mise en cache et la distribution sur le réseau.

    Non mais franchement…

    Là encore je n'ai pas utilisé cet outil. La promesse est sympa mais je ne vois pas trop l'intérêt par rapport aux deux mille autres outils du même genre.

    Sharpmake

    Sharpmake est un générateur de projets et solutions pour Visual Studio. Il est similaire à CMake et Premake, mais il est conçu pour être rapide et passer à l'échelle.

    Celui-ci est développé par Ubisoft initialement en interne et libéré en septembre 2017. Apparemment il n'y a plus d'activité dans le dépôt depuis octobre de la même année. Comme son nom l'indique, les scripts de build sont écrits en C#.

    D'après la doc il sait aussi générer des projets pour Xcode et des Makefiles. J'ai longtemps considéré l'utiliser en remplaçant de Premake mais d'une part c'est écrit en C#, donc c'est mort pour l'utiliser sous Linux, et d'autre part je sens bien que tout ce qui n'est pas Windows et Visual Studio va être bancal.

    Maven

    Apache Maven un outil de compréhension et de gestion de projet logiciel. Basé sur le concept de modèle d'objet de projet, Maven peut gérer la construction, le compte-rendu et la documentation d'un projet depuis un élément central d'information.

    Je ne sais pas vous mais moi je comprends à peine le descriptif. C'est peut-être ma traduction qui est foireuse.

    Maven est un outil du monde Java. J'ai pu l'utiliser un peu via des scripts déjà prêts et il n'y a pas grand-chose à lui reprocher de ce point de vue. Ça m'a l'air assez cool pour la gestion des dépendances.

    C'est un outil qui a l'air très professionnel. Ah mais attend… c'est pour ça qu'on comprend rien au descriptif ! La première version date de 2004 et c'est donc tout naturellement que le langage le plus populaire du début du siècle a été choisi pour les scripts de build, je parle bien sûr du 🎉 XML 🎉.

    Ant

    Apache Ant est une bibliothèque Java et un outil en ligne de commande dons la mission est de piloter des processus décrits dans des fichiers de construction en tant que cibles et points d'extensions dépendant les uns des autres.

    Là encore ça sent le professionnalisme. Les fichiers Ant sont des sortes de Makefiles mais écrits en XML. Faut-il le préciser, Ant est lui aussi un outil du monde Java.

    Gradle

    Accélérez la productivité des développeurs
    Depuis les applications mobiles aux micro-services, des petites startups aux grandes entreprises, Gradle aide les équipes à construire, automatiser et livrer de meilleurs logiciels, plus rapidement.

    Je te laisse deviner à quel langage est destiné cet outil.

    Gradle est l'outil de référence pour les builds des applications Android et c'est donc dans ce cadre que j'ai pu l'utiliser. Les scripts Gradle sont écrits en Groovy, un langage que je n'ai jamais utilisé par ailleurs. Perso je trouve pas ça génial mais c'est peut-être simplement parce ce que c'est loin de ce que l'on fait en C++.

    Les trucs qui me fatiguent le plus avec Gradle sont d'abord le temps de compilation. La compilation du projet Java de nos jeux, une partie qui contient pourtant peu de code, prend quasiment une minute. L'autre souci est de trouver de la doc claire et facile à digérer. La doc officielle représente à peu près 24% du web[référence nécessaire], ce qui fait que la moindre interrogation demande déjà plusieurs heures de lectures, et les exemples de StackOverflow et divers blogs sont assez disparates.

    Que choisir

    Déjà douze outils et rien n'a l'air de dominer le marché :/ Sans doute faudrait-il inventer un nouvel outil pour les remplacer tous, quelque chose d'hyper rapide, évolutif, mais aussi adapté aux processes de déploiement intraprocéduraux sur concentrateur décentralisés pour les plus professionnels d'entre nous, avec des scripts dans un langage populaire, type GOTO++.

    Malgré tout ce choix je n'ai rien trouvé qui résolve mon problème : générer un projet pour iOS, Android, Linux et OSX avec un seul script. Si vous avez une idée, ça m'intéresse.

    Commentaires : voir le flux atom ouvrir dans le navigateur

  • Le projet ZeMarmot a besoin de votre soutien (Journaux LinuxFR)

    Hello,

    Il ne me semble pas que Jehan ait posté son appel à l'aide sur LinuxFR donc je me permets de le faire rapidement ici.
    Le lien vers l'article sur le site du projet est ici

    Pour rappel, ZeMarmot est un film d’animation en 2D entièrement réalisé avec des logiciels libres. Il est en partie financé participativement, et diffusé sous licences Creative Commons paternité — partage à l’identique et Art Libre.
    En plus de la réalisation du film proprement dit, Jehan est un des contributeurs majeurs du projet Gimp.

    Le financement doit permettre à 2 personnes (Aryeom Han, animatrice et Jehan) de travailler sur le film ZeMarmot et d'en vivre si possible (ce qui est loin d'être le cas au moment de l'appel à l'aide). Récemment des problèmes matériels viennent compliquer les choses: l'ordinateur principal de Jehan a rendu l'âme et la tablette graphique de Aryeom montre des signes de faiblesses.

    Donc si vous pouvez consacrer quelques euros pour le projet et de préférence de façon récurrente ce serait un chouette geste pour Gimp et pour la culture libre.

    Merci

    Liens pour les dons:

    Lire les commentaires

  • Tutoriel 3D - 2D découpe au laser, le retour du tux (Journaux LinuxFR)

    Sommaire

    Tranche de pingouin

    Chose promise, cause perdue. Voici comment transformer un modèle 3D en tranches de bois pour découpe laser. Et en bonus, mon essai initial de découpe en création originale.

    Les outils que j’ai utilisé sont blender et inkscape, et ce juste parce que je les connaissais et donc plus facile pour expérimenter.

    Note aux amateurs de freecad, j’ai commencé à regarder comment ça marche, au cas où ce serait plus simple avec, si jamais je trouve une idée et le courage de refaire un tuto, ça me fera un zeugma.

    Au début était le cube

    Ouvrir un nouveau fichier dans blender et mettre la scène en métrique, car sinon les mesures ne sont pas fixées par taille réelle. Notez que à chaque étape du tuto on aura des soucis de conversion de dimensions, donc en fait… mais bon faut pas en profiter pour être négligent.

    où trouver le changement metrique

    Retirer le cube et ajouter le Tux à la scène. Vous pouvez le trouver ainsi que toutes les licences à Tuuuuuuux

    • Faire face au tux (1 au pavé num)
    • Mettre la vue iso (5 au pavé num)
    • sélectionner le tux
    • passer en editor mode (tab)
    • Sélectionner le dessous des pattes (B) qui est rond
    • Niveler (SZ0)
    • sélectionner les deux centres des pattes, (S) Snap cursor to selected
    • rebasculer en object mode (tab) , transform origine to 3d cursor (object/transform)

    Maintenant, le tux est calé pour avoir le plancher des pattes en comme origine, à la verticale du pseudo centre de gravité que nous venons de choisir.

    mettre la bête en Z 0.

    Il est gros vot manchot ?

    Il nous faut choisir une taille, suffisamment grosse pour que ce soit cool, et pas trop gros pour limiter le prix. Comme l’objet c’est aussi tester une bonne quantité d’épaisseurs pour voir comment ajuster la taille théorique d’une planche par rapport à sa taille réelle (il reste du vide, la colle ça épaissit, les planches sont pas forcément pile à la taille).

    Une planche 2mm chez sculpteo (chez qui je teste la découpe laser) fait 94cm*59cm, il faut aussi essayer de rester dans une seule planche avec tous les morceaux. Le tux est presque aussi large que haut, du coup on cherche une approximation de cube découpé en tranches et étalé fait la même surface en gardant un peu de marge. ça fait 55 tranches, donc une hauteur de 116.875mm

    Et si on l’écartelait ?

    Il nous faut séparer les pattes du corps du tux (ce sont des objets distincts dans le modèle de base en fait et elles s’interconnectent :

    Tux pattes interconnectées

    Il faut les réunir par booléen union au corps pour avoir un seul objet avec un intérieur/extérieur propre.

    tux vue pattes melees

    On peut maintenant appliquer une subdivision sur le tux CTRL+3, parce que le tux aime la douceur, et pas que celle angevine.
    c'est mieux avec les pattes creuses, c'est comme les heures à l'edf

    Lui sculpter des yeux plus sympa, parce que même si tout le monde ne veut pas l’avouer, pour avoir l’air cool faut quand même avoir un peu l’air con.

    tux sculptation des yeux (ou sculptage selon les régions)

    la même en couleur

    Mais quand est-ce qu’on coupe ?

    Patience, il faut regarder un peu avant de couper. Placer un plan plus grand que le tux au sol, genre 20cmx20cm et lui appliquer un booléen d’intersection avec le tux. Et regarder en bougeant le plan sur Z comment seront les tranches.

    On voit deux endroits à problème, les ailes et la queue qui auront des tranches avec plus que un morceau, ce qui est plus complexe à coller.

    par ex les ailes :

    ailes dissociées

    Ce sera lourd à coller ensuite, on peut mais pourquoi…

    autant relier les ailes au tronc le plus légèrement possible, avec un lien de 1mm de large.

    idem au niveau de la queue :

    queue perdue

    J’ajoute un bloc en union au niveau de la queue, le plus ajusté possible par un booléen union.

    jointure queue

    Cela vous permettra de facilement coller, il sera toujours possible de le limer après collage.

    Il faut bien nettoyer le résultat de l’union à l’intérieur du tux, ne pas laisser de cloisons internes, c’est à dire éviter d’avoir des plan à l’intérieur des plans :

    retirer les morceaux à l’intérieur des autres

    Finir de nettoyer en retirant les doublons de vertices, boucher les trous, assurer les normales pour que ce soit clair ce qui est à l’intérieur et à l’extérieur.

    Et si on l’empalait ?

    Pensons au support central qui va nous permettre de facilement positionner et coller les tranches de tux, il va être en trapèze et ressembler à ça au niveau d’une tranche :

    plan des tranches

    Le choix de la découpe sera donc toujours du côté le plus grand, en bas. Donc notre référence pour le positionnement des plans de découpe doit être la face basse de chaque tranche.

    Replaçons le plan à 0.01mm en Z (pour éviter le chevauchement parfait des surface avec les pattes Z=0), pensez à remettre tous les éléments avec scale=1 (Ctrl+A scale and rotation) pour la suite.

    Faire une array de 50 plans en Z espacés de 2.125mm, faire le booléen intersection avec le tux. Lors de la réalisation de mon bureau réel avec des tux, j’ai constaté que l’empilage de x tranches de 2mm n’a pas un résultat de x*2mm, mais avec l’air restant et la colle environ 2.125. Je vais affiner avec ce tux cette estimation mais déjà on part de 2.125mm par tranche.

    On voit les tranches et on voit des petits problèmes

    problème de tranche

    Une tranche qui manque en haut et le cul qui a une mini tranche en bas.

    Diminuer le overlap thresold du booléen pour que le problème du haut disparaisse :

    option thresold

    Remonter le point du bas du tux pour supprimer le second problème et non, ce n'est pas lui mettre un doigt dans le cul car ça ne doit pas rentrer :

    trou du cul de tux

    Nickel !

    bonnes tranches

    Simulons une épaisseur des tranches pour avoir un aperçu du résultat réel, ajoutons au plan un modifier solidify 2mm avec l’offfet à +1 (vers le haut) pour suivre le plan d’avoir la face basse comme référence :

    simul résultat final

    Le résultat est conforme, retirez le solidify, il ne doit pas interférer avec l’étape de création du lien central.

    On l’empale plus ?

    Mais si, mais si. En fait ce n’est pas obligatoire, mais ça facilite le positionnement des étages, et on peut aussi le garde sans le coller. Le lien central doit avoir une forme de trapèze et être parfaitement vertical, car pour l’instant sculpteo ne fait pas de découpe oblique.

    Il doit faire une épaisseur égale à celle du bois. Pour mon exemple je suis resté sur mon approximation (2.125mm) mais normalement il faut prendre 2mm et ajuster avec l’épaisseur du kerf qui est la taille du laser laissant un vide de découpe autour du trait de coupe. En pratique lors de mon premier essai j’ai eu des soucis d’épaisseur et j’ai du poncer mon trapèze. Du coup comme ce n’est pas nécessaire d’ajuster. Je surestime cette fois-ci la taille du trapèze.

    trapeze

    Il faut ajuster sa position pour qu’il traverse tout le tux, coup de chance c’est possible sur ce modèle en plaçant la traverse au centre de la dernière tranche du tux. Mais sinon on l’aurait simplement fait avec deux trapèzes sur deux hauteurs.

    Ajustez la taille en X et la hauteur de la partie haute pour faire joli, elle va dépasser un peu et même arrondir sa tête (note postérieure en pratique le trapèze sera toujours trop court, il faut juger les tranches encore un peu plus grand que 2.125mm).

    tete de tux

    En dessous ajuster aussi la taille en X pour donner un beau trapèze

    mise en trapeze

    On voit que c’est moche au niveau du pied

    tux chaplin

    On va donc remodeler un peu le trapèze pour qu’il soit plus joli à cet endroit.

    remodelage du pied

    aspect final

    Parlons peu, parlons kerf

    Le kerf c’est la partie du bois éliminée par le laser, en pratique la découpe est plus petite que le plan car le laser à une taille non ponctuelle. la découpe de la traverse dans les tranches sera donc un peu plus grande que prévu, et la traverse découpée plus court aussi que prévu.

    Dans ce modèle, on peut ignorer le kerf et accepter les différences, elles seront minimes et les pièces collées seront bien ajustées.

    appliquons donc le booléen différence entre le plan des tranches et la traverse

    Le résultat est difficile à voir mais en vue fil de fer c’est visible

    vue fil de fer du tux trapeziste

    C’est la lutte finale

    On peut passer à la phase finale, on réalise les “modifier” sur les planches, puis on aplati le trapèze en retirant les vertices d’un côté.

    En mode éditeur, on sépare toutes les tranches (P+loose parts en mode édition) et on les étale dans le bon ordre en vue du dessus. Attention, les numéros générés lors de la réalisation de l’array ne sont pas forcément dans l’ordre de Z…

    Pour ne pas me planter, je me met dans une vue adaptée et je bouge une par une les tranches avec des gx0.1 … Je vérifie bien que tout est dans l’ordre puis je met tout le monde à plat (sélectionner tout A puis SZ0)

    Nous allons avoir des soucis de conversion de taille entre blender puis Inkscape puis sculpteo… on commence par poser un étalon dans blender, un plan au sol de 1cm sur 90cm

    90cm etalon

    Le petit oiseau va sortir

    Enfin presque, il faut encore à faire la photo !

    Il existe une option de rendering qui génère du svg.

    Mettons la caméra au dessus en mode orthographique, d’abord une résolution 100% sur un ratio approximatif de mon rectangle incluant tout.

    100 pourcent

    puis placer la caméra assez bien au dessus de la scène et changez les paramètres :

    ortho

    L’échelle orthographique est ce qui correspond au zoom, ajustez la valeur pour que tout rentre au plus juste

    Tout doit rentrer dans la fenêtre de rendering :

    serrez les rangs

    Maintenant depuis les user pref, activez le svg freestyle exporter :

    options rendering

    Et activez les deux options freestyle et svg export depuis les options rendering

    option rendering activee

    Pressez F12, une image svg sera générée dans le répertoire indiqué dans output nommé 0001.svg,

    Ouvrez le dans Inkscape, dégroupez et sélectionnez l’étalon. mettez lui une épaisseur de contour à 0 pour ne pas fausser la taille et regardez sa taille. Dans mon cas je tombe sur 35.719cm.

    Je vais donc changer la résolution de l’image pour ajuster la taille d’un facteur de 90/35.719=2.52

    Je change dans blender le render pour :

    retailler

    Re F12 et vérification.

    Mon étalon fait maintenant 1cm sur 90.01cm.

    aller, on essaie avec un pixel de moins en Y :), on tombe sur 89.987. C’est moins bon, retour en arrière.

    Maintenant que l’on a les bonnes tailles dans Inkscape, il faut nettoyer. Parce que le freestyle a introduit des pixels de temps en temps.

    Je prends donc chaque découpe pour la repositionner au mieux et aussi supprimer les traces.

    points artefacts

    Pour m’aider et aussi servir d’étalon entre Inkscape et sculpteo je place un cadre dans une autre couleur qui délimite ma sélection, 53.5cm de large sur 75cm de haut.

    Et je fais tout rentrer dedans.

    Je vérifie chaque pièce pour assurer qu’il n’y a pas de défaut, et j’assure les contours à 1px et mon cadre avec une couleur différente

    C’est prêt.

    planche à découper

    Pour ceux qui sont plus observateurs que moi, vous verrez que j’ai oublié de grouper une fente dans une tranche. Moi je vais le voir au montage plus tard…

    TuxOlaser

    J’upload chez sculpteo.

    Deux couleurs sont détectées, l"une correspond au noir et l’autre au rouge du cadre. Les mesures n’ont pas été conservées, je ne sais pas pourquoi… mais mon cadre me permet de choisir un ajustement de taille à 26.5% qui me redonne les bonnes dimensions.

    Je peux alors désactiver le cadre rouge dans sculpteo (style 2 sur aucun et voila !

    prêt à couper.

    Livraison comprise il vous en coûtera 53.33€.

    Pour info, les tux du bureau ont coûté moins cher, ils étaient en une seule livraison et un peu plus petits, 72€ les 3.

    Déboitage du tux et montage

    Je hais les video de unboxing, et me voilà moi même à déboiter…

    Bon, puisqu’il faut :

    la boite est bien protégée

    boite

    et la planche dans la mousse

    planche entourée de mousse

    Les pièces sont tenues par du scotch, il faudra faire attention en retirant le scotch de ne pas casser les pièces fragiles.

    scotch sur les pieces

    Je numérote mes pièces avant de défaire, c’est moins cher que de faire des numéros au laser.

    sans scotch à numéroter

    Ensuite on empile jusqu’à la fameuse pièce 33 qu’il faudra redécouper.

    debut d'empilage

    piece 33

    redecoupe de la 33

    piece 33 empilee

    Tadaaaa

    Entrer une description pour l'image ici

    A propos de licences

    J’ai fouillé pour trouver les licences attachées au modèle de base, les voici :

    https://opengameart.org/content/tux

    https://opengameart.org/sites/default/files/license_images/gpl.png

    http://www.gnu.org/licenses/gpl-3.0.html

    https://opengameart.org/sites/default/files/license_images/cc-by.png

    http://creativecommons.org/licenses/by/3.0/

    Les fichiers

    Voila les fichiers sources blender et le inkscape (piece 33 corrigée)

    fichier blender

    fichier svg

    Commentaires : voir le flux atom ouvrir dans le navigateur

  • Mes péripéties avec la répétition espacée (Journaux LinuxFR)

    Sommaire

    Bonjour Nal,

    Aujourd'hui, je viens pour te raconter mes péripéties avec la répétition espacée et la naissance de morji, un logiciel de répétition espacée, tout comme mnemosyne ou anki, mais comme alternative minimaliste en mode texte dans le terminal. Avant de te raconter le pourquoi du comment de morji, je vais te raconter un peu le concept de répétition espacée, ainsi que te montrer un peu le principe des algorithmes qui font marcher l'idée.

    La répétition espacée : qu'est-ce donc  ?

    L'idée de la répétition espacée part d'un constat expérimental : lorsqu'on apprend quelque chose, peu importe quoi, on a besoin de réviser pour ne pas l'oublier, et l'intervalle entre révision et révision peut s'allonger avec le temps — l'expérience suggère une progression exponentielle. Si je t'apprends le nom d'une plante aujourd'hui et que je te repose la question dans un mois, tu auras sans doute oublié d'ici là. Si je te repose la question demain, il y a des chances que tu t'en souviennes, et si je te repose la question une semaine après, il y a de bonnes chances aussi ; si après ceci j'attends un mois pour t'embêter de nouveau… et bien probablement aussi !

    Tu me diras, rien de bien extraordinaire là-dedans. Peut-être pas, et encore… Mais ce qui est sûr, c'est que, du coup, il faut une certaine organisation si l'on veut retenir un maximum de choses tout en faisant un minimum d'efforts. Le drame, c'est que choisir manuellement à l'intuition ce qu'il faut réviser et quand, c'est pas toujours évident.

    Un peu d'automatisation !

    C'est là qu'on se dit, et si on pouvait faire faire ce travail à une machine ? Il se trouve que ça s'applique pas facilement à tout type de connaissance, mais il y a des cas où on peut, en particulier lorsque les faits à se remémorer se structurent facilement en cartes-mémoires du type question/réponse. Par exemple :

    Question: nom de plante avec de gros piquants dangereux
    qui pousse dans le désert
    Réponse: cactus
    

    L'interaction (version naïve) se fait ainsi :

    • le programme nous pose la question ;
    • on réfléchit à la réponse ;
    • on affiche la réponse ;
    • on dit à la machine si on s'en souvenait.

    Si on s'en souvenait (on a pensé à « cactus »), la machine calcule alors la date de la révision suivante en tenant compte de l'intervalle entre les deux révisions précédentes. Sinon (on a pensé à « rose » ou « chardon » ou à rien du tout), les intervalles repartent de zéro pour ce fait, qu'il faut remémoriser.

    Ces idées ont donné naissance à des algorithmes. Le premier semble être le Système Leitner, qui date des années 70 et qui ne semble pas être vraiment utilisé aujourd'hui dans des logiciels, mais qui par contre avait l'avantage de pouvoir s'utiliser à la main avec des boîtes. Cet algorithme classait les faits par groupes (les boîtes) : le premier groupe contenait les faits non mémorisés ou oubliés, le second les faits mémorisés qui ont été révisés une fois, et ainsi de suite. Plus le numéro de groupe était élevé, moins la carte était révisée, suivant une méthode de calcul artisanale qui utilisait une taille maximale pour chaque groupe : le premier groupe était de taille 1, le deuxième de taille 2, puis 5, puis 8, etc. C'est seulement lorsqu'un groupe était « plein » qu'il fallait réviser des cartes de ce groupe pour les faire passer au groupe suivant.

    L'inconvénient du procédé, même implémenté dans un logiciel (parce que les boîtes ça prend de la place mine de rien), c'est qu'il est un peu binaire. Des fois on se souvient presque (on a pensé « kaktus »), ou alors on se souvient, mais on a eu beaucoup de mal, ou alors c'était trop facile. Du coup, l'idée est venu de demander à l'utilisateur d'évaluer lui-même sa performance, soit à l'aide d'un nombre entre 0 et 5 (mnemosyne ou SuperMemo), soit de façon plus qualitative (anki). En fonction du résultat, l'intervalle de révision suivant est ajusté par le logiciel qui maintenant a une idée de la difficulté que présente ce fait particulier pour l'utilisateur.

    Vers des algos plus évolués : exemple de SM2

    Un deuxième algo plus évolué est alors apparu, appelé SM2, du nom de SuperMemo2, logiciel pas libre qui a lancé l'idée. Depuis, son algo s'est compliqué sensiblement pour tenir compte finement du fait que certains faits sont liés entre eux et autres subtilités, et le logiciel est probablement devenu une usine à gaz, mais l'idée de fond reste la même. En fait, les logiciels mnemosyne et anki utilisent simplement une version modifiée de SM2 qui marche bien en pratique et leurs auteurs semblent sceptiques sur les versions suivantes de l'algo (ça va jusqu'à SM11 ou plus). Il y a aussi un mode Emacs qui fait de la répétition espacée et qui permet d'utiliser SM5, même si par défaut ça utilise encore le système Leitner si les infos sur le site ne sont pas obsolètes. Il y a aussi Org-Drill (Emacs encore) qui fait du SM5 par défaut.

    L'algorithme SM2 original est une simple traduction des idées ci-dessus : si I(n) représente l'intervalle entre la (n-1)-ième répétition et la n-ième, alors :

    • I(1) = 1
    • I(2) = 6
    • Pour n > 2 : I(n) = I(n-1) * facilité.

    facilité est un paramètre propre au fait qui évolue au fil des notes successives données à chaque révision. Initialement il vaut 2.5, puis il évolue autour en fonction des notes. Le paramètre a une valeur minimale de 1.3, pour éviter des révisions trop fréquentes d'un même fait : en pratique elles correspondent à des faits non-compris ou mal posés dont il faut revoir la présentation. Par exemple, anki propose 4 choix lors d'une révision :

    • On a oublié : l'intervalle est remis à zéro, la facilité laissée telle quelle ; si on a oublié ça veut pas forcément dire que c'était dur, des fois on oublie, c'est tout.
    • Ok, mais c'était dur : la facilité est diminuée (de 0.15 il me semble pour anki), et le nouvel intervalle tiendra compte de ceci.
    • Ok, juste comme il faut : la facilité ne change pas.
    • Ok, mais trop facile : la facilité augmente (0.10 pour mnemosyne, 0.15 pour anki de mémoire).

    Le détail de l'algorithme original et de la modification du paramètre de facilité peut être trouvé à la source (site qui, dit en passant, contient beaucoup d'articles intéressants sur la mémoire, bien que parfois un peu biaisés sans doute). Remarque annexe sur le document : Faut faire gaffe, car il y a une petite subtilité : le 5ème et 6ème points sont inversés dans mnemosyne et anki, c'est-à-dire qu'on ne modifie pas la facilité lorsqu'on a oublié. Ceci semble logique, car si on a oublié totalement un fait, ça veut pas forcément dire qu'en le réapprenant on va avoir des difficultés et, de plus, ajuster la facilité en variant les réponses affirmatives semble suffisant et plus raisonnable : l'algo original (si tant est que ce ne soit pas juste un bug du document) a tendance à faire plomber trop vite le taux de facilité suite à des échecs successifs lors de l'apprentissage d'une carte.

    Quelques améliorations

    Un souci avec le SM2 original, c'est qu'il suppose que l'utilisateur va apprendre tous les jours plus ou moins la même quantité de faits. En effet, si un jour on apprend 20 faits, et un autre on en apprend 50, ça veut dire que ces 20 faits seront révisés, à moins d'être oubliés, toujours aux mêmes dates avec les mêmes intervalles, et de même pour les autres 50 aussi : on se retrouve donc avec une charge de révision très inégale suivant les jours. Même en étant disciplinés, il arrive parfois de ne pas pouvoir faire ses révisions pendant plusieurs jours, par exemple, et créer ainsi sans faire exprès ce genre d'inégalités de charge.

    Les logiciels anki et mnemosyne introduisent un peu d'aléatoire dans l'algorithme pour résoudre ce problème. Plutôt que de faire réviser les 50 cartes le même jour, elles seront réparties sur les jours autour, avec une incertitude qui dépend de l'intervalle (5% pour mnemosyne, sauf pour les petits intervalles où des valeurs spéciales sont codées en dur).

    Il y a d'autres petites subtilités pour être un peu résistant aux vacances ou autres cas spéciaux : par exemple, si on se souvient d'un fait qu'on était censé réviser il y a une semaine, le nouvel intervalle doit tenir compte de la date de la vraie répétition, pas seulement de la date théorique mais, en même temps, si l'utilisateur a du mal, on peu préférer être plus conservateur sur le nouvel intervalle qu'en théorie : lors du calcul anki compte les jours de retard avec un poids plus faible qui dépend de la note ; mnemosyne se contente d'être conservateur si la note correspond à « c'était dur ». C'est des ajustements de bon sens, mais sans théorie vraiment derrière, pour autant que je sache.

    Une petite simulation !

    Pour se faire une idée de la charge de révision que l'on accumule, j'ai fait une petite simulation sur plus d'un an (500 jours). Tous les jours, 15 nouvelles cartes apprises, et quelques pourcentages pris un peu au flair (ça varie sans doute beaucoup suivant la façon de voter de la personne et le sujet) : chaque jour, 5% de cartes oubliées (mais réapprises le jour même de l'oubli), 2% classées difficiles, et 1% classées faciles. Au total, 7500 cartes sont mémorisées. On se retrouve avec un nombre de cartes à réviser par jour pour la semaine suivante qui ressemble à :

    88 88 76 85 86 79 56
    

    Un petit calcul permet de prévoir l'ordre de grandeur du résultat : en supposant de voter toujours « Ok, je m'en souviens bien », ça correspond à des intervalles (à randomisation et ajustements près) de 1, puis 6, puis à partir d'ici multiplier l'intervalle par 2.5, ce qui donne en moyenne entre 5 et 6 révisions par carte sur l'intervalle de 500 jours, donc en multipliant par le nombre de cartes nouvelles par jour, ça donne entre 5 * 15 = 75 et 90. Comme en pratique on oublie quand même des cartes, et la facilité c'est souvent un peu moins de 2.5, c'est en fait un peu plus, mais c'est le bon ordre de grandeur.

    Quelques types de cartes-mémoires

    Tout à l'heure, j'ai donné un exemple simple de question/réponse avec un cactus. Les logiciels gèrent en général plus de types de cartes-mémoire. En particulier, des faits que l'on veut être capable de retenir dans les deux sens. Par exemple, imaginons qu'on veut retenir le nom des capitales, on veut une question du genre :

    Question: France
    Réponse: Paris
    

    Mais peut-être qu'il peut être intéressant aussi d'avoir la question à l'envers aussi :

    Question: Paris
    Réponse: France
    

    En pratique on s'aperçoit souvent que ce n'est pas parce qu'on sait répondre à une question dans un sens qu'on sait le faire dans l'autre ! Les amateurs de langues le savent bien :) C'est pour cela que mnemosyne et anki sont capables de générer deux cartes-mémoires à partir d'un seul fait pour gérer ce genre de cas de façon commode.

    Une autre façon parfois pratique de représenter une question peut être le texte à trous :

    Question: [...] est la capitale de la France.
    Réponse: Paris
    

    Mais aussi :

    Question: Paris est la capitale de [...].
    Réponse: la France
    

    Pour ce genre de cartes, en pratique on écrit quelque
    chose comme :

    Question: [Paris] est la capitale de [la France].
    Réponse: la France
    

    …Et le logiciel génère à partir de ce seul fait les deux
    cartes-mémoires.

    D'un point de vue de l'algorithme, ça pose la question intéressante d'éviter de se voir demander les deux cartes le même jour, ce qui risquerait de fausser un peu la révision et la note attribuée à la deuxième carte. En pratique on utilise des solutions plus ou moins ad-hoc où on s'arrange pour ne pas mettre les deux le même jour.

    Morji

    morji c'est donc encore un autre logiciel de répétition espacée utilisant un SM2 modifié, comme anki et mnemosyne, mais dans le terminal et avec un minimum de dépendances. « Mnemosyne » est le nom d'une déesse grecque de la mémoire, « anki » signifie mémorisation en japonais ; pour rester dans le thème et faute de meilleures idées, « morji » signifie « se souvenir » en lojban.

    Une nimage d'abord

    https://bardinflor.perso.aquilenet.fr/morji/morji-screenshot.png

    Le début de l'histoire

    J'étais jusqu'à il y a peu un utilisateur relativement satisfait de mnemosyne. L'interface est plutôt simple, son concept de tags pour organiser les faits est flexible et, dans l'ensemble, le logiciel est assez orthogonal. Il a quelques défauts, parfois un peu lent pour certaines opérations, c'était quand même un peu trop clickodrome pour moi et, devoir écrire mes cartes sans vim, c'était un peu dur ; mais dans l'ensemble, c'est sympa.

    D'habitude j'utilise OpenBSD sur un fixe, mnemosyne est dans les paquets, donc tout va bien. Mais j'ai aussi une autre machine (un ordinateur portable) sur laquelle, pas de chance, OpenBSD détectait pas bien la carte réseau, du coup j'ai installé un Void Linux (il s'agissait de pas être trop dépaysé). Et là, c'est le drame. Mnemosyne n'était pas dans les dépôts. Paf.

    Je prends mon courage à deux mains, et j'essaie de compiler le truc. Je regarde les dépendances, certaines sont pas dans les dépôts. Qu'à cela ne tienne, c'est du python, j'installe ça avec pip… Après plusieurs itérations à installer de nouveaux paquets, c'est l'échec cuisant. Je commence à redouter des incompatibilités de versions, python 2 ou 3, je teste des trucs ; ça fait bien deux heures, j'abandonne et me dis que, quand même, les packageurs, c'est un peu des super héros, et que je serais mal barré sans eux.

    Ça m'a fait un peu peur, parce que, bon, l'idée de me retrouver un jour avec ma base de données mnemosyne et toutes ses données d'apprentissage sans pouvoir l'utiliser, ça fait un peu mal. Alors, comme je connaissais un peu les algorithmes, SM2 et tout ça, je savais que c'était quand même pas très compliqué et, comme j'avais pas besoin de tant de features que ça, je me suis lancé.

    Les features

    morji gère juste les trois types de cartes-mémoires que j'ai décrites avant : dans un sens, à double sens et textes à trous. Il ne gère pas l'html, ni le javascript, mais il permet de faire du balisage sémantique simple pour mettre des couleurs, du gras ou de l'italique. Par exemple, la ligne suivante dans le fichier de configuration :

    markup keyword colored red
    

    Définit le tag keyword qui permettra de rendre du texte en rouge. On l'utilise ainsi dans le contenu d'une question :

    Que veut dire [keyword mot-clé]?
    

    qui rend mot-clé en rouge.

    morji utilise un système de tags similaires à celui de mnemosyne. On peut donc associer à chaque fait un ou plusieurs tags. Ensuite, on active ou désactive des tags pour choisir quels thèmes réviser ou apprendre. Ça permet par exemple de mixer les thèmes pendant les révisions — chose que je trouve stimulante perso —, puis au moment d'apprendre de nouvelles cartes sélectionner un seul tag.

    Il est possible d'importer d'un coup une liste de faits depuis un fichier avec des champs séparés par des tabulations, un peu comme avec mnemosyne.

    Remarque technique :. morji n'est pas un projet de recherche, du coup il stocke moins de statistiques dans la base de données. Je ne sais pas si c'est surtout ça, ou le fait que mnemosyne stocke certaines informations plus ou moins en double pour des raisons qui restent un peu mystérieuses pour moi (éviter de recalculer des choses, peut-être), mais ma base de données mnemosyne est passée de presque 50M à 10M avec morji ; pratique pour faire des backups quand on a une connexion pas trop rapide :)

    Les trucs qu'il n'y a pas

    Actuellement, morji ne gère pas de fichiers externes (images, son). A priori, il serait cependant facile si besoin de l'étendre via le fichier de configuration (qui est un script Tcl même si ça se voit pas) pour lancer un visionneur d'images externe, par exemple, à défaut d'un truc parfaitement intégré.

    Il n'y a pas non plus de navigateur de cartes-mémoire. En pratique, ça correspond à cas d'utilisation très rare — en tous cas pour moi — puisque, a priori, le principe c'est qu'on va pas chercher des faits soi-même, c'est le logiciel qui le fait pour nous ; ceci dit, parfois ça pourrait être commode, mais je n'ai pas trouvé encore une solution simple qui me plaise. En attendant d'en trouver éventuellement une, pour faire des substitutions en masse ou ce genre de choses, il est possible d'utiliser un script (morji est scriptable en Tcl) ; l'interface pour faciliter cela proprement n'est pas encore vraiment fixée ni documentée (en dehors de commentaires dans le code et d'exemples), mais ne devrait pas trop changer, donc en pratique il y a moyen de se dépatouiller si besoin.

    Sous le tapis

    Là, c'est parti pour une petite section un peu technique, pour ceux qui ont eu la patience de me lire jusqu'ici :)

    Comme j'ai un peu raconté tout ce qu'il faut savoir sur SM2, les faits et les types de cartes-mémoires, etc. je me dis que tu veux peut-être savoir à quoi ressemble le schéma de la base de données utilisée par morji, qui est en fait une traduction idée pour idée des concepts.

    Il y a quatre tables : une pour les faits, une pour l'information spécifique à chaque carte-mémoire, une pour les tags, une qui fait la relation entre quels faits ont quels tags, et puis c'est tout. Je vais juste raconter un peu les deux premières, pour qu'on revoie les concepts de l'algo SM2.

    Celle des faits, facts, stocke donc, entre autres, une question et une réponse :

    CREATE TABLE IF NOT EXISTS facts(
        uid INTEGER PRIMARY KEY,
        question TEXT NOT NULL,
        answer TEXT NOT NULL,
        notes TEXT NOT NULL,
        -- oneside/twoside(recognition/production)/cloze...
        type TEXT NOT NULL
    );

    En fait, on retrouve bien le champ pour la question et la réponse. Il y a de plus un champ pour des notes additionnelles dont je n'ai pas parlé avant (mais c'est dans la nimage plus haut), et qui sert à afficher des trucs en plus dans la réponse pour les faits à deux sens, indépendamment du sens (par exemple un lien vers la source de l'information). Le champ type nous dit s'il s'agit d'un fait à un sens, à deux sens ou d'un texte à trous.

    La table contenant l'information d'apprentissage de chaque carte mémoire est un peu plus compliquée :

    CREATE TABLE IF NOT EXISTS cards(
        uid INTEGER PRIMARY KEY,
        -- last repetition time (null for new cards)
        last_rep INTEGER,
        -- next repetition time (null for new cards)
        next_rep INTEGER CHECK(next_rep ISNULL OR last_rep < next_rep),
        easiness REAL NOT NULL DEFAULT 2.5 CHECK(easiness > 1.29),
        -- number of repetitions (0 for new and forgotten cards)
        reps INTEGER NOT NULL,
        fact_uid INTEGER NOT NULL REFERENCES facts ON DELETE CASCADE,
        -- additional data whose meaning depends on facts.type
        fact_data TEXT NOT NULL
    );

    Les champs last_rep et next_rep contiennent les dates de la dernière répétition et la répétition suivante, respectivement (leur différence est donc l'intervalle théorique entre les deux répétitions). Le champ easiness contient la facteur de facilité de toute à l'heure, et reps, c'est le nombre de répétitions, donc le n des formules. Enfin, fact_uid signale le fait auquel fait référence la carte, et fact_data donne des informations supplémentaires : par exemple, est-ce le verso ou le recto qu'il faut montrer ? Un truc à remarquer aussi, c'est la valeur par défaut de 2.5 pour la facilité et la contrainte sur le minimum, qui font écho à l'algorithme.

    Petite anecdote pour la fin

    Je crois que j'ai déjà prononcé le mot Tcl un peu avant. Eh oui, morji est écrit en Tcl. En fait, quand j'ai commencé à écrire morji, j'ai vite compris que ça allait être essentiellement des requêtes SQLite et pas grand-chose de plus. Or, pendant que je me mettais à jour sur SQLite, mon attention a été attiré, un peu par hasard, par le fait que SQLite avait été initialement prévu comme une extension Tcl, avant de devenir ce qu'on connaît aujourd'hui ; du coup ça m'a intrigué, j'ai découvert que l'interface Tcl pour SQLite était vraiment sympa et leur système de tests unitaires aussi. Ajouté au fait que Tcl est un langage léger présent sur à peu près toutes les plateformes, eh bien, j'ai pas pu résister :)

    Anecdote : au début j'envisageais d'écrire morji en Go, du coup je voulais l'appeler « gogoratu » — « se souvenir » en basque —, parce que c'était rigolo, mais du coup, après, la blague tombait un peu à l'eau :)

    Voilà, c'est tout !

    Liens : site de morji, avec documentation en html ; page github du projet.

    Lire les commentaires

  • LibreOffice, altération d'images intégrées :( ? (Journaux LinuxFR)

    Bonjour à tous, amis journaleux :)

    Je suis très embêté par un très vilain bug dans LibreOffice. J’ai passé déjà beaucoup de temps pour comprendre le problème et m’assurer qu’il s’agit bien d’un bug dans LibreOffice (y compris illustrations, échange sur liste de diffusion etc.) Avec mon travail et mon petit garçon de 3 mois, je n’ai malheureusement pas le temps de remplir les formalités prévues pour le signalement d’un bug, d’autant que je ne maîtrise pas l’anglais et que je devrais passer du temps à jongler aussi avec un logiciel (ou service en ligne ) de traduction. Par ailleurs, je considère qu’il s’agit d’un bug plutôt grave car il donne lieu à des fichiers corrompus sans que l’on ne s’en aperçoive et cela pourrait nuire vraiment à l’image de notre précieuse suite bureautique, sans compter que j’ai même pas de solution facile à mettre en œuvre :(

    Bref, je compte sur quelqu’un pour prendre le relais et faire cette déclaration de bug en anglais, tout comme il faut.

    Voici, ce que j’ai déjà posté sur la liste de diffusion qa@fr.libreoffice.org :

    Je suis victime d'un grave bug de régression concernant les images embarquées…

    Je maintiens depuis des années un document Draw que vous pouvez trouver à cette adresse : http://www.spaceeman.be/ftl/

    Depuis peu, l'impression me donnait des rectangles noirs à l'emplacement de certaines images.

    J'ai cherché à comprendre, s'il s'agissait pas exemple d'un format qui n'est plus bien supporté par une lib', etc.

    Non, c'est bien LibreOffice (5.4.4~rc2) [PS: confirmé également avec 6.0.1.0+ et le master courant (future 6.1)] qui a un problème, qui tronque la version binaire de certaines images embarquées ! rien que ça…

    Le bases
    Page 6
    l'oiseau, qui se trouve dans un groupe, est l'illustration de ce que peuvent représenter les 380 octets d'un petit fichier (c'est didactique).

     Titre de l'image

    S'il l'on regarde l'archive qu'est le fichier .odg, l'on constatera que le fichier est (ici) intègre.

    Titre de l'image

    Titre de l'image

    De même, si l'on exporte la page en bitmap

    Titre de l'image

    PS: le rendu jouant sur les sous-pixels RBG est-il ici pertinent ? Personnellement je ne pense pas. Mais c'est une autre histoire…

    Par contre !

    Si l'on imprime…
    Si l'on exporte en PDF…

    http://www.spaceeman.be/files/bugs/libo-pictures-bintrunc/ftl-bases.pdf

    On obtient alors un rectangle noir en lieu et place de l'image

    Titre de l'image

    Si à partir de Draw on enregistre l'image (menu contextuel…), on obtient un fichier tronqué, non plus de 380 octets mais de 368 octets !

    Titre de l'image

    ↑ en fonction du logiciel utilisé, l'image est correctement affichée (Firefox par exemple) ou un rectangle noir (GIMP par exemple).

    Il manque bien des octets,

    Titre de l'image

    Si l'on modifie le document, en supprimant des pages…, l'image embarquée devient la version tronquée !

    http://www.spaceeman.be/files/bugs/libo-pictures-bintrunc/ftl-bases-page6.odg

    Titre de l'image

    Voila, ma conclusion est que LibreOffice, dans cette version, peut gravement altérer des images embarquée, en supprimant des octets, soit lors de l'impression, export PDF ou suite à certaines manipulations…

    Qu'en pensez-vous ?

    Le bug est-il déjà connu ?

    Confirmation sur la liste de Jean-Baptiste Faure :

    À l'export en PDF j'obtiens un rectangle noir avec LO 5.4.4, 6.0.1.0+ et le master courant (future 6.1) mais pas avec 5.3.7.

    JB ajoute qu'avec d'autres documents et images PNG il n'a pas de problème (tout comme moi au passage) et pause la question de savoir ce que « ce petit fichier PNG a de particulier ». Il convient finalement :

    De toute façon ça semble bien un bug que tu peux rapporter ici :
    https://bugs.documentfoundation.org/
    Il faudra bien joindre ton fichier de test afin que le bug puisse être
    reproduit puis analysé.

    Bien à vous les amis :) Je vous tiendrai ici au courant si j'ai d'autre infos…

    Lire les commentaires

  • Du reverse engineering, et de la pomme (Journaux LinuxFR)

    Sommaire

    Dans ce journal, qui se veut un peu long mais clairement divisé en parties relativement
    indépendantes, j'aimerai expliquer les expérimentations que j'ai faite pour pouvoir ajouter de la
    musique sur un iPod (Apple, donc) de 7ème génération, qui n'est pas supporté par les outils actuels
    sous GNU/Linux.

    Et ça ne se finit pas élégamment, mais ça se finit quand même : j'écris ce journal en écoutant la
    musique de cet iPod, musique transférée depuis GNU/Linux !

    Le résultat en tant que tel n'a pas grand intérêt : ma solution n'est utilisable que pour ce type
    d'iPod là, et empêche l'utilisation d'iTunes, n'est pas graphique, etc… Mais comme c'est la première
    fois que je fais ce genre de chose, beaucoup d'éléments m'ont semblé intéressants, et j'espère aussi
    récupérer des avis et des conseils sur ces méthodes.

    Contexte

    Pour faire court, j'ai reçu un iPod 7g à Noël il y a deux ans (oui, c'est une excuse courante pour
    les linuxiens), et j'aurai quand même aimé l'utiliser. Sauf qu'il n'est pas possible de transférer
    des morceaux depuis les lecteurs de musique libres qu'on peut trouver sur GNU/Linux.

    Après quelques recherches, il s'avère que libgpod ne le supporte pas, et il n'y donc aucune raison
    pour que ça puisse marcher avec un quelconque lecteur. On trouve vaguement une procédure sur
    Internet, mais c'est à base de .so dont on n'a pas les sources, et de toute façon ça ne marche pas
    chez moi (il semble que j'ai un firmware trop récent).

    Je laisse donc tomber dans un premier temps. Mais cet été, je retombe dessus, et ayant un peu avancé
    dans mes études, j'ai un peu plus d'idées qu'avant. Je me décide donc à essayer de faire un peu de
    reverse engineering là dessus. Il va de soi que je ne me suis pas devenu un expert dans ce domaine
    en un an et demi.

    Un problème de signature

    Une approche large

    On a un peu de chance, tous les fichiers qu'écrit iTunes (en dehors du système lui même) sont
    lisibles normalement, comme si l'iPod était une vulgaire clé usb. Oui, ce n'était pas gagné.

    Déjà, je redémarre sous windows, j'installe iTunes, je réinitialise l'iPod. Je redémarre sur Arch, copie
    l'intégralité des dossier de l'iPod sur mon ordinateur, je rédemarre, j'ajoute un morceau, et je
    fais un diff pour voir les fichiers qui ont changé.

    Évidemment il n'y a pas qu'un, mais ça reste raisonnable, je les remplace un par un jusqu'à
    trouver ceux qui sont vraiment responsables du changement.

    3 fichiers ressortent du lot : Locations.itdb, Library.itdb, Locations.itdb.cbk.

    Là, agréable surprise, les deux premiers sont des bases de données SQLite. Victoire, je commence à bidouiller un peu, je peux changer le titre des morceaux en modifiant
    Library.itdb, ça marche bien. J'exulte. Sauf qu'ensuite, j'essaye d'ajouter un nouveau morceau. Pour
    ça, j'ajoute une entrée dans une table de Locations.itdb, et une autre dans Library.itdb. Et là, le
    drame, l'iPod me dit qu'il n'y a aucun morceau sur l'iPod. Donc non seulement ça a échoué, mais en
    plus, on a perdu les morceaux qui y étaient déjà.

    Je remets les bases de données dans un état antérieur qui fonctionne. Je commence à comprendre que
    le .cbk est une signature des autres fichiers. Je change un octet dans ce fichier avec ghex, et
    l'iPod déclare qu'il n'y a aucun morceau sur l'appareil. Maintenant on est certain qu'il s'agit
    d'une signature, et probablement seulement de Locations.itdb (déjà par son nom, et ensuite parce que
    les changements dans Library.itdb n'ont pas l'air de déranger l'iPod).

    Les grands moyens, le désassemblage

    Alors là, on examine un peu le fichier .cbk : 177 octets, ce qui ne correspond pas un standard
    largement répandu (i.e. je ne trouve pas ce que ça peut être), j'essaye quand même des trucs au
    hasard, mais bon, même en supposant que ça soit un sha quelconque, il suffit qu'il y ait simplement
    un masque appliqué sur Locations.itdb pour que je n'ai aucune chance de trouver. Donc ça,
    j'abandonne.

    Je me lance donc dans la décompilation d'iTunes, ou plutôt dans le désassemblage, puisque j'apprends
    au passage qu'il n'y a pas de logiciel accessible pour décompiler un truc de cette taille là et
    avoir un résultat un peu intéressant (oui, ça existe mais ça ne marche pas bien du tout).

    Là surprise, les outils classiques fonctionnent bien, même si c'est un binaire Windows
    et qu'on désassemble sous Linux.

    Là, la seule chose que je peux chercher c'est "cbk". Gros coup de chance, il y a 2 occurences. L'une
    me mène dans le segment de data, je récupère l'adresse, je cherche dans l'assembleur où elle est
    utilisée, et pareil un nombre très réduit d'occurrences.

    Je tente de lire l'assembleur et de le décompiler à la main les morceaux qui semblent prometteurs :
    autant dire qu'au bout de quelques heures j'abandonne, c'est incompréhensible.
    Je fais quand même quelques expérimentations, j'écris un programme qui sépare l'asm en fonctions, et
    qui leur donne des noms d'animaux aléatoires à la demande. C'est rigolo, mais ça ne m'avance pas
    beaucoup.

    Une petite victoire, des maths, et le désespoir

    Pour poursuivre un peu dans cette voie, j'ai besoin de voir comment le code s'exécute. Je fais des
    recherche, je trouve un débugguer pour Windows, je redémarre, je mets des breakpoints sur les
    adresses que j'ai remarquées à l'étape précédente. Je lance iTunes avec le débugguer, ça crash. Je
    recommence, pareil. Finalement je lance iTunes, et
    j'attache le débugguer ensuite (ça revient en gros au même). Ce n'est pas super stable (c'est le
    moins qu'on puisse dire), mais ça marche à peu près.

    J'ajoute un morceau à l'iPod, et le débugguer s'arrête sur un breakpoint. Ouf, je n'avais plus
    d'idées sinon.

    Alors là, j'y passe des heures, je fais marcher le débugguer pas à pas, entre les crash, j'essaye de
    faire une carte du code voir par où on va, si je comprends quelque chose. J'utilise mon programme
    qui sépare l'asm en même temps, pour donner des noms aux fonctions que je rencontre. Quand elles
    sont appelées à d'autres endroits, je ne les étudie pas, etc…

    Au bout d'un moment, j'arrive à comprendre à peu près dans quel ordre les bases de données et la
    signature sont écrites. Mais bon…

    Et à un moment, je tombe sur le code de chargement de 4 constantes, ça ressemble à l'initialisation
    d'un code de crypto. Je les mets dans mon moteur de recherche favori, et là, boum, c'est du sha1. Je
    passe encore quelques heures à étudier ça, et finalement, j'arrive à déterminer que sha1 est appelé
    sur les 1024 premiers octets de Locations.itdb, puis les 1024 suivant, et cela 4 fois.

    Hop, je split le fichier, je calcule le sha1, et je les retrouve dans le .cbk. Jubilation.

    Mais ça ne fait pas tout le fichier ça, il manque encore pas mal d'octets du cbk. Je réétudie
    l'assembleur, je me rends compte que les 4 hash calculés sont accolés et qu'ensuite on recalcule
    encore une fois le sha1 là dessus. Hop, ça ne laisse plus que 55 octets dans le .cbk.

    Et là… je continue de regarder l'asm et le débuggueur, je ne trouve plus rien. Pire, l'assembleur
    change d'un coup, il devient encore plus difficile à lire. Je ne suis pas arrivé à décider si c'est
    le débugguer qui bugguait ou si c'était fait exprès mais il semblerait que certains endroits du code
    incrémentent %pc de seulement quelques octets, ce qui décale le cadre de lecture de l'asm. En plus,
    les instructions qui font ça le font après avoir fait tout un tas de calculs absurdes (genre mutiplier
    par 0x452FE45 puis soustraction de 0x786798, puis on remultiplie… tout ça pour faire moralement %pc = %pc + %rax,
    avec %rax = 2). Alors je commence à me dire que c'est peut-être de l'obfuscation et que c'est juste
    fait exprès pour ne pas qu'on puisse continuer.

    Ça fait donc 55 octets, qui sont probablement calculés à partir de 122 premiers. Mes maigres
    connaissances en crypto me disent que je n'ai absolument aucune chance d'inverser ça par force
    brute, et que ce n'est absolument pas standard. Bref, c'est désespérant.

    C'est dommage, j'ai la majorité des octets, mais il en suffit d'un de faux… J'abandonne pour le
    moment.

    La solution détournée, mais peu élégante

    Hop, ce sont les vacances de Noël, je retombe sur l'iPod que je n'ai toujours pas utilisé, et je n'y
    remets. Après quelques égarements dans l'asm et le débuggueur (qui avance un peu, j'ai trouvé un peu
    plus dans l'asm quelles étaient les fonctions qui généraient la signature), je commence à relaisser
    tomber.

    Mais en fait, on a pas besoin de générer la signature à chaque fois. Le contenu de Locations.itdb
    est assez inutile. Grossièrement, cette base de données ne sert qu'à associer un id à un fichier.
    Donc quand on ajoute un morceau, il faut rajouter une ligne. Oui mais en fait, je fais un test, et
    on peut avoir plus de ligne dans Locations.itdb que de morceaux dans Library.itdb.

    On va donc faire générer à iTunes une signature pour une bases qui contient des centaines de
    morceaux, puis les supprimer de Library.itdb, et on aura un certain nombre d'emplacements disponibles
    pour mettre nos morceaux. Quand on en ajoutera un, il suffira de prendre une ligne qui n'est pas
    encore associée à un vrai fichier dans Locations.itdb, et la rajouter dans Library.itdb, avec toutes
    les informations sur ce morceau (titre, artiste, album, etc).

    L'intérêt de la méthode c'est qu'on a besoin une seule fois d'iTunes, et ensuite ça marche (très
    probablement) pour tous les iPod du même modèle (enfin ça c'est à vérifier, mais j'y crois).

    Et ça marche ! Je sépare un mp3 en 10000 morceaux, j'importe ça dans iTunes, je les copie sur l'iPod
    (enfin là je suis passé à 3000, 10000 ça faisait tout planter), et ça génère bien un Locations.itdb
    avec 30000 entrées.

    Reste à coder de quoi ajouter automatiquement toutes les données aux bases de données de l'iPod,
    gérer les "emplacements" disponibles à chaque fois, etc…

    Après 2 petites journées à coder en Vala, je transfère la majorité de ma bibliothèque depuis Linux,
    sans avoir besoin d'utiliser Windows. Le code est ici, mais ça risque probablement de détruire toute
    la bibliothèque de votre iPod si vous l'utilisez…

    Conclusion : les formats ouverts et les formats ouverts

    Ces expérimentations m'ont donc permis d'écrire un programme qui transfère bien des morceaux depuis
    Linux vers un iPod.
    La conclusion reste quand même qu'il faut acheter des produits qui ont des spécifications un minimum
    ouvertes, à défaut de matériel et de logiciel libre.

    Cependant, dans cette histoire qui peut sembler noire de logiciels propriétaires, on voit quand même
    les bienfaits des logiciels open source. Parce que oui, on s'aperçoit qu'Apple utilise des
    technologies largement répandues ou des spécifications standards : SQLite, sha1, etc… Sans cela, il
    est certain que ce travail aurait été très laborieux, voir impossible.

    L'autre aspect, c'est qu'il semble évident que les ingénieurs d'Apple ne cherchent pas à empêcher
    l'utilisation de leur matériel sur d'autres systèmes, ils ne l'encouragent pas, c'est vrai, mais il
    n'y a pas particulièrement de protection là dessus : les coups de chance que j'ai eu ne seraient pas
    possibles si les ingénieurs s'étaient sérieusement dit qu'il fallait l'empêcher (ou sinon c'est qu'il
    sont assez incompétents et négligents, mais je ne le crois honnêtement pas).

    Enfin, quelques mots sur le côté légal de la chose : désassembler le code d'iTunes comme je l'ai fait est probablement formellement interdit par la licence d'utilisation. Cela dit, on peut aussi voir cette démarche comme nécessaire pour faciliter l'interopérabilité, comme le fait VideoLAN. C'est étonnamment clair dans le code de la propriété intellectuelle :

    La reproduction du code du logiciel ou la traduction de la forme de ce code n'est pas soumise à l'autorisation de l'auteur lorsque la reproduction ou la traduction au sens du 1° ou du 2° de l'article L. 122-6 est indispensable pour obtenir les informations nécessaires à l'interopérabilité d'un logiciel créé de façon indépendante avec d'autres logiciels

    Lire les commentaires

  • Dr. Geo 18.06 (Dépêches LinuxFR)

    GNU Dr. Geo est un logiciel de géométrie interactive euclidienne du plan, pour une utilisation à l'école secondaire et primaire. Il permet d'organiser des activités pédagogiques dans l'enseignement de la géométrie, voire d'autres domaines liés des mathématiques.
    Intégré à un environnement dynamique de programmation Smalltalk, il propose également une approche de la géométrie dynamique par la programmation, soit par l'utilisation de script(s) intégré(s) à une figure, soit par une description purement programmatique d'une construction géométrique. En outre, Dr. Geo est toujours modifiable depuis lui-même, fonctionnalité héritée de son environnement de développement.

    Dr. Geo 18.06

    La version 18.06 fait suite à la version 17.07 sortie en juillet 2017. Une grande partie de l'effort fut de porter le code de la version 3 à la version 7 de l'environnement Smalltalk Pharo avec lequel est développé Dr. Geo. Outre les corrections de bugs inhérentes à ce portage, quelques fonctionnalités nouvelles ont fait leur apparition.

    Nouvelles fonctionalités

    Dans Dr. Geo, un script est défini par une classe Pharo. L'utilisateur insère alors une instance du script dans la figure géométrique ; il lui associe si nécessaire d'autres objets géométriques de la figure en paramètres. Un script effectue un traitement ad-hoc, calculs ou modifications sur d'autres objets de la figure tels que programmés dans les méthodes du script. Une fois défini, le script est facile à utiliser.

    L'édition de script se fait maintenant à l'aide d'un outil d'édition de code dédié, et non plus par l'intermédiaire du navigateur de code de Pharo, qui est pour le moins impressionnant.

    À noter que l'ajout d'attribut au script nécessite toujours l'utilisation du navigateur de code de Pharo. Ce besoin est nécessaire uniquement lorsque le script a un état dont il doit se souvenir tout au long du cycle de vie de la figure.
    Editeur de script

    Le manuel utilisateur a une section dédiée au script.

    Inspecteur sur code de figures programmées

    Une figure programmée est l'autre forme d'utilisation de la programmation dans la géométrie dynamique. Dans cette approche la figure géométrique est entièrement définie par un code Smalltalk et l'utilisation de l'API dédiée.

    Il est dorénavant plus aisé de gérer ses fichiers de figures programmées. Le nouvel inspecteur de Pharo — outre l'inspection d'attributs d'instance de classe — propose aussi de voir, d'exécuter, d'éditer et de créer les scripts de figures programmées.
    Inspecteur sur scripts de figures programmées

    Zoom positionnel

    Pour zoomer dans une figure l'utilisateur dispose du widget de molette orange en haut à droite de chaque figure ou de la molette de la souris. Le zoom par la souris est maintenant positionnel, focalisé sur la position du curseur souris ; celui par le widget reste, lui, centré au milieu de la zone visible de la figure.

    Détection de polygone sans surface

    Lorsqu'un polygone est sans surface (vide), Dr. Geo ne détectera que ses lignes, et non plus sa surface intérieure puisqu'elle n'existe pas.
    Polygone sans/avec surface

    Tests unitaires basés sur figures programmées

    Le petit corpus de figures programmées distribué avec Dr. Geo est également utilisé pour définir une série supplémentaire de tests unitaires.

    Partage réseau

    Dans le cadre d'une activité pédagogique en salle informatique, distribuer aux élèves des fichiers de figures est pratique. Dr. Geo propose maintenant une fonctionnalité de partage en réseau local, indépendante des services du réseau local (NFS, Samba, Windows, etc.). La marche à suivre est la suivante :

    1. L'enseignant sauve les documents à partager dans son dossier DrGeo.app/MyShares : MyShares
    2. L'enseignant active le partage réseau local depuis le navigateur de préférences de DrGeo (menu Système, Préférences) : Activation du partage
    3. L'élève, depuis l'outil habituel d'ouverture de figures, parcourt les figures partagées (bouton 'Partage enseignant') : Parcourir les figures partagées

    Cette fonctionnalité peut s'utiliser de façon croisée avec Linux, Mac et Windows.

    Thèmes graphiques

    Le navigateur de préférences (menu Système, Préférences) donne accès à deux thèmes graphiques, hérités de Pharo :

    • Thème sombre, par défaut, à privilégier lorsque Dr. Geo est utilisé de façon autonome sur un seul poste.
      Thème sombre

    • Thème clair, à utiliser en vidéo projection, par exemple, car le thème sombre manque de contraste.
      Thème clair

    Option plein écran

    Depuis le menu système, l'utilisateur peut basculer en affichage plein écran ; le système hôte est alors complètement masqué. Pratique pour que les élèves se concentrent sur leur activité de géométrie dynamique.

    Les autres modifications de la version 18.06.

    Commentaires : voir le flux atom ouvrir dans le navigateur

  • France Culture: que reste-t-il du logiciel libre ? (Journaux LinuxFR)

    Bon jour Nal !

    L'émission Du grain à moudre d'hier, sur France Culture, posait cette question: « Que reste-t-il du logiciel libre ». Des représentants de Framasoft et de Microsoft tentaient de répondre à la question. On peut écouter l'émission en podcast.

    J'écoutais vaguement en faisant la cuisine… J'en ai néanmoins déduit une conclusion:

    • Le modèle économique du logiciel libre, qui consiste à vendre un service plutôt que le logiciel l'a emporté. C'est du moins le modèle économique que le représentant de Microsoft considère dorénavant le plus viable.
    • Le logiciel libre, entendu comme 4 libertés, prospère dans les piles logicielles éloignées de l'utilisateur final, mais peine à s'imposer dans les logiciels plus proches de l'utilisateur final.
    • L'éthique que certains (dont moi) associent au logiciel libre, de maîtrise de son outil de travail ou de ses données perd du terrain. Non seulement parce que le modèle du service (dans les nuages) s'est imposé, mais aussi parce que d'une manière générale, plus l'on s'approche de l'utilisateur final, moins on trouve de logiciel libre.

    Commentaires : voir le flux atom ouvrir dans le navigateur

  • La voiture en open source (Dépêches LinuxFR)

    « Vous ne téléchargeriez pas une voiture… » disait la vidéo. Eh bien, justement, si !

    Télécharger une voiture ?
    Cette image (du centre) est tirée de la vidéo bien connue insérée dans de nombreux DVD et Blu‐ray, dans laquelle l’annonceur ose comparer le matériel et l’immatériel : on soustrait un bien matériel (don, échange, vente ou vol), là où l’on multiplie un bien immatériel (copies à loisir). Ce débat est bien évidemment volontairement faussé et donc caduque.

    OSVehicle
    OSvehicle est justement une tentative de voiture libre et open source. Vous pouvez enfin télécharger une voiture, et ce n’est pas voler (c’est rouler d’ailleurs).

    L’idée n’est pas seulement de produire un design modifiable, modulaire et DIY (« Do It Yourself »), ou de produire localement, et de manière indépendante. L’idée est également d’innover, de s’adresser aux marchés de niche, de réduire l’impact écologique et, bien évidemment, de partager les savoirs et les passions.

    Une des motivations clefs du véhicule open source est aussi de reprendre le contrôle sur la réparabilité et la bidouillabilité à l’heure de l’obsolescence programmée, sur le véhicule connecté, et de produire de manière équitable (fair trade). Bien évidemment, ce projet est à très haut potentiel.

    Le véhicule open source est donc une plate‐forme ouverte, incluant le châssis, le moteur et la partie électronique.

    Appel à contribution sur la section « Do It Yourself » 

    Le bricolage ou bidouillage est central dans le libre, et pas seulement au niveau code. Quelques dépêches ont couvert ce sujet par le passé :

    NdM : Une dépêche sur InMoov, un robot avec plans sous licence libre à imprimer en 3D (voir vidéo) serait la bienvenue.

    Lire les commentaires

  • Sortie de Firefox 59 (Dépêches LinuxFR)

    La version 59 de Firefox est sortie le 13 mars. Elle apporte son lot de nouveautés, ses améliorations de performances (notamment pour les utilisateurs de macOS) et un souci toujours accru de protéger la vie privée de ses utilisateurs (versions bureau et mobile).

    Logo Firefox

    Nouveautés communes aux versions bureau et Android

    La navigation en mode privé n’enverra plus le chemin dans l’en‐tête Referer pour éviter le traçage entre sites.

    Nouveautés pour le bureau

    La page d’accueil a été améliorée : elle se charge plus rapidement, il est possible de faire du glisser‐déposer pour réarranger les sites les plus vus et de nouvelles possibilités vous sont offertes pour personnaliser la page.

    Mozilla croit en la décentralisation d’Internet et a ajouté la possibilité pour les extensions de pouvoir attraper les liens dat://, ipfs:// et ssb://, trois protocoles en vue.

    Dans les préférences, une partie sur les permissions (localisation, caméra, microphone, notifications, etc.) a été ajoutée afin de voir quelles sont les autorisations et blocages effectués. Il est également possible de bloquer totalement les demandes, mais Mozilla prévient que cela risque d’empêcher le bon fonctionnement de quelques sites Web.

    Les WebExtensions ont également eu leur lot de nouveautés comme, par exemple, la possibilité d’enregistrer des scripts de contenus de manière dynamique.

    Off‐Main Thread Painting continue d’être proposé à de nouveaux utilisateurs. Dans la version 58 de Firefox, c’était activé par défaut pour Windows. C’est maintenant aux utilisateurs de macOS d’avoir la fonctionnalité par défaut avec la version 59. Et GNU/Linux pour la prochaine version ?

    Les captures d’écran de Firefox peuvent maintenant être éditées (recadrage, annotations).

    La prise en charge des protocoles de communication en temps réel (RTC) a été améliorée. Et la spécification Pointer Events a été implémentée, permettant de mieux gérer les souris, écrans tactiles et autres mécanismes de saisie avec un pointeur.

    Enfin, notons que le moteur de recherche Qwant est dans la liste des moteurs de recherche par défaut pour les utilisateurs de la version française de Firefox 59.

    Nouveautés pour Android

    La compatibilité avec les sites de diffusion vidéo a été améliorée grâce à la prise en charge du protocole HLS (HTTP Live Streaming). Le travail sur les performances continue en tâche de fond.

    Et pour le futur ?

    F-droid

    Firefox pourrait faire son apparition sur F-Droid avec la version 60. En effet, un drapeau --without-google-play-services a été ajouté pour se passer des services Google Play à la compilation de Firefox, ce qui est un prérequis pour rejoindre le marché d’applications F-Droid.

    Blocage des fenêtres modales

    Firefox a été l’un des premiers navigateurs à bloquer les fameuses « pop‐ups ». Depuis, les fenêtres modales en JavaScript sont devenues un moyen populaire, mais tout aussi désagréable, de fournir la même (anti)fonctionnalité. La question de bloquer ces fenêtres modales est à l’étude. Si vous voulez aider, vous pouvez installer l’extension In‐Page Pop‐up Reporter qui va fournir des informations à Mozilla à ce sujet.

    Et du côté des extensions

    Ghostery

    L’extension Ghostery est (finalement) passée sous licence libre MPL 2.0 (mais, personnellement, je continue de préférer uBlock Origin comme bloqueur de publicités).

    Grammalecte

    Grammalecte a sorti une nouvelle version, la 0.6.2. Elle apporte des nouveautés, mais certains utilisateurs ont été surpris par la nouvelle permission demandée, à savoir sur l’API « downloads ». Comme son auteur l’explique, Grammalecte ne s’en sert pas pour espionner les fichiers que vous avez téléchargés, mais juste pour permettre d’exporter certaines données depuis Grammalecte (c’est la seule façon que les extensions ont pour écrire sur le disque dur).

    Commentaires : voir le flux atom ouvrir dans le navigateur

  • Quel IDE pour quel langage (Journaux LinuxFR)

    Il y a trop longtemps, le débat sur les IDE se cristallisait entre VI et EMACS. Sur l'un, il fallait appuyer sur 3 touche en même temps, l'autre l'une à la suite de l'autre.

    Par hasard, j'ai appris Emacs, et changer de réflexe sur les raccourcis est très compliqué (genre ctrl-x rt). J'ai beaucoup codé en C, et ocaml et perl dessus avec succès.

    Puis j'ai fait du Java avec Eclipse. Il me manquait une tonne de fonctionnalité d'édition de base par rapport à Emacs, mais se rajoutait un des fonctions nouvelles très puissantes, comme l'auto-complétion depuis les library, qui suivait le typage et la syntaxe, la documentation par le survol (pas besoin d'aller chercher un fichier particuliers), le reformatage de code (factorisation de fonction depuis un bout de code). De retour sous Emacs, tout cela me manque.

    J'ai fais aussi un détour sous Visual Studio pour le C++, où la navigation entre fichier (clic d'une fonction pour avoir sa déclaration), et le debuging visuelle était vraiment agréable.

    Depuis que je code en go, j'aime de moins en moins Emacs, et sa tonne de fonction dont il faut se rappeler le nom pour les utiliser, si encore on sait qu'elle existe genre "global-auto-revert-mode".

    Dans la grande étude de codingame, il parle des IDE préférés de leur codeur. cf : http://publications.codingame.com/codingame-2018-developer-survey/what-developers-want

    J'ai du mal à imaginer un IDE sans associer le langage qui va avec. Le support de C++ dans Eclipse n'est pas du tout au même niveau que le Java, par exemple.

    Visual Studio 42% Univers Microsoft
    IntelliJ 30% Java
    Visual Studio Code 27% de tout
    Eclipse 25% Java
    Atom 16% de tout
    PyCharm 15% Python
    NetBeans 9% Java ?
    PhpStorm 7% PHP
    Code::Blocks 7% C/C++/fortran
    Xcode 6% Univers Apple
    Cloud9 3% de tout dans le cloud
    Other 16%

    (désolé pour le vrac mais linuxfr ne supporte pas le fait d'embarquer des bouts de code externe :/)

    Pour vous quel sont les couples "ultimes" IDE-langage ? Qu'est-ce que vous conseillez ? Qu'est-ce que vous déconseillez formellement ?

    Lire les commentaires

  • 1 mois avec UBPORTS sur un téléphone LG Nexus 5 (Journaux LinuxFR)

    Ubports est un projet qui continue le développement de Ubuntu Touch après l'arrêt de celui-ci par Canonical. Le projet est actif, avec un financement sur Patreon.
    Ubports est à ma connaissance la seule distribution Linux (autre qu’Android et dérivés comme Lineage OS ) utilisable actuellement sur téléphones/tablettes (peu de modèles, voir plus loin).
    ( Sailfish OS est en pause, il y a aussi un nouveau projet de Linux sur Samsung (en fait pas vraiment pareil , car Linux ne sera utilisable que quand le téléphone sera relié à un écran/clavier), ou encore le futur Purism )

    Donc, ce journal est un retour sur l’utilisation d’Ubports sur un téléphone Nexus 5. C'est un peu la suite de ce journal de gnumdk datant de 2016: 1 an sous Ubuntu Phone .

    Choix du téléphone:

    Peu de modèles compatibles, et plutôt anciens (voir ici ) .
    Le Nexus 5 est le modèle le mieux supporté . Il n’est pas trop dépassé (cpu 2 ghz, 2 go ram, full hd, 32 go de stockage interne). J’en ai acheté un sur Ebay pour moins de 100 € (prendre un d821 pour l’Europe) .

    Installation:

    J’ai utilisé MDT (magic device tool): voir ici .
    Sur le téléphone connecté en usb, il faudra activer le mode développeur, rebooter en mode bootloader (Touches Power + Vol- appuyées au redémarrage) , accepter le déblocage du bootloader.
    L’installation dure longtemps : certaines étapes durent 10 mn sans signe d’activité.
    Si il n’y aucune activité pendant plus longtemps , forcer un reboot pour reprendre l’installation .
    Quand l’interface Ubuntu apparait, il faut faire la dernière mise à jour OTA2 depuis les paramètres, puis rebooter un dernière fois.

    Utilisation

    Interface utilisateur :

    Au début, on est assez gêné par la disparition des 3 touches en bas de l’écran . Il faut s’habituer à utiliser la barre de tache à gauche de l’écran et la touche “retour” du navigateur. Finalement, la barre de tache est très pratique , elle permet en plus de quitter les applis , ce qui manque sur Android.
    Après quelques plantages pendant les premiers jours, le système est stable , pas de reboot depuis 7 jours .

    Téléphone et sms:

    Cela marche bien , le son est bon , les notifications d’appel fonctionnent..

    Photo :

    Fonctionne

    Wifi et 4g :

    Fonctionne bien , pas de déconnections wifi

    Batterie:

    C’est moyen: la décharge est assez rapide quand on fait fonctionner le navigateur (suffisant pour plusieurs heures quand même) . Couper le wifi et la 4g pour la veille téléphone permet de dépasser largement 24h sans recharge (d’après la courbe de décharge, ça pourrait tenir 48h ).

    pas de problème , de rares blocages , c’est Chromium à ce qu’il semble. Les versions “mobiles” des sites passent bien (quand elles existent) : je les utilise pour un webmail, ma banque, chess.com , Google drive etc …. Cela corrige un peu le manque d’applis disponibles .

    Applis sur Openstore :

    Elles proviennent de l’ancien store de Ubuntu Touch, qui est encore accessible quelques temps : les 2 stores sont donc accessibles depuis le téléphone.
    Certaines applis ne sont pas (encore?) dans Openstore comme le “Clementine remote” .
    J’utilise une appli Flas pour le stream radio , une appli mail Dekko, un navigateur GPS Unav (pas assez testé , semble fonctionner en mode “en ligne”, possibilité de charger des cartes depuis Openstreetmap pour le mode “hors ligne” mais pas de navigation dans ce cas )

    Pour Deezer, et Spotify , pas de site mobile. Pour Spotify , une appli “Cutespotify” mais il faut un compte premium.
    C'est corrigé par une appli “cloudmusic” qui utilise un fournisseur chinois et accède à 10 millions de morceaux (pas que chinois) sans pub et légalement (?) , (voir cette question ) .
    Le journal 1 an sous Ubuntu Phone traite plus longuement des applis disponibles.

    Conclusion:

    UBports marche assez bien pour mon usage quotidien et en plus, c’est vraiment amusant à utiliser. J'espère avoir donné envie à certains de l'essayer…

    Lire les commentaires