Linux (fr)

  • WhatsApp, sa porte discrète du fond et les backdoors de Signal (Journaux LinuxFR)

    Nous le savons tous WhatsApp n'a pas de backdoor, c'est d’ailleurs pour ça que son code source n'est pas public : ya rien à voir, tchatez.

    Une très bonne explication est publiée sur le site de Reflet :

    Il suffit à WhatsApp d’ajouter un nouvel appareil virtuel au compte de Bob, cet appareil recevra ainsi les messages qui lui sont destinés
    De manière générale c’est le problèmes des systèmes où le lien entre personne physique et clef de chiffrement est établi et contrôlé par un acteur tiers, comme WhatsApp, ou en utilisant des mécanismes peu fiables, comme le contrôle du numéro de téléphone.
    C’est également un problème par ex. chez Apple (iMessage) : Apple gère la liste des appareils liés à un compte et est donc en mesure d’ajouter un appareil « fantôme » au compte qui recevrai alors tous les messages qui lui sont destinés, et peut se faire passer pour ce compte.

    Cependant, selon certains avis avisés de la Free Software Foundation Europe, il y aurait un certain nombre de BackdoorS présentes lors de l'utilisation du logiciel Signal (logiciel développé par Open Whisper Systems, entreprise qui a vendu à WhatsApp la mise en place de l'implémentation non-publique du protocole TextSecure-Axolotl-Signal_Protocol et qui nous assure qu'ils n'ont pas mis de backdoor dans le code-source non-publié de WhatsApp - logiciel qu'ils recommandent même si c'est leur concurrent).

    Revenons-en à nos Systèmes Chuchotants (presque) Ouverts et parfois fermés et à ses portes d'accès inattendues. Ce que je trouve notable dans l'article de la FSFE :

    Well beside the point about Signal being suggested by several widely known people: While Signal is indeed open-source, it is still not free software because it uses an external library that is not open. So every audit that works on the source code will fail to find security issues and backdoors in that externally included code – and this is where I want to start to look into Signal now.

    […]

    Google Cloud Messaging and other METADATA
    Well, you need to consider that Google knows a lot about everyone. The usual Android user will grant Google access to his contact database, list of installed apps, when which app is started, your current location, which text you write using the devices virtual keyboard (when using the “Gboard”) and even more.

    […]

    So, when using Gboard, Google already knows the content of the messages shared, but not the recipient. And this is where the GCM data can be used. It shouldn’t be too hard to correlate the fact that one user is sending a message via Signal to another user receiving it.

    […]

    With Gboard active, Google even knows the exact moment the message is sent (enter key is pressed). Of course there are millions of Signal users with different users likely sending messages in approximately the same time, but it’s no problem if you need multiple messages to be sure and there is another bunch of information further restricting the search space: both users likely have the phone number of the other one in their phone’s contact list and Google is usually well aware of the contents of your contact list.

    […]

    Maps Integration
    Critical about this is that the MapView view as used by Signal is just a wrapper that loads the actual MapView, by including code from the Google Play Services binary

    […]

    The code is then executed in the Signal process, which includes access to the Signal history database and the crypto keys.

    […]

    The Google Play Services binary can easily be updated in background through Google Play Store, even targeted to single users, and the updated code would become active inside Signal the moment you use it next time. Can it get worse? Yes. An apk update would be detectable to the user, but Google Play Services uses a dynamic module loading system (called Chimera and/or Dynamite) that seems to be capable of replacing the Maps implementation from a file not installed to the system, as long as it’s signed by Google.

    […]

    But Signal is Forward secret, You can’t read old messages
    The forward secrecy feature is only on the transport level. At both ends (in groupchats, all ends) the messages are available in plain text in form of a history. If you or the other(s) don’t wipe your chat history regularly, your history is still attackable. But this is how users want it, because it’s more user-friendly.

    […]

    Et vous, qu'en pensez-vous ?

    Lire les commentaires

  • Faire un peu d'argent avec le logiciel Libre, l'après Wallabag... (Journaux LinuxFR)

    Bonjour'nal,

    Alors que j'étais en pleine réflexion sur le devenir du projet Unixcorn et notamment son financement (dépendant actuellement à 98% de mon portefeuille) j'ai découvert l'article de blog de Nicolas Loeuillet, racontant le lancement de son entreprise wallabag.it : http://nicolas.loeuillet.org/billets/service-wallabag-it

    Ça me titillais depuis bien longtemps, après avoir travaillé comme administrateur système dans une grande entreprise helvète, avoir repris les études en Bretagne, travailler à mon compte me faisais de l’œil et m'attirais grandement. Non pas grâce au statut, ou l'écosystème environnant (French-Tech-mes-fesses très peu pour moi) mais pour l'indépendance et la capacité de travailler d'un peu n'importe où sans contraintes.
    J'ai donc contacté Nicolas et lui ai fait part de mon projet, le remerciant au passage pour son second article nous contant le début de son aventure, il sembla de suite enjoué et m'encouragea à me lancer. Voila ce qui fut fait en ce début de mois de janvier…

    J'ai donc créé une micro-entreprise de vente de services, Whiskers Systems, axés pour l'instant autour de trois logiciels phares :

    Je propose ensuite deux types d'offres, la première est l'hébergement de l'utilisateur sur notre propre infrastructure (sauf pour GitLab où il est possible de créer un compte gratuitement sur l'instance d'Unixcorn) et la seconde qui est l'installation, la configuration et la maintenance d'un serveur dédié avec la solution choisie.

    J'ai donc créé un site internet, à base d'un "template" HTML simple (qui s’avérera être le même que celui de wallabag.it 🙈) et publié quelques offres avec la solution de payement française PayPlug. Celui-ci n'est pas encore terminé, les versions anglophones, néerlandaises et allemandes ne sont pas encore en ligne, pas encore de logo, etc.
    Si vous avez des retours à faire ce sera avec plaisir, l'expérience étant toute nouvelle pour moi. 😀

    Bonne visite !

    Lire les commentaires

  • Google chiffrement de mail end to end (Journaux LinuxFR)

    Bonjour à tous,

    Il semblerait qu'il y ait quelques avancements concernant le chiffrement de bout en bout avec google mail.

    Google vient de publier le projet keytransparency. Projet devant permettre de construire des clients (web)mail permettant le chiffrement de bout en bout pour monsieur et madame Michou.

    Mais corrigez moi si j'ai mal compris.

    Blog post à propos de key transparency
    Application Chrome
    Projet end-to-end

    Vous en pensez quoi ?

    Lire les commentaires

  • Le logiciel libre vu dans un contexte élargi (Journaux LinuxFR)

    Encore un journal Bookmark, mais totalement en rapport avec le libre cette fois :
    Dans le cadre d'une série d'essais sur la notion de commun, un certain D. Temple propose ce joli texte (rien à voir avec l'illustration) ; narration diachronique du copyleft à travers l'histoire de monsieur Stallman, s'éclairant du contexte historique et philosophique. Pour ceux qui trouvent encore normal qu'autrui ai plus de pouvoir qu'eux mêmes sur leurs ordinateurs et leurs données (ce qui est le cas de la plupart d'entre nous, même utilisateurs exclusifs de logiciels libres), voici peut-être de quoi ouvrir un peu la réflexion sur un thème dépassant infiniment le seul domaine de l'informatique.
    Plus qu'un simple rappel de l'histoire de la GPL, ce texte et l'essai dans lequel il s'inscrit montrent comment la notion de logiciel libre s'inscrit dans une réflexion plus globale qui engage l'avenir de l'humanité.

    Désolé pour le côté lyrique et grandiloquent de cette présentation il fallait éviter le côté trop ouvertement je donne mon lien et --->[] ; pardon aussi aux collègues programmeurs que le texte assimile avec des dispositifs électromécaniques contrôlant laves-vaisselle et laves-linge :-).

    Lire les commentaires

  • Sortie de GHC 8.0.2 et une petite histoire de typage statique (Journaux LinuxFR)

    Sommaire

    GHC, le compilateur Haskell le plus utilisé, est sorti en version 8.0.2, vous pouvez consulter l'annonce de la sortie datée du 11 janvier 2017 ainsi que les notes de version

    Il s'agit principalement d'une version de suivi qui corrige plus de deux cent bugs depuis la version 8.0 dont l'annonce de la sortie
    avait été faite sur http://linuxfr.org. Donc à ce titre, il n'y a pas grand chose à raconter. Le futur, c'est GHC 8.2 qui devrait arriver aux environs d'avril si on en croit le planning. Celle-ci devrait apporter principalement des améliorations de performance de l'environnement d'exécution parallèle et du ramasse-miettes.

    Comme ce journal frôle le journal bookmark et que je tient à mon karma, je vais vous présenter une fonctionnalité d'Haskell, que l'on retrouve dans de nombreux langages, j'ai nommé les ADT, où types de donnée algébriques

    Il s'agit d'un croisement un peu douteux entre les struct, bien connus de nombreux langages de programmation, et les union, utilisés en C/C++ et qui sont une sorte d'enum. Le tout gonflé aux stéroïdes de la généricité, de la sécurité et du sucre syntaxique.

    Remarque : ce journal a été rédigé dans l'espace de rédaction de dépêche, pour profiter de la collaboration pour corriger notamment de nombreuses coquilles. Merci aux participants, palm123, Anthony Jaguenaud et Lucas pour leur remarques bénéfiques.

    ADT : un struct

    Un ADT c'est un type. Commençons d'abord par la partie qui ressemble à des struct. Si je veux faire un point à 3 dimensions en Haskell, je ferai :

    data Point = PointC Float Float Float deriving (Show)

    Il s'agit de la déclaration du type Point. Ce type peut être construit grâce à un constructeur PointC qui prend 3 Float et renvoi un Point. Le type de ce constructeur est PointC :: Float -> Float -> Float -> Point, une fonction qui prend un Float, puis un autre Float, et encore un Float et renvoie un Point. Le nom du constructeur est libre, il aurait très bien pu être le même que le nom du type.

    La clause deriving (Show) sert à générer automatiquement des fonctions pour l'affichage.

    Un petit exemple de cas d'utilisation dans le shell interactif GHCI :

    Prelude> PointC 1 2 3
    PointC 1.0 2.0 3.0
    Prelude> PointC 4 5 6
    PointC 4.0 5.0 6.0

    Le constructeur PointC peut aussi servir à déconstruire" les valeurs si il apparaît du coté gauche du signe = :

    Prelude> PointC a b c = PointC 1 2 3
    Prelude> a
    1.0
    Prelude> b
    2.0
    Prelude> c
    3.0

    Ceci est très pratique lors de la création de fonctions :

    Prelude> getX (PointC x _ _) = x
    Prelude> getY (PointC _ y _) = y
    Prelude> getZ (PointC _ _ z) = z
    Prelude> norm (PointC x y z) = sqrt (x * x + y * y + z * z)
    Prelude> p = PointC 1 2 3
    Prelude> getX p
    1.0
    Prelude> getY p
    2.0
    Prelude> getZ p
    3.0
    Prelude> norm p
    3.7416575

    Nous avons donc vu qu'un type en Haskell peut être vu comme un struct / objet dans d'autres langages, c'est à dire un agrégat de champs de type hétérogène. Si cela vous inquiète, on peut aussi donner des noms aux champs :

    data Point = Point {x :: Float, y :: Float, z :: Float}

    Mais ceci est une autre histoire.

    ADT : un enum

    Les "enum" dans de nombreux langages permettent de crée un type pouvant être représenté par plusieurs valeurs. L'exemple d'école :

    data Couleur = Rouge | Vert | Bleu | Marron | Noir | Blanc deriving (Show)

    Ici nous avons crée le type Couleur et nous lui avons associé 6 constructeurs différents. Observez bien le | entre les constructeurs, il représente l'alternative.

    L'usage du nom "constructeur" ici est souvent troublante pour qui n'est pas habitué, dites vous simplement que Rouge est une fonction qui ne prend pas d'argument et renvoie une valeur de type Couleur, en ce sens, c'est un constructeur de Couleur.

    On peut utiliser ces constructeurs pour créer des objets de type Couleur:

    Prelude> Rouge
    Rouge
    Prelude> Bleu
    Bleu

    On peut aussi réaliser différentes opérations dessus grâce à de la déconstruction comme vu précédemment. Dans la fonction réaction qui suit, je liste les différents cas de couleur, le _ servant de joker. En Haskell, on peut définir des fonctions en listant les cas :

    réaction Rouge = "Cool"
    réaction Bleu = "Cool aussi, mais je préfère le rouge"
    réaction Vert = "Bof Bof"
    réaction Noir = "Moche"
    -- cas générique
    réaction _ = "Je n'aime pas les autres couleurs"

    Et l'usage dans l'interpréteur nous donne :

    Prelude> réaction Rouge
    "Cool"
    Prelude> réaction Blanc
    "Je n'aime pas les autres couleurs"

    Nous avons vu comment réaliser en Haskell l'équivalent des "enum" que l'on peut trouver dans d'autres langages.

    ADT : enum avancés, ou union

    Le C et le C++ proposent un mécanisme d'union, où un type peut contenir au choix plusieurs sous-types. Par exemple :

    union Forme
    {
         struct {
              float cote;
         } carre;
    
         struct {
              float coteA;
              float coteB;
         } rectangle;
    };

    Je ne reviendrai pas sur son usage en C, sachez seulement que le type Forme peut contenir soit un float cote, soit deux float coteA et coteB. L'usage des deux simultanément est indéfini et on ajoute souvent à la structure de donnée un marqueur pour informer l'utilisateur du type de la donnée réellement stockée.

    En haskell, ce type peut être facilement représenté par un ADT combinant struct (ou type "produit") et enum (ou type "somme") :

    data Forme = Carré Float | Rectangle Float Float deriving (Show)

    Ici nous avons un type Forme qui contient deux constructeurs :
    - Carré, qui associe un Float à une Forme
    - Rectangle, qui associe deux Float à une Forme.

    Contrairement aux langages qui supportent les enum où les unions, on remarque notamment que n'importe quel type complexe peut apparaître dans les différents cas de l'énumération.

    Les outils décrit précédemment, de construction et de déconstruction par analyse de cas fonctionnent également. Ainsi on peut crée des Forme :

    Prelude> Carré 10
    Carré 10.0
    Prelude> Rectangle 20 30
    Rectangle 20.0 30.0

    Et on peut faire des fonctions qui vont traiter notre type par analyse de cas :

    surface (Carré c) = c * c
    surface (Rectangle a b) = a * b
    

    Ici la fonction surface déconstruit un Carré et renvoie sa surface. Si la déconstruction n'est pas possible (car c'est un Rectangle), alors la fonction passe au cas suivant). À l'usage :

    Prelude> surface (Carré 10)
    100.0
    Prelude> surface (Rectangle 5 3)
    15.0

    Plusieurs remarques :

    • Le compilateur nous protège et ce de plusieurs manières :

      • Si j'avais oublié de gérer les cas Rectangle, le compilateur m'aurait prévenu.
      • Contrairement aux unions en C/C++, on ne peut pas confondre un Rectangle et un Carre, c'est de nombreuses heures de recherche d'erreurs qui disparaissent soudainement.
    • La syntaxe et l'usage sont succincts, c'est agréable à mon goût. La même chose est possible dans de nombreux langages, par exemple en C++, grâce à l'utilisation de "variant" mais l'usage est lourd. Comparez le programme entier en Haskell à la version C++ :

    data Forme = Carré Float | Rectangle Float Float
    
    surface (Carré c) = c * c
    surface (Rectangle a b) = a * b
    
    main = do
       let carré = Carré 10
           rectangle = Rectangle 5 3
    
       print (surface carré)
       print (surface rectangle)

    La version C++ équivalente suivante utilise boost::variant, en c++17 nous utiliserons std::variant :

    #include <iostream>
    #include <boost/variant.hpp>
    
    struct Carre
    {
        float c;
    };
    
    struct Rectangle
    {
        float a;
        float b;
    };
    
    using Forme = boost::variant<Carre, Rectangle>;
    
    class surface
    {
    public:
        float operator()(const Carre &carre) const
        {
            return carre.c * carre.c;
        }
    
        float operator()(const Rectangle &rectangle) const
        {
            return rectangle.a * rectangle.b;
        }
    };
    
    int main()
    {
        Forme carre = Carre{10};
    
        Forme rectangle = Rectangle{5, 3};
    
        // affiche 100
        std::cout << boost::apply_visitor(surface(), carre) << std::endl;
        // affiche 15
        std::cout << boost::apply_visitor(surface(), rectangle) << std::endl;
    }

    Ce code passe par la définition du type en trois étapes : définition des sous types Carre et Rectangle et définition du type Forme comme un variant, un choix, entre les deux précédents types.

    La classe surface est ici un visiteur qui propose une surcharge de l'opérateur float operator(const T &t) pour chaque sous type T que peut contenir notre variant.

    La fonction boost::apply_visitor est chargée d'appeler la bonne surcharge de l’opérateur operator() de surface en fonction du contenu du variant passé en second paramètre.

    ADT : exemple plus poussé

    Alors pourquoi je vous raconte tout cela. En premier lieu, j'aime bien. En second lieu, je me dis que cela peut vous intéresser à Haskell ou au moins vous sensibiliser à l'existence de ce type d'outil et peut-être que vous les utiliserez dans vos projets futurs. Par exemple, dans mon travail quotidien, je fais du C++, mais Haskell m'a beaucoup influencé et j'utilise tous les jours des boost::variant. Mon opinion là-dessus c'est que même si la syntaxe en C++ est verbeuse à souhait, cela sauve de certaines situations. Au final je pense que le code est plus robuste.

    Pour finir, je vais vous donner un exemple d'un problème que je rencontre souvent dans des API et qui serait, à mon sens, mieux traité avec des ADT. C'est le cas traditionnel des valeurs sentinelles. Je fais un peu concurrence au journal de cette semaine sur la prévention de bug en Ocaml grâce à un typage plus strict. Là où ce journal s'intéressait à la définition d'un type synonyme mais incompatible, je m'intéresse à la définition d'un type totalement diffèrent permettant de représenter un contexte différent et ainsi de supprimer les cas impossibles et de rendre plus robustes les cas possibles.

    Introduction

    Pour appuyer mon propos, intéressons-nous à une libraire C++ que j'utilise tous les jours, OpenEXR, qui permet, entre autre, de lire et d'écrire des images au format EXR très utilisé dans l'industrie de l'image. La page github d'OpenEXR.

    Cette librairie propose entre autre la lecture et l'écriture de fichiers via plusieurs threads, ce qui est une fonctionnalité très pratique quand l'écriture de plusieurs Go d'images en séquentiel est le facteur limitant sur des machines à 24 coeurs.

    Le point de l'API qui nous intéresse est le suivant, les fonctions setGlobalThreadCount et globalThreadCount :

    void    setGlobalThreadCount (int count);
    int globalThreadCount();

    Alors, si on lit la documentation, on peut voir que count dans setGlobalThreadCount sert à définir le nombre de thread utilisés globalement pour réaliser les écritures.

    En cherchant un peu, on tombe sur ce commentaire :

    • The functions in this file query and control the total number of worker threads, which will be created globally for the whole library. Regardless of how many input or output files are opened simultaneously, the library will use at most this number of worker threads to perform all work. The default number of global worker threads is zero (i.e. single-threaded operation; everything happens in the thread that calls the library).

    Traduction à l'arrache :

    La fonction setGlobalThreadCount controle le nombre total de threads […] la bibliothèque utilisera au maximum ce nombre de threads. Le nombre par défaut est zéro, ce qui signifie que les opérations ne seront pas parallélisées.

    On tombe aussi sur des discussion github intéressantes, dont je ne trouve plus le lien, désolé, traitant du moyen de fournir à setGlobalThreadCount une valeur qui correspond au nombre de thread système optimal (sans avoir à trouver celui-ci, on peut imaginer qu'il puisse changer à la volée en fonction de la charge de la machine, où dans un environnement virtualisé, en fonction des besoins), et les débats tournaient autour du fait de mettre -1 comme nombre de thread pour ce cas de figure. Ce n'est pas implémenté à ma connaissance dans openEXR, mais supposons que cela le soit.

    Donc en gros, voici le comportement que nous pouvons imaginer pour setGlobalThreadCount(n) :

    • Si n > 0, alors c'est le nombre de thread utilisé globalement
    • Si n = 0, alors il n'y aura pas de multi threading
    • Si n = -1, alors on utilise le nombre de thread machine
    • Si n = -12, autre cas particulier que nous pourrions imaginer.

    Le problème

    Premier problème, en tant qu'utilisateur, je n'avais pas conscience de l'existence des cas 0, -1 et -12 sans lire le code source et la documentation d'OpenEXR.

    Second problème, on va se planter, LARGEMENT, en beauté. Qui ? Les développeurs d'OpenEXR sans doute, et moi en utilisant leur API. Comment je le sais ? Parce que je me suis planté.

    Où pouvons-nous nous planter ? Partout où le nombre global de thread est utilisé. Si le cas particulier 0, -1 et -12 n'est pas géré explicitement, et bien c'est un bug. Cela peut faire des choses marrantes, comme par exemple créer 0 thread de travail, et répartir le travail entre eux, ce qui donne un blocage de l'application.

    Troisième problème, le futur. Même si c'est bien géré actuellement, que se passe-t-il demain lorsque quelqu'un va écrire une nouvelle fonction basée sur cette valeur sans connaître l'existence des cas particuliers qui existent ? Et bien cela va marcher, jusqu'à ce que quelqu'un utilise un cas particulier non traité, et là, pan. Ou si quelqu'un ajoute un nouveau cas particulier et ne le gère pas à tous les endroits nécessaires ?

    On peut aussi se planter en passant une mauvaise constante par erreur. Imaginons qu'il existe dans le même espace de nom, une constante nommée "NoThreading", mais utilisée par une autre librairie, et ayant pour valeur magique un entier. Si celui-ci est négatif, c'est le drame, le comportement du programme est largement indéfini, au mieux c'est une erreur à l'exécution, au pire ?. Si celui-ci est positif, il faut espérer qu'il ne soit pas trop gros, car je n'aimerais pas créer 100000 threads sur ma machine de production, l'OS ne tiendrait pas.

    Ce type de bug potentiel est la raison qui fait que la montée de version sur un gros projet logiciel est difficile du fait de la peur des régressions. Et même le meilleur système de test unitaire ne peut rien garantir à ce sujet.

    Je passe aussi sur le problème de documentation et de lecture de code avec l'utilisation de constantes magiques en paramètre de fonction. setGlobalThreadCount(-123) n'est pas très informatif. Alors oui, cela se règle avec des définitions de constante, mais on peut encore se tromper, en définissant la constante à une mauvaise valeur, et rien ne force le développeur à utiliser la constante magique.

    Ce problème est présent de partout, dans toutes les bibliothèques que nous utilisons, dans tous les langages que nous utilisons. Ceux-ci proposent des valeurs sentinelles. Python avec la méthode find des chaînes de caractères, qui renvoie -1 si la chaîne n'est pas trouvés (Il y a la version avec exception, c'est moins pire). C++ avec la fonction std::find qui retourne un itérateur vide en cas d'échec et rien qui ne vous force à tester cela.

    La solution

    La solution passe par la définition d'un type représentant le problème plus finement. Dans le cas d'OpenEXR, et si celui-ci était écrit en Haskell, nous pourrions avoir un type :

    -- Word est en entier non signé
    data PolitiqueThread = NombreFixé Word | NombreMaximumHardware | PasDeThreading | CasParticulier

    Ainsi on pourrait appeller la fonction setGlobalThreadCount de différentes façon :

    setGlobalThreadCount (NombreFixé 8)
    
    setGlobalThreadCount NombreMaximumHardware
    
    setGlobalThreadCount PasDeThreading
    
    setGlobalThreadCount CasParticulier

    Nous réglons en premier lieu le problème de documentation lors de l'appel. En tant qu'utilisateur, je suis forcé de voir que ce n'est pas juste un entier, et d'au moins voir la documentation avec la liste des cas, qui est automatiquement à jour. Le code est lisible et il est explicite que cette valeur n'est pas anodine.

    Nous réglons aussi le problème lors de l'usage. On ne peut plus utiliser les valeurs -1 et -12 et 0 par erreur en considérant qu'il s'agit d'un nombre de thread et non pas d'un cas particulier, car le langage nous force à déconstruire et à gérer les différents cas de déconstruction. Observez comment 0, -1 et -12 n'apparaissent pas :

    threadCount <- getGlobalThreadCount
    case threadCount of
       NombreFixé n -> "nombre fixé à " ++ show n
       NombreMaximumHardware -> "Fait chauffer la ferme de calcul"
       PasDeThreading -> "Plutôt tranquille"
       CasParticulier -> "Celui-ci je ne l'aime pas"

    Nous réglons aussi le problème de l'évolution future et de l'ajout de nouveau cas particulier, puisque le compilateur vas râler aux endroits où tous les cas ne sont pas gérés.

    Le problème de passer une valeur qui n'a pas de sens par défaut n'existe plus non plus. Le type PolitiqueThread est incompatible avec un autre type. La seul erreur possible reste de passer un nombre qui n'a pas de sens à NombreFixé. Soit un nombre négatif, soit un nombre trop grand qui ferait exploser le système.

    Je n'ai pas de solution parfaite à ce dernier problème. On peut en premier lieu cacher le constructeur NombreFixé et le remplacer par une fonction type :

    nombreFixé n
     | n > 0 && n < maximumThread = NombreFixé (fromIntegral n)
     | otherwise = erreurRuntime ("n est trop bizarre: " ++ show n)
    
    -- fromIntegral sert à convertir n qui est un entier signé vers un `Word`.

    Cette solution limite la casse. Il y en d'autres. On pourrait par exemple utiliser de l'analyse statique de code en imposant des contraintes sur nombreFixé. Liquid Haskell sait faire cela, mais dans un contexte limité.

    Conclusion

    En profitant de la sortie de GHC 8.0.2, j'ai essayé de vous sensibiliser un peu plus au problème des valeurs sentinelles. À mon sens, ce problème est grave car il en découle du code peu lisible, peu "naturellement" documenté, peu robuste à l'évolution et peu robuste à l'utilisation normale par un développeur qui ne connaît pas par cœur les détails de l'API qu'il utilise. Une solution est l'emploi d'ADT, ceux-ci sont disponibles dans de nombreux langages, comme Haskell, Caml, Rust, Scala, Swift, … Et peuvent plus ou moins facilement être remplacés par des structures équivalentes à la simplicité près, comme avec les variant en C++.

    Ce que je vous ai montré n'est qu'une partie de ce qui est possible avec les ADTs, et un lecteur motivé pourra commencer sa lecture sur la section de wikipedia consacrée aux ADT généralisés

    Lire les commentaires

  • [Tuto/HowTo] Sauvegarder la Base de données de phpBB sur ubuntu/debian/raspbian avec automysqlbackup (Journaux LinuxFR)

    Ce tuto est la suite de [Tuto/HowTo] Sauvegarder les fichiers joints de phpBB3 sur le cloud via rsync et webdav/dafvs2
    Le tuto d'origine se situe à l'adresse suivante : https://www.0rion.netlib.re/forum4/viewtopic.php?f=63&t=496#p1097

    Introduction

    • automysqlbackup est un script libre, disponible dans les paquets Ubuntu et Debian/Raspbian, qui permet d'automatiser la sauvegarde de base de données. Une fois le paquet installé, par défaut il copiera les bases de données en suivant les cron suivants : @daily ("0 0 * * *"), @monthly ("0 0 1 * *"), @weekly ("0 0 * * 0"). Et grâce à l'option LATEST=yes vous disposerez aussi d'un dossier intitulé latest dans lequel sera situé le dernier backup en date.

    Mise en place

    Créez le dossier pour accueillir les sauvegardes de la (ou les) Base(s) De Données sur votre montage webdav/davfs2 créez dans le tuto précédent

    sudo mkdir /media/montageDistant/phpBB_BDD/

    Installez le logiciel

    sudo apt-get update
    sudo apt-get install automysqlbackup nano
    

    Éditez le fichier de configuration
    sudo nano /etc/default/automysqlbackup

    Modifiez les valeurs suivantes (pour rechercher un élément tapez CTRL+W) :

    • BACKUPDIR="/var/lib/automysqlbackup" => remplacez /var/lib/automysqlbackup par le dossier où vous souhaitez ranger les backup de votre base de données (dans ce tuto /media/montageDistant/phpBB_BDD/)
    • LATEST=no => passez la valeur no à yes
    • SEPDIR=yes => Si vous souhaitez un dossier par base de données laissez yes, si vous préférez grouper les BDD dans un seul fichier pour chaque backup, entrez _no
    • PREBACKUP="/etc/mysql-backup-pre" => vous pouvez décommentez la commande (supprimer le #) et remplacez "/etc/mysql-backup-pre" par "/usr/sbin/service apache2 stop"
    • POSTBACKUP="/etc/mysql-backup-post" => vous pouvez décommentez la commande (supprimer le #) et remplacez "/etc/mysql-backup-pre" par "/usr/sbin/service apache2 start"
    • DBEXCLUDE="" => si vous souhaitez ne pas inclure des base de données, indiquez leur petit nom.

    PS: lors du précédent tuto nous avons défini la sauvegarde des fichiers joints à minuit et trois minutes, les Base de données seront quant à elle sauvegardée chaque jours à minuit et une minute. Si deux minutes de décalage semble une éternité pour l'ubber geek que vous êtes alors en suivant le précédent tuto remplacez le cron "3 0 * * *" par @daily ;)

    Lire les commentaires

  • Sortie de matplotlib 2.0 (Journaux LinuxFR)

    Bonjour à toutes les moules scientifiques (et les autres !),
    la bibliothèque python Matplotlib vient de sortir en version 2.

    Pour info, matplotlib est la bibliothèque de référence pour le tracé de données avec python. Elle permet de tracer des graphs de grande qualité que ce soit en 2D ou 3D (cf la galerie du site). Pour les aficionados des logiciels privateurs à plusieurs milliers d'euros (commençant par mat et terminant par lab), il est possible d'utiliser le namespace pyplot qui fournit alors une syntaxe très proche de celle utilisée par le-dit logiciel commercial.

    La grande nouveauté de cette version est le changement global des styles de graphs qui sont maintenant plus "actuels" par défaut (même s'il était déjà possible d'obtenir des choses assez proches avec les bibliothèques de styles introduites précédemment (voir par exemple ici).

    La liste complète des nouveautés est disponible ici, tandis que les nouveautés concernant le style par défaut sont accessibles ici.

    Notons en particulier la colormap appelée Viridis qui remplace cette horreur qu'est jet (cf les innombrables publications à ce sujet). Pour la petite histoire, après avoir fait énormément pour la popularité de la colormap jet, matlab s'est décidé il y a quelques versions à proposer une meilleur table de couleurs nommée parula. Dans sa grande mansuétude, mathworks a publié cette dernière sous licence propriétaire. C'est ainsi qu'est née viridis (et aussi parce que l'on n'est pas obligé de toujours suivre ce que fait mathworks). Vous pouvez regarder à ce propos la passionnante présentation de Nathaniel Smith lors de la conférence Sicpy2015.

    En résumé, matplotlib, maintenant c'est beau (par défaut) !

    Lire les commentaires

  • [Tuto/HowTo] Concevoir une camera de surveillance avec un Raspberry Pi (Journaux LinuxFR)

    Sommaire

    Tuto testé sur un Raspberry Pi type 1A avec Raspbian Jessie (la version (25/07/2016) sans pixel) et un serveur Zoneminder
    Tuto d'origine : [Tuto/HowTo] Concevoir une camera de surveillance avec un Raspberry Pi

    Introduction

    Principe de base

    • Créer une camera de surveillance sécurisée compatible avec ZoneMinder. Cette camera sera plus sécurisée que les caméras grand public que l'on trouve dans le commerce.

    Côté Hardware

    • Nous allons créer une caméra Hardware avec un Raspberry Pi (conseillé type 2 voir plus), un vieux spot halogène de travail (protection métal), une webcam et du câble RJ45 Cat5 ou 6, un morceau de carton (recup), une alimentation pour raspberry pi (même que chargeur smartphone (min 1A, conseillé 2A)). Pour pouvoir voir la nuit en utilisant des Leds infrarouge, vous devez ouvrir la webcam (sans la casser) et enlever la lentille rectangulaire qui se situe devant la camera. Par contre la camera sera plus éblouie durant la journée (vous pouvez utiliser deux webcams, une avec la lentille infrarouge (jour) et une sans (nuit)).

    Côté Software

    • Sur une Raspbian seront installé motion, openssh-server, autossh, Tor. Avec ces logiciels nous allons établir une liaison SSH permanente depuis le serveur ZoneMinder vers la camera de surveillance. Ainsi les communications seront protégées par le tunnel de données SSH dont la cible sera Motion. Motion quant à lui sera chargé de "lire" la webcam et de générer un flux de données lisible par ZoneMinder.

    Software

    Installation et configuration des logiciels de la caméra

    Note : je pars du principe que tu viens d'installer Raspbian et n'a encore rien fait dessus.

    Système

    • Mettre à jour le système et supprimer les trucs inutiles
    sudo su
    apt-get purge libreoffice* wolfram-engine sonic-pi minecraft-pi greenfoot pcmanfm realvnc-vnc-server supercollider-ide
    apt-get update
    apt-get upgrade
    apt-get autoremove
    apt-get autoclean
    rpi-update
    
    • Installer les pré-requis
    apt-get install motion tor screen autossh
    
    • Redémarrer la machine
    reboot
    

    Liaison SSH

    • Créer un utilisateur dédié à recevoir le tunnel de données
    sudo adduser video_surveillance
    
    • Ajouter l'utilisateur au groupe videos
    usermod -a -G video video_surveillance
    
    • Éditer /etc/ssh/sshd/config
    sudo nano /etc/ssh/sshd_config
    
    • Ajouter les lignes suivantes en adaptant à vos besoins
    Match user video_surveillance
            PermitOpen 127.0.0.1:*
    
    • PermitOpen 127.0.0.1:* Hostname:Port, ici nous restreignons les tunnels de l'utilisateur à la boucle locale; le caractère * signifie "tous". Une fois sûr de votre config vous pouvez remplacer par le ou les ports pour joindre vos caméras

      • Redémarrer le serveur SSH
    sudo service ssh restart
    

    Motion

    • Créer le répertoire de travail, ici j'ai choisi /opt/script/motion/
    sudo mkdir -p /opt/script/motion/
    
    • Créer le fichier de configuration
    sudo nano /opt/script/motion/motion.conf
    
    • Coller la configuration suivante en l'adaptant éventuellement
    videodevice /dev/video0
    input -1
    start_motion_daemon=no
    webcam_localhost off
    quiet on
    post_capture 0
    output_all off
    control_localhost off
    output_normal off
    width 640
    height 480
    webcam_maxrate 25
    ffmpeg_video_codec msmpeg4
    stream_localhost off
    stream_port 6881
    
    • Si vous ne l'utilisez que via le tunnel SSH remplacez webcam_localhost off par webcam_localhost on afin d'empêcher d'autres d'accéder à la caméra

      • Créer le script de démarrage
    sudo nano /opt/script/motion/startMotion.sh
    
    • Ajouter dedans les lignes suivantes en les adaptant éventuellement
    #!/bin/bash
    sleep 5
    su video_surveillance -c "/usr/bin/screen -d -m -S motion motion -c /opt/script/motion/motion.conf"
    
    • Créer le script d’arrêt
    sudo nano /opt/script/motion/stopMotion.sh
    
    • Ajouter dedans les lignes suivantes en les adaptant éventuellement
    #!/bin/bash
    su video_surveillance -c "/usr/bin/screen -S motion -X quit"
    
    • Accorder les bonnes permissions sur le script de lancement
    sudo chown root:root -R /opt/script/motion
    sudo chmod 755 -R /opt/script/motion
    
    • Ajouter le script au démarrage du système en éditant /etc/rc.local
    sudo nano /etc/rc.local
    
    • Ajouter la ligne suivante juste avant exit 0
    sudo /opt/script/motion/startMotion.sh
    

    Tor

    Note : Tor n'est normalement pas nécéssaire si votre caméra ne change pas de réseau. Néanmoins dans l'utilisation que nous allons en faire en cas de vol de la caméra vous pourrez récupérer quand même le flux vidéo. Si votre réseau passe d'IPv4 à IPv6 cette méthode devrait aussi permettre la communication entre Zoneminder et votre caméra en attendant que vous reconfiguriez votre réseau.

    sudo su
    mkdir -p /var/lib/tor/hidden_service
    mkdir -p /var/lib/tor/hidden_service/ssh
    echo "HiddenServiceDir /var/lib/tor/hidden_service/ssh" >> /etc/tor/torrc
    echo "HiddenServicePort 22 127.0.0.1:22" >> /etc/tor/torrc
    chown debian-tor:root -R /var/lib/tor/hidden_service/
    chmod 700 -R /var/lib/tor/hidden_service/
    service tor restart
    cat /var/lib/tor/hidden_service/ssh/hostname
    • Note : Pensez à noter l'adresse en .onion que la dernière commande va vous fournir, vous en aurez besoin pour la suite. Si par la suite vous souhaitez la ré-afficher, entrez cette commande sur votre caméra
    sudo cat /var/lib/tor/hidden_service/ssh/hostname
    

    Mise en place sur le serveur ZoneMinder

    Liaison SSH

    • Exporter la clé SSH
    sudo su
    ssh-copy-id -i ~/.ssh/id_rsa.pub video_surveillance@adresseCamera
    
    • Note : si vous n'avez jamais créé de clés pour votre utilisateur root (admin) alors envoyez les commandes suivantes
    sudo su
    ssh-keygen -t rsa -b 4096 -o -a 666
    
    • Pour vérifier l’existence de la clé RSA de root entrerz la commande suivante
    sudo cat /root/.ssh/id_rsa.pub
    
    • Vérifier que la connexion sans mot de passe fonctionne
    ssh video_surveillance@adresseCamera
    
    • Rendre compatible le client ssh avec le réseau Tor
    sudo nano /etc/ssh/ssh_config
    
    • Et ajouter ces lignes
                Host *.onion
                ProxyCommand nc -xlocalhost:9050 -X5 %h %p
    
    • Créer le script de démarrage qui va créer la liaison peu après le boot
    sudo nano /opt/scripts/creatTunnelForvideo_surveillance.sh
    
    • Ajouter le script suivant en adaptant ses variables
    #!/bin/bash
    #  -> WTFPL - infos script : https://www.0rion.netlib.re/forum4/viewtopic.php?f=34&t=498
    # -> code by voxdemonix <-
    
       #pour tester que la création de tunnel fonctionne vous pouvez adapter la ligne suivante puis la lancer dans votre shell
    #su myUser -c 'autossh -M 0 -q -N -o "ServerAliveInterval 60" -o "ServerAliveCountMax 3" -L 6881:127.0.0.1:6881 video_surveillance@HOSTNAME'
    
    
    ipCameraLan="192.168.1.42" # l'adresse IP locale de votre camera
    adresseCameraTor="monTorHiddenService.onion" # l'adresse en .onion de ta camera que je t'ai dis de noter quelques paragraphes plus haut
    adresseMacCamera="00:00:00:00:00:00" #l'adresse mac de votre camera (tapez ifconfig dans un terminal sur votre server pour la voir)
    UserLocalForSshTunneling="root" # l'user a utiliser sur votre ordinateur pour le montage du tunnel (dans ce tuto on utilise root afin d'empêcher un virus ayant piraté l'user principale d’exécuter des commandes sur la camera)
    UserRemoteForSshTunneling="video_surveillance" # l'user a utiliser côté server/caméra ( /!\ n'utilisez jamais root ni pi !)
    portEntree="6881" # le port sur le serveur ZoneMinder ; un port par caméra
    portSortie="6881" # le port sur le serveur/camera
    
    if [ ! "$SUDO_USER" ]; then
    exit 0
    fi
    sleep 60 # petit délais d'attente afin que le réseau soit prêt et la machine démarrée
    
    ping $ipCameraLan -c 1 >> /dev/null 2>&1
    macRecover=$(arp -n | grep -i -o $adresseMacCamera)
    
    if [ "$macRecover" == "$adresseMacCamera" ]; then
       su $UserLocalForSshTunneling -c "autossh -M 0 -q -N -o 'ServerAliveInterval 60' -o 'ServerAliveCountMax 3' -L $portEntree:127.0.0.1:$portSortie $UserRemoteForSshTunneling@$ipCameraLan -f"
    else
       su $UserLocalForSshTunneling -c "autossh -M 0 -q -N -o 'ServerAliveInterval 60' -o 'ServerAliveCountMax 3' -L $portEntree:127.0.0.1:$portSortie $UserRemoteForSshTunneling@$adresseCameraTor -f"
    fi

    ipCameraLan="192.168.1.42" => l'adresse IP locale de votre camera
    adresseCameraTor="monTorHiddenService.onion" => l'hostname WAN ou l'adresse Tor Hidden Service au choix
    adresseMacCamera="00:00:00:00:00:00" => l'adresse mac de votre camera (tapez ifconfig dans un terminal sur votre server pour la voir)
    UserLocalForSshTunneling="root" => l'user a utiliser sur votre ordinateur pour le montage du tunnel (dans ce tuto on utilise root afin d'empêcher un virus ayant piraté l'user principale d’exécuter des commandes sur la camera)
    UserRemoteForSshTunneling="myUserServer" => l'user a utiliser côté server ( /!\ n'utilisez jamais root ou pi !)
    portEntree="6881" => le port sur ZoneMinder
    portSortie="6881" => le port de motion (voir paramètre stream_port de motion.conf) sur la caméra

    • Accorder les bons droits sur le script
    sudo chown root:root /opt/scripts/creatTunnelForvideo_surveillance.sh
    sudo chmod 755 /opt/scripts/creatTunnelForvideo_surveillance.sh
    
    • Éditer /etc/rc.local
    sudo nano /etc/rc.local
    
    • Ajouter la ligne suivante juste avant exit 0
    sudo /opt/scripts/creatTunnelForvideo_surveillance.sh
    

    Ajouter la webcam à ZoneMinder

    • Rendez-vous sur la WEBUI de ZoneMinder avec un utilisateur pouvant ajouter une cam

    • Cliquer sur "Ajouter une caméra"

      • Onglet General Type de source : Distant (remote)
      • Onglet Source Protocole : HTTP Méthode : Simple Nom d'hôte : 127.0.0.1 Port : 6881 Largeur (nb pixels) : 640 Hauteur (nb pixels) : 480

    screenshot-2016_01_07-ZoneMinder-addCamera_General-motionSoftware.png
    screenshot-2016_01_07-ZoneMinder-addCamera_Source-motionSoftware.png

    Hardware

    • Récupérez un vieux spot halogène de chantier en métal (les anciens sont plus robustes avec plus de place à l'intérieur)

    • Percez un trou un l'arrière afin de faire passer le câble (le RJ45 + le câble d'alim du RaspberryPi prennent un peu plus de place que le câble d'alimentation d'origine)

    • Soit vous passez vos câbles puis colmatez l'espace avec du silicone (pas très propre), soit, comme dans les photos suivantes, procurez-vous une boite de dérivation et forez deux trous pour la fixer avec des vis. Veillez à ce qe l'eau ne puisse s'infiltrer.

    • Fixez la webcam avec de la toile isolante (papier américain). Pour la stabiliser (le spot n'étant pas cubique) utilisez du carton que vous pliez pour lui donner un effet ressort.

    • Insérez votre Raspberry Pi et branchez le

    • Découpez un morceau de carton (ici récupéré sur un pack de 6 bières) afin de couvrir la vitre du spot, le but étant de protéger l'intérieur du soleil tout en laissant un espace de visibilité pour la webcam

    • Refermez le tout et colmatez avec du silicone les éventuels trou de forage

    • Enjoy!

    tuto_image_01.jpg
    tuto_image_02.jpg
    tuto_image_03.jpg
    tuto_image_04.jpg
    tuto_image_05.jpg

    Lire les commentaires

  • LinuxFr.org : première quinzaine de janvier 2017 (Journaux LinuxFR)

    Deux puissance sixième épisode dans la communication entre les différents intervenants autour du site LinuxFr.org : l’idée est tenir tout le monde au courant de ce qui est fait par les rédacteurs, les admins, les modérateurs, les codeurs, les membres de l’association, etc.

    L’actu résumée ([*] signifie une modification du sujet du courriel) :

    Statistiques

    • 1 931 commentaires publiés (dont un masqué depuis) ;
    • 275 tags posés ;
    • 89 comptes ouverts (dont 1 fermé depuis) ;
    • 55 entrées de forums publiées (dont une masquée depuis) ;
    • 18 dépêches publiées ;
    • 32 journaux publiés (dont 0 masqué depuis) ;
    • 1 entrée dans le système de suivi (dont 0 fermée depuis) ;
    • 1 sondage publié ;
    • 0 page wiki publiée.

    Listes de diffusion (hors pourriel)

    Liste linuxfr-membres@ — [restreint]

    • R. A. S.

    Liste meta@ — [restreint]

    • [Meta] Seconde quinzaine de décembre 2016

    Liste moderateurs@ — [restreint]

    • [Modérateurs] copie courriel à X, auteur de dépêche [*]

    Liste prizes@ — [restreint]

    • [Prizes] LinuxFr prizes récap du dimanche 8 janvier 2017, 09:12:38 (UTC+0100)

    Liste redacteurs@ — [public]

    • R.A.S.

    Liste team@ — [restreint]

    • [team linuxfr] Migration utf8 → utf8mb4 ;
    • [team linuxfr] Réouverture de mon ancien compte.

    Liste webmaster@ — [restreint]

    • R. A. S.

    Canal IRC adminsys (résumé)

    • travaux autour de la migration MySQL en utf8mb4 sur le serveur de développement ;
    • les traditionnelles mises à jour de sécurité.

    Tribune de rédaction (résumé)

    Tribune de modération (résumé)

    • retard sur la génération d’une dépêche Agenda du Libre ;
    • signalement d’un fil de discussion potentiellement problématique.

    Commits/pushs de code https://github.com/linuxfrorg/

    • Various updates and fixes for stats (#1062) ;
    • Fix the migration to utf8mb4.

    Divers

    • un disque dur H.S. à remplacer sur un des serveurs ;
    • la traditionnelle dépêche sur les statistiques 2016 est toujours en préparation ;
    • l’idée d’une dépêche rétrospective 2016 semble abandonnée ;
    • une nouvelle soirée de contribution LinuxFr.org est prévue dans le cadre de la Soirée de contribution au Libre du 19 janvier à Paris.

    Lire les commentaires

  • Album Autocollants du Libre : appel aux associations (Dépêches LinuxFR)

    Suite au renouveau des ateliers de contribution à l’Album Autocollant du Libre, l’association LILA lance un nouvel appel aux associations pour leur participation au projet, ainsi que l’envoi de leurs autocollants.

    Envoyez vos autocollants

    La seconde partie de cette dépêche donnera les détails, résumera le compte‐rendu de notre précédent atelier (six personnes présentes) et la direction actuelle du projet.

    Sommaire

    Appel aux associations : envoyez‐nous vos fichiers d’autocollants

    Presque deux ans plus tôt, lorsque l’association LDN avait lancé l’idée du projet, quelques dizaines d’autocollants furent collectés. Cela ne représente pas forcément bien l’état associatif et libriste français actuel, donc nous lançons un nouvel appel :

    Associations libristes, envoyez‐nous vos autocollants et leurs mesures métriques !

    Notez qu’il fut décidé que plutôt qu’être exhaustif, nous partons dans une optique bien plus « pédagogique », donc tous les autocollants ne seront pas forcément utilisés (notamment certains autocollants sont quasiment identiques avec des nuances ou juste de taille différente, etc.). Nous vous demandons donc aussi de nous indiquer vos autocollants préférés (ceux que vous préférez voir inclus et qui illustrent au mieux votre activité).

    Des textes explicatifs de l’activité sont aussi les bienvenus, pas forcément pour inclusion (nous nous réservons le droit d’adapter), mais au moins pour nous donner une idée de ce que vous faites et/ou de l’histoire derrière certains autocollants en particulier.

    Et surtout, nous avons besoin d’un document signé nous donnant l’autorisation d’utiliser (modification, distribution et vente) vos textes, autocollants et logo dans le contexte de ce projet d’album. Puisque très souvent, les associations libristes ne mettent pas de licence sur leurs productions imprimées (et n’autorisent pas l’utilisation de leur logo), nous avons besoin de votre autorisation pour faire les choses dans les règles.

    Bien sûr, si vous souhaitez accompagner cette autorisation d’un droit de regard avant impression, ce n’est absolument pas un problème (et même prévu). Le but est d’aider et de promouvoir l’activité associative du Libre, pas l’inverse. D’ailleurs, si vous souhaitez être sûr que votre association soit parfaitement représentée, nous vous invitons à participer aux ateliers de création pour en orienter les décisions ! :-)

    Envoyez donc vos autocollants et autorisations à contact chez libreart.info avec un titre explicite.

    Un album avec une histoire à raconter

    Notre précédent atelier a recentré l’album de manière plus originale : ce n’est plus seulement un album d’autocollants et c’est probablement le changement le plus excitant (lire le compte‐rendu plus détaillé). L’idée en cours serait d’avoir un petit personnage qui traverserait les pages de l’album et raconterait un peu l’histoire ou les concepts du logiciel libre, illustré par l’activisme des diverses associations libristes francophones. Ce personnage récurrent pourrait, par exemple, être le GNU de notre série Wilber & Co., mais nous accueillons avec joie les propositions alternatives. Nous préférerions même davantage d’investissement externe ; et même, pourquoi pas, une histoire en cadavre exquis dessinée par de nombreux artistes ?! Artistes, manifestez‐vous ! :-)

    Nous pourrions ainsi parler du projet « Dégooglisons Internet » de Framasoft, son pourquoi et son comment. Les combats sur les brevets logiciels et les DRM de l’April seront aussi efficacement illustrés par leur collection d’autocollants thématiques. LILA pourrait présenter son projet de film libre, son travail pour faire découvrir l’art libre et les logiciels libres de création ; et avec une mise en abîme de l’Album d’Autocollants du Libre. La Quadrature du Net ne manque pas non plus d’autocollants pour illustrer son travail sur la vie privée, la neutralité et contre la censure du Net. Et ainsi de suite…
    Petite et grande associations, manifestez‐vous !

    Cela en fera alors un objet de découverte et — typiquement dans un évènement tel que les RMLL — aidera les visiteurs à mieux appréhender le Libre. Cela pourrait même être utilisé comme un jeu de piste, avec les gens essayant de faire tous les stands pour récupérer les autocollants manquants et, ainsi, faire une bonne introduction à l’activité de chaque association. Cela sera d’ailleurs une activité très amusante pour les enfants également !

    Prochain atelier : jeudi 19 janvier à Paris

    Nous nous réunissons au même endroit que précédemment, encore une fois dans le contexte de la Soirée de contribution au Libre parisienne, à partir de 19 h, jeudi 19 janvier 2017.

    Dans cet atelier, nous approfondirons probablement le concept du petit personnage qui se balade à travers les pages et de ce qu’on veut raconter ; nous commencerons peut‐être des essais de mise en page pour avoir une idée plus concrète, ou autre chose ! Car, dans tous les cas, ce sera vous, les participants au projet, qui dirigerez vraiment sa direction.

    Venez nombreux !

    Coordonnées

    FPH Fondation Charles‐Léopold Mayer pour le Progrès de l’Homme
    38, rue Saint‐Sabin, 75011 Paris.

    • digicode : contactez‐nous ;
    • tél. : +33 1 43 14 75 75 ;
    • métros : Mo 5 station Bréguet Sabin, ou Mo 8 station Chemin Vert ou Bastille ;
    • bus : ligne 20 ou 65, arrêt Chemin Vert ;
    • station Vélib’ : 11033, au 23 bd Richard Lenoir ;
    • site Web de FPH : www.fph.ch.

    Note : nous organiserons régulièrement des ateliers sur ce projet, mais ne ferons pas d’article à chaque fois (seulement pour des raisons particulières, comme ici, l’appel aux associations). Nous conseillons de vous tenir au courant en souscrivant à la liste de discussion : envoyez un courriel avec le titre « subscribe » sur libre-sticker-album-request@lists.tuxfamily.org.

    Lire les commentaires

  • Tails : Nous avons besoin de vos dons ! (Dépêches LinuxFR)

    Tails (The Amnesic Incognito Live System) est une distribution GNU/Linux autonome (live CD ou live USB) visant à protéger votre anonymat et votre vie privée quand vous vous connectez à Internet. Il y a quelque semaines a été démarrée une campagne de dons pour financer le travail en 2017.

    Sur la page du projet Tails Pourquoi nous avons besoin de dons : « Tails est distribué librement et gratuitement. Nous ne vendons pas vos données, nous ne vous envoyons pas des publicités ciblées et nous ne vendrons jamais notre projet à une grande entreprise. Nous distribuons Tails gratuitement simplement parce que tout le monde mérite d’être protégé contre la surveillance et la censure. Mais également parce qu’être un logiciel libre est une condition nécessaire pour que nos outils soient sûrs et vous protègent comme prévu. Si notre code source était fermé, il n’y aurait aucun moyen de vérifier que notre logiciel est digne de confiance. »

    Visuel Tails

    Toujours sur la même page Pourquoi nous avons besoin de dons, le projet indique récolter en moyenne 210 000 € depuis 2014 (34 % du gouvernement américain, 34 % de fondations et d’ONG, 17 % d’individus et 15 % de sociétés). Il évoque d’ailleurs la question de la part du financement provenant du gouvernement des États‐Unis et indique « que Tails est utilisé par environ 18 000 personnes chaque jour. Si chacune donnait 12 €, le prix d’une clef USB, notre budget pour l’année entière serait récolté en un jour. »

    Si vous voulez que Tails reste indépendant, merci de prendre une minute pour faire un don.

    Lire les commentaires

  • Une petite histoire d'utilisation type fort dans Ocaml (Journaux LinuxFR)

    Sommaire

    Obtenir du code correct par l'utilisation de types

    Je vais illustrer cette idée avec un cas trivial mais pragmatique. Pour se mettre à un langage, rien ne vaut un petit projet perso, avant de passer aux choses sérieuses en regardant le code écrit par d'autres. Dans mon cas, il s'agit de l'écriture d'un utilitaire pour afficher des schémas Kicad et les différences entre deux versions (rien de gros ni professionnel comme GNU, comme dirait l'autre). Par avance, mes excuses aux grands maîtres d'Ocaml si j'écorche le langage ou ses concepts.

    Les coordonnées sont représentées par des couples int*int, mais dans l'optique d'utiliser le typage, il était plus intéressant de différencier le type coordonnées d'une simple paire. En effet, rien n'est plus ressemblant à une paire d'entiers qu'une autre paire d'entiers. En Ocaml, par exemple, on peut définir des types qui sont synonymes du type « paire d'entiers » :

    # type anon_coord = int*int;;
    type anon_coord = int*int
    # type anon_coord2= int*int;;
    type anon_coord2= int*int

    Mais alors les deux types sont synonymes aussi :

    #let x:anon_coord = 5,7;;
    val x : anon_coord = (5, 7)
    # let y:anon_coord2 = x;;
    val y : anon_coord2 = (5, 7)

    J'ai donc opté dès le départ pour un type annoté, qui serait particularisé :

    # type coord = Coord of (int*int);;
    type coord = Coord of (int * int)
    # let z = Coord (6,8);;
    val z : coord = Coord (6, 8)
    # let Coord (x,y) = z;;
    val x : int = 6
    val y : int = 8

    Le type a alors un constructeur unique et l'annotation empêche de passer une simple paire là où on attend le type annoté. La déconstruction par pattern matching permet simplement d'accéder aux coordonnées individuelles.

    L'affichage de schéma consiste à afficher les symboles des composants électroniques à certains emplacements ainsi que de primitives (lignes, textes). Ces composants sont décrits dans des fichiers bibliothèque et il est nécessaire de les translater et les tourner correctement dans le contexte du schéma. En fait, chaque symbole est décrit par un ensemble de primitives graphiques similaires à celle du schéma et qui doivent subir la même transformation pour obtenir la transformation du symbole.

    Or, lors du codage de cette fonctionnalité, il est apparu assez rapidement que j'avais introduit des bugs qui faisaient que les primitives des composants étaient affichées sans subir de transformation, ce qui les collait toutes dans le coin supérieur gauche du schéma (un comportement de bug bien connu dès qu'on joue un peu à dessiner). J'aurais pu à ce moment dégainer le débugger ou ajouter quelques lignes de traces pour voir ce qu'il en était, mais le projet étant didactique, j'ai préféré recourir à une solution à base de typage.

    J'avais utilisé le même type coord dans le traitement du schéma et des bibliothèques, mais il parait plus judicieux de différencier ces types, car même si les bibliothèques de composant utilisent le même format de description que celles des fichiers de schéma, elles décrivent des coordonnées qui seront forcément relatives au point d'ancrage du composant dans le schéma. Il fallait donc créer un type annoté différent pour les coordonnées des primitives de bibliothèque, un type qui ne serait pas connu du canevas et qui permettrait de détecter un passage des primitives au canevas sans transformation.

    # type relcoord = RelCoord of (int*int);;
    type relcoord = RelCoord of (int*int)

    Une fois le type injecté dans les types de primitives, merlin, l'outil de vérification à la volée indique dans l'éditeur tous les points qui nécessitent correction, indépendamment du fait que le comportement était correcte auparavant. Soit c'est une évolution de type et il faut changer le constructeur, au moment du parsing du fichier bibliothèque, ou l'utilisation, au moment d'injecter le composant dans le schéma, soit il y avait le bug et il faut ajouter la transformation adéquate pour transformer le type relcoord en type coord consommable par le contexte.

    La beauté du truc, c'est que mis à part les oublis de transformation, j'avais tout codé correctement. Du coup, quand ça a compilé, ça a marché. Car c'est le compilateur qui m'a indiqué où se trouvaient mes bugs. Comparé à certaines pérégrinations de débogage de python dans certaines branches de traitement mal testées, je dois dire que ça a été une vraie bouffée d'oxygène et un argument supplémentaire pour coder plus en ocaml.

    Quelques commentaires sur cette aventure

    L'utilisation de types annotés n'introduit pas de code supplémentaire ou d'utilisation d'espace mémoire dans l'exécutable. Une fois la vérification de type effectuée, les types annotés sont identiques aux types synonymes à l'exécution.

    L'injection du Relcoord est moins invasive qu'il n'y parait. Ocaml a l'inférence de type, ce qui limite les besoins à la définition des types internes du module de gestion des bibliothèques de composants de Kicad, et aux constructeurs et déconstructeurs. La création d'opérations au niveau d'abstraction Coord, Relcoord tels que

    val +$ : coord -> relcoord -> coord
    val rotation : relcoord -> relcoord

    et le fait que la plupart des fonctions sont déclarées sans spécification de type diminue grandement le volume de la migration.

    On peut (doit ?) pousser le concept plus loin, comme par exemple écrire une bibliothèque de calcul matriciel qui vérifie à la compilation la dimensionnalité des calculs.

    Cela à un rapport (très simplifié) à la preuve de programme. Ainsi, à présent, je peux garantir qu'aucun composant électronique ne peut être passé directement à l'affichage. C'est une garantie sans intérêts pour l'utilisateur, mais on peut imaginer saisir dans les relations entre les types des garanties susceptible d'intéresser l'utilisateur, par exemple, que l'application ne fournit pas à un tiers les informations que je lui fournis.

    À ma connaissance, seuls les langages fonctionnels typés offrent cette possibilité de différencier des types structurellement identiques, autrement qu'en faisant des classes.

    Lire les commentaires

  • Du choix discutable des sources de Google pour ses définitions automatiques (Journaux LinuxFR)

    Cher Journal,

    Suite au journal-candidature précédent j'ai voulu faire une recherche simple sur google :

    rôle député

    pour me rafraichir la mémoire.

    Titre de l'image

    Google me renvoit alors vers une définition provenant du site personnel de Marion-Maréchal Le Pen

    On ne va même pas parler de la définition en elle-même, qui, sans êtres fausse, n'est surement pas la plus concise ni la plus précise jamais réalisée mais je me demande juste pourquoi Google ne pointe pas vers wikipedia comme d'habitude ou mieux service-public.fr ou même vie-publique.fr (deux site officiels des institutions Françaises) ?

    D'ailleurs le lien vers vie-publique.fr est le premier dans la liste des résultat après l'encadré définition.

    Comment google choisit ses "best definition" ? Je crois pourtant pas que ce soit possible de payer comme pour le contenu sponsorisé.

    Si c'est par un algorithme comme d'usage il faut croire que certains partis ont su en tirer profit pour faire du racolage a moindre frais. D'ailleurs, vu que l'algorithme renvoie bien vers vie-publique.fr en premier, pourquoi ce n'est pas celui-ci qui est jugé le plus pertinent pour l'encadré "definition" ? Je ne trouve pas ça logique. Bref, quelqu'un sait comment ça marche (apparemment les devs de MLP oui) ?

    Ne pensez-vous pas que cela pose problème quand on connait l'importance du "Numérique" (Internet, réseaux sociaux, whatever) et notamment Google comme moyen d'information ?

    J'ai signalé le problème via le formulaire google mais vu qu'on ne reçoit aucun accusé de réception ni lien de suivi je me demande si quelqu'un connait une association, un groupe ou un mouvement que ça pourrait intéresser et qui pourrait suivre le problème sur la durée mais aussi assez rapidement vu les prochaine échéances électorales ?

    PS: La définition aurait pointé sur le site de Fillon Melanchon Macron Hamon ou n'importe qui d'autre le problème resterait le même (à une mesure différente selon les sensibilités de chacun).

    My 2 Cents.

    Lire les commentaires

  • Tablette 2017 (Journaux LinuxFR)

    Bonjour.
    J'aimerais avoir votre avis, de façon assez large, sur le sujet des Tablettes en 2017.

    On trouve aujourd'hui toute sorte de tablettes sur le marché. De l'Apple, de l'Android et du Windows (plus quelques outsider, mais un peu confidentiel quand même). Et on y vois, dans les grandes enseignes, des rayons au moins aussi grands que ceux des ordinateurs conventionnels.

    C'est un système qui remplace aujourd'hui l'ordinateur conventionnel pour beaucoup de monde, et même si l'écran tactile pose de sérieux problème d'ergonomie quand on veux faire autre chose que consulter de l'information, ça n'en reste pas moins un objet pratique quand l'activité est la détente de neurone au fond du canapé.

    Mais quel matériel prendre (ou même préférer) quand on est libriste, et quand on voudrais même un peu de vie privée ?


    APPLE - iOS

    Bon, pour l'ouverture on repasse, Pour la vie privée faut y croire, et pour le budget faut l'avoir.
    Mais à côté de cela, ils semblent avoir arrêté d'innover dans ce secteur. Voir ils se concentrerais plus sur les tables (12" c'est déjà la taille de mon ordinateur, pour une tablette c'est grand), les petits appareils semblant simplement abandonné.

    Google - Android

    Un faux gentil qui fait de l'open source sans adopter vraiment la philosophie du libre, l'amour de Google pour nos données personnelles pouvant en refroidir plus d'un.
    On y voir à peu près tous les prix, toutes les configurations, de la plus sage aux plus excentriques. Mais le support semble souvent abandonné à la sortie même du produit.

    Quelques dérivés (plus éthique, plus respectueuse) existent, mais peu on vraiment parler de véritables alternatives ?

    Microsoft - Windows

    On ne présente plus Windows qui depuis sa version 8 essaye durement de s'adapter au monde des tablettes. Un monde encore difficile pour cet éditeur ou il essaye d'y faire revenir le monde sur le quel il est roi : Le Desktop.
    Certains dirons «le bon vieux monde», mais c'est aussi souvent celui qu'on fuit les libristes.

    Intel - Atom

    Non pas au niveau du logiciel, mais au niveau du matériel, Intel qui c'est vu prendre son marché informatique par les ARM reviens ici à l'attaque sur le marché des tablettes et PC Hybride avec ce bon vieux x86.

    Finalement cette architecture très largement connue du monde des bidouilleurs et des libristes, ne représenterais elle pas l'une des meilleures opportunité pour l'arrivée massive de nos Gnu/Linux dans ce monde ?


    Comment le monde du libre (dans sa philosophie de liberté) arrive elle, aujourd'hui, à gérer ce changement ou le classique PC tombe en désuétude ?
    Quels sont aujourd'hui les vrais projets viables ? Comment évolue on par rapport à ce virage de notre société numérique qui s'impose à nous ?

    J'aimerais avoir le fruit de vos réflexions les plus larges possibles sur ce sujet.
    Je suis certains qu'il s'y cache beaucoup de très bonne choses.

    Lire les commentaires

  • Gamedev Framework 0.3.0 (Journaux LinuxFR)

    Gamedev Framework (gf) est un framework de développement de jeu vidéo 2D en C++11. Il est basé sur SDL et OpenGL ES 2.0 et s'inspire très largement de l'API du module graphique de SFML avec quelques différences mineures et surtout en ajoutant des fonctionnalités non-présentes dans SFML.

    Six mois après la version 0.1.0 et trois mois après la version 0.2.0, la version 0.3.0 sort aujourd'hui, comme prévu.

    Au menu des nouveautés, j'ai refait complètement l'interface en mode immédiat en me basant sur Nuklear qui a le grand avantage par rapport à Dear Imgui de ne pas avoir de variables globales. Tout est bien encapsulé dans des structures. De plus, l'auteur a construit sa bibliothèque pour qu'elle soit embarquée, et donc tout le code est dans un unique .h, c'est-à-dire les déclarations des types et des fonctions et l'implémentation d'icelles. La bibliothèque permet également de venir brancher son système de rendu assez facilement (il y a plein d'exemples sur tout un tas de bibliothèques), y compris pour le rendu des fontes. Au niveau des fonctionnalités, on a tout ce qu'on peut attendre d'une telle bibliothèque. J'ai donc encapsulé tout ça dans une classe pour masquer Nuklear et utiliser mes types. Et j'ai surtout passé pas mal de temps à documenter parce que la documentation de Nuklear est inexistante. Voici une capture de l'outil gf_noise présenté la dernière fois avec cette nouvelle bibliothèque:

    imgui avec Nuklear

    L'autre gros ajout de cette version, c'est la collision entre deux polygones. J'ai implémenté les algorithmes GJK (pour la détection de collision) et EPA (pour le calcul de la normale et de la pénétration) qui ne sont pas simples à comprendre. Je me suis beaucoup inspiré des tutoriels de Dyn4J (un moteur physique pour Java) qui sont très pédagogiques avec plein de dessins, d'explications et de bouts de code : GJK (Gilbert–Johnson–Keerthi) et EPA (Expanding Polytope Algorithm). Et ça a l'air de marcher ! Ce travail prépare l'ajout d'un moteur physique simple, comme demandé par devnewton. J'y ai réfléchi un peu et en fait, ses arguments m'ont convaincu. Avoir un moteur physique simple peut être utile pour beaucoup de jeux, sans avoir à sortir l'artillerie lourde genre Box2D. C'est en essayant de porter un vieux jeu qui utilisait Box2D que le besoin est apparu très clairement. Donc, ça sera sans doute dans la version 0.4.0.

    Pour le reste, plein de petits ajouts et plein de petits changements et quelques corrections de bugs: porter ou développer des jeux en même temps que coder gf permet d'en trouver pas mal. À noter d'ailleurs le portage d'un nouveau jeu (disponible dans les sources), Lux, qui est un shoot'em up ultra classique et dont voici une petite capture d'écran.

    Lux

    En conclusion, cette sortie tombe juste avant la Global Game Jam à la fin du mois. Je vais donc utiliser cette version et sans doute ajouter un nouveau jeu à la collection ! Rendez-vous dans trois mois, le 14 avril, pour la sortie de la version 0.4.0.

    Lire les commentaires

  • Les consultations publiques en ligne doivent être basées sur des logiciels libres (Dépêches LinuxFR)

    La consultation publique en ligne initiée par MM. les députés Luc Belot (PS) et Patrice Martin‐Lalande (LR) sera clôturée mardi 17 janvier 2017. Elle porte sur leur proposition de loi « généralisant la consultation publique en ligne, par l’Internet, sur les textes de loi avant leur examen par le Parlement ».

    Au vu du calendrier parlementaire, cette proposition de loi ne sera vraisemblablement pas présentée au Parlement, cependant elle a le mérite de faire avancer le débat sur les consultations publiques en ligne. D’autant qu’il est tout à fait probable que la prochaine majorité se saisisse de ce sujet tant il semble populaire : nombreux sont ceux qui semblent considérer ces consultations comme un pilier d’un « renouveau démocratique ». C’est le cas des députés à l’origine de la proposition qui voient dans ces consultations un moyen de « retisser le lien de confiance distendu ».

    Si le débat de fond sur l’opportunité et le périmètre de cette procédure présente un intérêt réel, il est une question de forme sur laquelle il ne peut être transigé : les consultations publiques en ligne doivent être basées sur des logiciels libres. Le numérique ne peut aider la démocratie sans en adopter les fondements. C’est dans cette optique que l’April a formulé une proposition d’amendement au texte des députés afin d’inscrire dans la proposition de loi le recours impératif à des logiciels libres au moment de consultations publiques en ligne.

    Notons d’ailleurs que la plate‐forme servant de base à cette consultation, tout comme celle qui avait été utilisée pour le projet de loi « République numérique », repose sur un logiciel privateur de la société Cap Collectif. Sur ce sujet, lire l’excellent billet de Regards Citoyens : Civic Tech ou Civic Business ? Le numérique ne pourra pas aider la démocratie sans en adopter les fondements.

    Si vous souhaitez participer à cette consultation, et notamment soutenir la proposition de l’April, l’inscription à la plate‐forme a le mérite d’être très rapide et d’exiger un nombre minimal de données personnelles : un pseudonyme, un mot de passe et une adresse de courriel suffisent.

    Lire les commentaires

  • Info perso: ma candidature aux législatives (Journaux LinuxFR)

    Bonsoir à tous,

    Tout d'abord bonne année à tous et mes meilleurs vœux!

    Je sais que ce n'est pas le lieu mais comme nous sommes vendredi…

    Je vous annonce que je suis candidat aux législatives pour juin prochain dans la 1ère circonscription de Loire-Atlantique (Nantes-Nord, Orvault, Sautron).

    J'ai participé dans pas mal d'associations quand j'étais un peu plus jeune et je suis toujours un adepte des logiciels libres. Donc je pourrai en parler mais aussi les défendre. Je défendrais également une certaine notion de la liberté.

    Je suis à votre disposition pour en discuter si besoin,

    Bon week-end

    Sincèrement,
    Antoine Nivard.

    Je n'ai pas mis les liens car c'est pour vous informer qu'il y a des citoyens qui s'engagent dans la politique, et en plus des partisans du logiciel libre!

    Lire les commentaires

  • Des conséquences d'un plâtre (Journaux LinuxFR)

    'lut,

    Je me retrouve avec le bras droit dans le plâtre pour plusieurs semaines suite à la rencontre brutale avec un véhicule qui m'a grillé la priorité alors que j'étais en vélo. Allant au boulot depuis des années en vélo, je pourrais disserter des heures sur la dangerosité d'utiliser son vélo dans la jungle urbaine et les campagnes d'incitation à prendre le vélo dans ce contexte, mais ce n'est pas l'objet de ce post.
    Je me retrouve coincé à la maison, quasi incapable de faire quoi que ce soit, d'autant que je suis droitier et que ma main est peu mobile et l'ensemble encore douloureux. Je me voyais condamné à rester avachi dans le canapé à regarder les feux de l'amour une bière dans ma main encore valide. Mais finalement j'ai trouvé bien plus gratifiant d'installer et/ou tester toutes les choses que j'avais jamais le temps de faire dans le monde du libre bien entendu, d'où ce post.

    En premier lieu, j'ai mis à niveau ma station de Musique Assistée par Ordinateur avec les dernières versions de Rosegarden et d'Ardour que j'ai pu tester consciencieusement. Tous les musicos ne jurent que par Ardour, et pourtant je trouve qu'il nettement moins convivial que Rosegarden. Il y a quand même des manips d'édition classiques qui sont particulièrement tordues et absolument pas intuitives, qui nécessitent d'étudier la doc et demandent 4 actions alors que sous Rosegarden on fera la même chose avec une seule action de manière totalement intuitive ! Pour le MIDI c'est un peu la croix et la galère avec Ardour avec des outils d'édition assez limités. Par contre côté Ardour la richesse des plugins et autres traitements audio est prodigieuse, c'est sans doute ce qui explique l'attrait d'Ardour des musicos confirmés, car le champ des possibilités est absolument infini. Pour les autres je conseillerai plutôt Rosegarden qui est plus facile d'accès, pour l'audio mais également pour le MIDI avec des outils d'édition, notamment de partition, très évolués. Rosegarden ne dispose pas par contre de la richesse des traitements audio (il n'intègre pas les plugins LV2), mais on pourra se contenter des plugins LADSPA pour commencer et c'est déjà pas mal.
    En résumé, Ardour point fort: les traitements audio, Rosegarden points forts: MIDI et l'interface plus conviviale.
    Pour en savoir plus tuto sur rosegarden 16.06 par là http://www.funix.org/fr/linux/index.php?ref=mao-util#Rosegarden et le tuto d'Ardour 5.50 par ici http://www.funix.org/fr/linux/index.php?ref=mao-util#ardour

    En deuxième lieu, j'ai passé du temps sur kdenlive pour le montage vidéo. kdenlive est maintenant complètement intégré à l'environnement KF5/Qt5, je regrette néanmoins depuis pas mal de régressions. Il était parfaitement francisé dans ses versions 0.9.X, on a maintenant une sorte de franglais et on a perdu également quelques fonctions parfois utiles (comme la possibilité de retailler une image automatiquement ou d'inverser un clip). Par ailleurs on a plus le choix pour la sortie vidéo, glx/OpenGL est imposé et sur ma machine j'ai pu constater une dégradation sensible des performances de kdenlive avec de la HD. Heureusement que kdenlive intègre une fonction de "dégradation" des vidéos pour le montage (Proxy clip). Mais c'est quand même assez désagréable d'avoir l'impression que ça marchait mieux avant. Je regrette également que la fonction qui permet d'utiliser la puissance du GPU en utilisant movit fasse planter kdenlive.Il y a néanmoins des points positifs, on peut maintenant générer du 4K (format H265/HEVC) dès lors bien sûr qu'on dispose du 4K en entrée et il y a pas mal de petites fonctions en plus ou qui ont été améliorées/stabilisées. Je travaille actuellement sur les fonctions de motion tracking et de travail sur fond vert, ça demande quand même un peu d'investissement matériel en terme de lumière, de fond uniforme pour arriver à faire quelque chose de sympa, mais les possibilités sont énormes. Mon tuto mis à jour par là http://www.funix.org/fr/linux/index.php?ref=kdenlive

    J'ai mis à jour mes 8 machines linux (pour 3 personnes à la maison…) et j'ai encore bien d'autres sujets en chantier, dont l'accès sécurisé à distance de mon serveur perso, le partage d'une connexion 4G d'android vers linux, la personnalisation d'un environnement XFCE, tester les dernières versions d'OpenShot video et Cinelerra. Bref encore de quoi largement développer mon côté gauche et ne pas voir le temps défiler.

    Lire les commentaires

  • Meilleures contributions LinuxFr.org : les primées de décembre 2016 (Dépêches LinuxFR)

    Nous continuons sur notre lancée de récompenser ceux qui chaque mois contribuent au site LinuxFr.org (dépêches, commentaires, logo, journaux, correctifs, etc.). Vous n’êtes pas sans risquer de gagner un abonnement à GNU/Linux Magazine France ou encore un livre des éditions Eyrolles ou ENI. Voici les gagnants du mois de décembre 2016 :

    Abonnement d’un an à _GNU/Linux Magazine France :

    Livres des éditions Eyrolles et ENI :
    - Matthieu Moy, pour darktable 2.2.0 ;
    - Framasky, pour GitLab libère les GitLab Pages ;
    - maclag, pour Les outils sociaux décentralisés en panne ;
    - Xavier Claude, pour Retour d’expérience sur Qubes OS : un peu plus de sécurité pour votre desktop ;
    - Cédric Krier, pour Sortie de Tryton 4.2 ;
    - Kévin Dunglas, pour API Platform 2 : un cadriciel pour créer des API Web hypermédia en quelques minutes.

    Les livres qu’ils ont sélectionnés sont en seconde partie de la dépêche. N’oubliez pas de contribuer, LinuxFr.org vit pour vous et par vous !

    Certains gagnants n’ont pas pu être joints ou n’ont pas répondu. Les lots ont été réattribués automatiquement. N’oubliez pas de mettre une adresse de courriel valable dans votre compte ou lors de la proposition d’une dépêche. En effet, c’est notre seul moyen de vous contacter, que ce soit pour les lots ou des questions sur votre dépêche lors de sa modération. Tous nos remerciements aux contributeurs du site ainsi qu'à GNU/Linux Magazine France, aux éditions Eyrolles et ENI.

    Bandeau LinuxFr.org

    Les livres sélectionnés par les gagnants :

    Logo éditions Diamonds   Logo éditions ENI   Logo éditions Eyrolles
                       

    Lire les commentaires

  • Odoo, éditeur de logiciel de gestion libre, sort une nouvelle application Odoo Email Marketing (Dépêches LinuxFR)

    Avec la sortie de sa dernière version, Odoo, la suite d'applications pour la gestion d'entreprise, a retravaillé son application de publipostage: Odoo Email Marketing.
    Odoo Email Marketing existe depuis la version 8 mais avec la nouvelle version 10 l'application prend un vrai tournant ! Une nouvelle interface, de nouveaux modèles… Odoo Email Marketing devient plus simple, plus intuitif et plus réactif.

    Fini l'importation de contacts grâce à l'intégration

    Comme toutes les applications Odoo, la fonctionnalité principale de la solution est appliquée à Odoo Email Marketing. Celle-ci est intégrée à toutes les autres applications Odoo. Du coup, il est facile de choisir les destinataires à partir de la base de données Odoo, sans effectuer aucune importation ou exportation. Par exemple, vous choisissez d'envoyer une lettre d'information à vos nouveaux prospects de Odoo CRM ou envoyez un courrier uniquement aux participants d'un événement spécifique que vous organisez avec l'application Odoo Event. Tous les contacts sont automatiquement synchronisés et sont à jour !

    Vous pouvez créer une liste (avec des filtres spécifiques) et réutiliser la même liste des mois plus tard, tous les nouveaux contacts qui correspondent au filtre seront automatiquement dans votre liste créée précédemment.

    Vous pouvez également choisir d'importer une liste externe d'e-mails de contacts. Si l'un de ces contacts répond à votre e-mail, Odoo CRM crée automatiquement lead à partir de cette réponse et ajoute le contact dans votre CRM ! Ceci est un autre exemple de la façon dont vous pouvez gagner du temps avec la fonctionnalité d'intégration.

    Vous n'êtes pas inspiré ? Prenez un modèle !

    Odoo Email Marketing est livré avec un ensemble de différents modèles. Tout type d'entreprise trouvera celui qui correspond à son style. Grâce à ces modèles, vous pouvez créer des e-mails de qualité plus rapidement !

    Éditeur Drag & Drop

    Odoo vise toujours à maintenir une interface simple et conviviale. Cette nouvelle application est livrée avec une fonctionnalité d'édition facile : des blocs de construction que vous pouvez glisser et déposer.

    Selon le contenu que vous souhaitez ajouter à un endroit précis dans le courrier électronique, vous pouvez choisir le type de bloc dans le menu de gauche et le glisser et le déposer à sa place. Le menu de gauche contient plus de 20 blocs de construction différents : du titre, au pied de page, avec du texte et des images à insérer facilement.

    Cette fonctionnalité permet à quiconque de modifier un bulletin d'information, aucune connaissance en code n'est nécessaire.

    Un seul prix, quel que soit le nombre d'abonnés ou d'e-mails

    Dans sa version communautaire, libre et téléchargeable sur le site, l'application Email Marketing n'a aucune limite dans le nombre de mails envoyés, tout dépend du serveur que vous utilisez.

    Dans sa version payante, elle offre un nombre illimité d'abonnés ; vous pouvez avoir 10 contacts ou plus de 500 000 pour le même prix. Cela permet à une entreprise en croissance de continuer à utiliser Odoo sur le long terme, sans frais supplémentaires. Dans la version SaaS, le prix est fixé par mois, indépendamment du nombre d'e-mails que vous envoyez.

    Toujours dans la version cloud, il est possible d'utiliser une application, de manière autonome, gratuitement. Dans ce cas, Odoo Email Marketing est limité à 400 emails par jour. Cette limite est portée à 50000 courriels par jour avec l'abonnement payé (30 € / 40 $). Si vous envoyez plus de 50000 courriels par jour, il n'y a aucun coût supplémentaire et les courriels restants sont envoyés par lots pendant plusieurs jours.

    Obtenir des statistiques

    Avec Odoo Email Marketing vous avez immédiatement les taux de livraison, d'ouverture, de réponse, de clics et de rebond. Il est facile de voir les statistiques pour chaque catégorie et de voir quel lien a été cliqué, etc. Lorsque vous cliquez sur le bouton « Désabonner », le destinataire est automatiquement marqué comme « opt-out » dans toutes vos listes.

    Lire les commentaires

  • Odoo, éditeur de logiciel de gestion libre, sort une nouvelle app: Odoo Email Marketing (Dépêches LinuxFR)

    Avec la sortie de sa dernière version, Odoo, la suite d'applications pour la gestion d'entreprise, a retravaillé son application de publipostage: Odoo Email Marketing.
    Odoo Email Marketing existe depuis la version 8 mais avec la nouvelle version 10 l'application prend un vrai tournant ! Une nouvelle interface, de nouveaux modèles… Odoo Email Marketing devient plus simple, plus intuitif et plus réactif.

    Fini l'importation de contacts grâce à l'intégration

    Comme toutes les applications Odoo, la fonctionnalité principale de la solution est appliquée à Odoo Email Marketing. Celle-ci est intégrée à toutes les autres applications Odoo. Du coup, il est facile de choisir les destinataires à partir de la base de données Odoo, sans effectuer aucune importation ou exportation. Par exemple, vous choisissez d'envoyer une lettre d'information à vos nouveaux prospects de Odoo CRM ou envoyez un courrier uniquement aux participants d'un événement spécifique que vous organisez avec l'application Odoo Event. Tous les contacts sont automatiquement synchronisés et sont à jour !

    Vous pouvez créer une liste (avec des filtres spécifiques) et réutiliser la même liste des mois plus tard, tous les nouveaux contacts qui correspondent au filtre seront automatiquement dans votre liste créée précédemment.

    Vous pouvez également choisir d'importer une liste externe d'e-mails de contacts. Si l'un de ces contacts répond à votre e-mail, Odoo CRM crée automatiquement lead à partir de cette réponse et ajoute le contact dans votre CRM ! Ceci est un autre exemple de la façon dont vous pouvez gagner du temps avec la fonctionnalité d'intégration.

    Vous n'êtes pas inspiré ? Prenez un modèle !

    Odoo Email Marketing est livré avec un ensemble de différents modèles. Tout type d'entreprise trouvera celui qui correspond à son style. Grâce à ces modèles, vous pouvez créer des e-mails de qualité plus rapidement !

    Éditeur Drag & Drop

    Odoo vise toujours à maintenir une interface simple et conviviale. Cette nouvelle application est livrée avec une fonctionnalité d'édition facile : des blocs de construction que vous pouvez glisser et déposer.

    Selon le contenu que vous souhaitez ajouter à un endroit précis dans le courrier électronique, vous pouvez choisir le type de bloc dans le menu de gauche et le glisser et le déposer à sa place. Le menu de gauche contient plus de 20 blocs de construction différents : du titre, au pied de page, avec du texte et des images à insérer facilement.

    Cette fonctionnalité permet à quiconque de modifier un bulletin d'information, aucune connaissance en code n'est nécessaire.

    Un seul prix, quel que soit le nombre d'abonnés ou d'e-mails

    Dans sa version communautaire, libre et téléchargeable sur le site, l'application Email Marketing n'a aucune limite dans le nombre de mails envoyés, tout dépend du serveur que vous utilisez.

    Dans sa version payante, elle offre un nombre illimité d'abonnés ; vous pouvez avoir 10 contacts ou plus de 500 000 pour le même prix. Cela permet à une entreprise en croissance de continuer à utiliser Odoo sur le long terme, sans frais supplémentaires. Dans la version SaaS, le prix est fixé par mois, indépendamment du nombre d'e-mails que vous envoyez.

    Toujours dans la version cloud, il est possible d'utiliser une application, de manière autonome, gratuitement. Dans ce cas, Odoo Email Marketing est limité à 400 emails par jour. Cette limite est portée à 50000 courriels par jour avec l'abonnement payé (30 € / 40 $). Si vous envoyez plus de 50000 courriels par jour, il n'y a aucun coût supplémentaire et les courriels restants sont envoyés par lots pendant plusieurs jours.

    Obtenir des statistiques

    Avec Odoo Email Marketing vous avez immédiatement les taux de livraison, d'ouverture, de réponse, de clics et de rebond. Il est facile de voir les statistiques pour chaque catégorie et de voir quel lien a été cliqué, etc. Lorsque vous cliquez sur le bouton « Désabonner », le destinataire est automatiquement marqué comme « opt-out » dans toutes vos listes.

    Lire les commentaires

  • Mon sac (Journaux LinuxFR)

    Comme probablement beaucoup d'entre vous mon ordinateur me suit un peu partout, et pour le transporter (et tout ce qui va avec) j'ai un sac (Qui vient de me lâcher il y à peu).

    Mais vous c'est quoi votre «Sac» ? Votre «Babasse» ?

    Lire les commentaires

  • Weboob s’offre une nouvelle version pour fêter la nouvelle année (Dépêches LinuxFR)

    Weboob (Web Outside Of Browsers) est un ensemble d’applications interagissant avec des sites web.

    Pour fêter la nouvelle année, l’équipe de développeurs de Weboob a mis les bouchées doubles pour réussir la sortie d’une nouvelle version. Cette version 1.2 est l’aboutissement d’un travail très actif durant tout le cycle de développement, avec plus de 1 400 commits en onze mois, écrits par 29 contributeurs différents.

    En plus de fournir une bibliothèque permettant de grandement simplifier l’extraction de données des sites, Weboob compte aujourd’hui 220 modules prêts à l’emploi pour accéder à de nombreux sites Web sans passer par un navigateur standard.

    Sans être exhaustive, la suite de la dépêche vous propose de découvrir quelques nouveautés de cette version, que ce soit pour les utilisatrices et utilisateurs, ou les développeuses et développeurs.

    Sommaire

    Applications graphiques et passage à Qt 5

    Si au niveau des fonctionnalités les applications graphiques n’ont pas toutes évolué, on peut noter, en revanche, le passage de toutes les applications de Qt 4 vers Qt 5.

    Au niveau des améliorations notables, on peut citer les applications QCineoob et QCookboob qui sont désormais plus claires en affichant les résultats de recherches, gagnent en clarté au niveau des différents onglets et s’enrichissent d’un nouveau raccourci clavier (Alt + ) pour revenir en arrière.

    Enfin, la nouvelle application QBoobLyrics fait son apparition. Elle permet de chercher et afficher des retranscriptions de textes de chansons.

    Banques, factures, que du bon

    Budget Insight (BI), avec plus de 60 % des changements de cette version, est le plus gros contributeur de Weboob, principalement sur les connecteurs bancaires et de factures.

    Le projet a bénéficié d’une refonte de la gestion des virements, qui sont proposés professionnellement par BI à travers leur API, et le portage d’une partie des connecteurs bancaires vers la nouvelle capability CapBankTransfer.

    Il est donc aisé, à partir de l’application boobank, d’initier des virements SEPA vers les bénéficiaires internes et externes.

    Cela se retrouve également dans l’application mobile (propriétaire) Budgea : capture d’écran de Budgea

    Dans les autres nouveautés, les informations concernant votre conseiller bancaire sont également récupérées, à travers la commande advisor : une raison de moins de vous connecter au site de votre banque !

    Logements

    Weboob suit les grandes tendances, y compris le boom de l’immobilier et les difficultés pour trouver une location dans certaines régions de France. Les applications QFlatBoob et flatboob affichent désormais le prix au mètre carré des logements, et gagnent un peu en ergonomie quand des champs sont manquants (oui, il existe des annonces immobilières sans la surface).

    GitLab CI

    Buildbot était utilisé jusqu’à présent pour faire tourner les tests unitaires des modules de Weboob. Les outils existants étaient devenus obsolètes et peu utilisés, et les builders n’étaient plus tous maintenus et disponibles. Du coup, les tests unitaires étaient peu utilisés et peu surveillés.

    Avec la migration depuis le Redmine sur symlink.me vers un tout nouveau GitLab, l’intégration continue a été repensée pour utiliser GitLab CI.

    Dorénavant, un maximum de tests unitaires sera effectué à chaque commit. Ceci implique :

    • de vérifier que la dernière branche de développement compile ;
    • de vérifier que les modules passent un certain nombre de règles de codage et que les modules ont tous des icônes et des tests unitaires ;
    • enfin, de faire tourner le plus de tests unitaires possible sur Weboob et les modules, en générant un rapport de couverture de code.

    Pour ce dernier point, un des gros changements apporté est la possibilité de faire tourner un maximum de tests sans identifiants pour le module à tester, en passant automatiquement les tests nécessitant des identifiants. Il est bien entendu possible de spécifier un fichier de back‐end à utiliser pour fournir des identifiants à certains modules et faire tourner encore plus de tests unitaires.

    En plus de ces tests unitaires centralisés, chaque contributeur est invité à lancer sa propre instance de tests chez lui, pour les modules ne pouvant fonctionner sans identifiants spécifiques, afin d’envoyer le maximum de tests et de fournir une visualisation Web permettant de suivre en un coup d’œil l’évolution du statut des modules au cours du temps.

    Du côté des développeuses

    Héritage des modules, navigateurs et pages

    Weboob, dans sa volonté de conquérir le monde, Minus, et de lui imposer sa vision sexiste de plus en plus d’utilisat[eur][rice]s, avait besoin dans certains cas de gagner en lisibilité quant au nommage de ses modules.

    La question qui se posait était la suivante : comment gérer proprement les modules cic et credit mutuel qui partagent exactement le même moteur de site (et bien d'autres encore, mais il fallait bien choisir un exemple concret pour que la famille Michu dans son ensemble [père, mère et enfants de tous sexes et de tous âges] comprenne), dont les sites sont quasi-identiques, cela, sans dupliquer de code ?

    Une réponse aurait pu être de regrouper l’analyse de ces deux sites dans un seul module, mais, malheureusement, cela posait d’autres questions. Il faut supprimer l’un des modules, lequel ? Comment indiquer aux utilisat[eur][rice]s de ce module (disons CIC) supprimé, d’utiliser l’autre ? Et, surtout, comment un[e] utilisat[eur][rice] lambda nommé[e] M[onsieur][adame] Michu, saura‐t‐[il][elle] qu’[il][elle] doit utiliser le module (disons CreditMutuel) pour regarder ses comptes domiciliés au CIC ?

    La réponse que nous avons trouvée est de passer par l’héritage entre back‐ends, que ce soit au niveau des classes héritées de modules, browsers et pages.

    Les classes AbstractModule, AbstractBrowser et AbstractPage ont ainsi vu le jour !

    Par exemple, le fichier module.py du CIC ne contient maintenant plus que ça (commentaires et importations mis à parts) :

        class CICModule(AbstractModule, CapBankTransfer, CapContact):
        NAME = 'cic'
        MAINTAINER = u'Julien Veyssier'
        EMAIL = 'julien.veyssier@example.fr'
        VERSION = '1.2'
        DESCRIPTION = u'CIC'
        LICENSE = 'AGPLv3+'
        CONFIG = BackendConfig(ValueBackendPassword('login',    label='Identifiant', masked=False),
                               ValueBackendPassword('password', label='Mot de passe'))
        BROWSER = CICBrowser
        PARENT = 'creditmutuel'
    
        def create_default_browser(self):
            browser = self.create_browser(self.weboob, self.config['login'].get(), self.config['password'].get())
            browser.new_accounts.urls.insert(0, "/mabanque/fr/banque/comptes-et-contrats.html")
            return browser

    L’introduction de ces nouveautés a aussi permis de gérer différemment les classes génériques qui permettaient de faciliter l’analyse de sites de journaux numériques. Jadis, ces facilitateurs étaient placés dans la partie core de Weboob, partie qui ne pouvait être mise à jour (en cas de bogue d’errance de développement dans les sites scrappés) qu’avec la publication d’une nouvelle version de (ne vous en cachez pas) votre outil préféré.

    Dorénavant, il suffit d’étendre un nouveau module spécialement créé pour l’occasion et qui n’implémente aucune capability ; pour ne pas le nommer genericnewspaper, afin de profiter de ces facilitateurs. Ce dernier, comme tous les autres modules, peut être mis à jour, alléluia, via un simple weboob update.

    Par exemple, le module minutes20 (pour gérer le journal 20 minutes), se contente d’hériter de GenericNewspaper, de configurer l’adresse URL d’un article, les expressions XPath des articles, et c’est à peu près tout.

    Prise en charge des versions de Python

    Comme annoncé lors de la dernière sortie, Weboob 1.1 était la dernière version à prendre en charge Python 2.6. Python 2.7 est donc la seule version prise en charge par Weboob 1.2.

    Rappelons que ce sont les anciens modules utilisant la bibliothèque mechanize (à travers weboob.deprecated.browser) qui retiennent Weboob à Python 2.
    Tous les nouveaux modules (depuis Weboob 1.0) sont écrits avec Browser 2 (qui utilise la bibliothèque requests, compatible avec Python 3). D’anciens modules sont également portés vers Browser 2 au fil de l’eau.

    En vue d’un passage à Python 3, les modules utilisant toujours Browser 1 à l’été 2017 seront simplement supprimés (car ils ne sont de toute façon probablement plus maintenus), à l’occasion de la sortie du futur Weboob 1.3.

    Le passage total de Weboob et ses modules à Python 3 pourra ensuite se faire, prévu pour Noël 2017. Dès lors, plus aucune version de Python 2 ne sera prise en charge.

    Améliorations du navigateur

    Le projet ne le met pas toujours en avant, mais il est tout à fait possible d’utiliser Weboob comme une bibliothèque de scraping. En termes de fonctionnalités, le navigateur (Browser) n’a rien à envier à des projets qui pourraient venir spontanément en tête d’un développeur ou d’une développeuse souhaitant réaliser rapidement un script pour lire le contenu d’un site.

    Les (le plus souvent mauvaises) expériences dans le scraping du projet permettent d’avoir des fonctionnalités déjà intégrées pour un nouveau développeur. Exemple parmi d’autres, mais qui a été rencontré durant le cycle de cette version, certains serveurs ont mis en place des protections anti‐scraping se basant sur l’ordre des paramètres de la requête HTTP POST envoyée.

    PartialHTMLPage

    Certains sites retournent des réponses HTML partielles (au travers de requêtes XMLHttpRequest), à insérer au milieu de documents existants. Ces réponses peuvent contenir plusieurs balises racines, ce qui fait que la page retournée n’est pas du HTML.
    Le type de page PartialHTMLPage a été ajouté pour gérer ces réponses automatiquement.

    CacheMixin

    L’APIBrowser est une classe de Browser (introduite dans Weboob 1.1) dédiée aux API Web JSON, plutôt qu’aux pages HTML crados.

    Une nouvelle classe mixin a été ajoutée, CacheMixin, qui possède un cache (optionnel) pour éviter de refaire les mêmes requêtes. On peut configurer l’APIBrowser pour retourner la réponse mise en cache dès que la même requête est faite, sans aucune transmission réseau, ou bien on peut le configurer pour laisser le site décider, grâce à l’utilisation des en‐têtes ETag et If-Modified-Since.
    Une fois qu’on a ajouté le mixin à l’héritage, pour l’utiliser, il suffit de remplacer les appels à open par open_with_cache.

    Débogage simplifié

    Si les applications Weboob fournissent déjà des options permettant le débogage fin pour un utilisateur ou un développeur, il n’était pas toujours simple de déboguer en production des erreurs aléatoires sur des pages. Afin de simplifier la vie des développeurs et développeuses, il est désormais possible de configurer l’enregistrement des pages HTML lues par le navigateur dans la configuration d’un back‐end, il suffit d’ajouter l’attribut _debug_dir.

    Encodeur JSON

    Un encodeur JSON a été ajouté (dans le module weboob.tools.json) pour pouvoir convertir les objets Weboob en JSON :

        json.dumps(objet_weboob, cls=weboob.tools.json.WeboobEncoder)

    Il permet de simplifier la vie des développeurs souhaitant exporter les résultats obtenus par Weboob (notamment pour l’exposer sur des applications Web).

    Petites nouvelles

    À l’occasion de la rédaction d’un article tutoriel pour GNU/Linux Magazine France (date de parution encore inconnue), le site Linuxjobs a gagné son module Weboob. Il rejoint d’autres sites de recherche d’emploi, comme Apec, Lolix, Monster, Pôle Emploi

    Si vous voulez en savoir plus sur le projet et que vous vous rendez au FOSDEM 2017, sachez qu’une conférence aura lieu sur Weboob le dimanche à midi en salle UD2.120 (Chavanne).

    Enfin, dans la catégorie des utilisations externes de Weboob, nous vous avons souvent parlé dans les dépêches de KMyMoney. Le greffon Weboob (écrit par les développeurs de Weboob) est désormais officiel et intégré dans la dernière version.

    Contributeurs

    Merci aux contributeurs qui ont participé à cette version :

    • Adrien Clerc ;
    • Baptiste Delpey ;
    • Benjamin Bouvier ;
    • Benjamin Carton ;
    • Bernard Guyzmo Pratz ;
    • Cédric Félizard ;
    • Christophe Lampin ;
    • Edouard Lambert ;
    • Edouard Lefebvre du Prey ;
    • Florent Fourcot ;
    • François Revol ;
    • James Galt ;
    • Jean Walrave ;
    • Johann Broudin ;
    • Jonathan Schmidt ;
    • Julien Danjou ;
    • Julien Veyssier ;
    • Laurent Bachelier ;
    • Matthieu Weber ;
    • Neil Armstrong ;
    • Oleg Plakhotniuk ;
    • Phyks (Lucas Verney) ;
    • Roger Philibert ;
    • Roland Mas ;
    • Romain Bignon ;
    • Simon Lipp ;
    • Vincent Ardisson ;
    • Vincent Paredes ;
    • ZeHiro.

    Weboob est un projet qui vit grâce à ses contributeurs. Si vous souhaitez l’améliorer et que vous connaissez le Python (ou pas, des besoins sur la documentation et la qualité des icônes se font sentir), n’hésitez pas à contribuer.

    Lire les commentaires

  • BinMake : pour construire un fichier binaire décrit en texte (Journaux LinuxFR)

    BinMake est un logiciel libre permettant de créer des fichiers binaires en décrivant par du texte leur contenu.
    Il peut également être inclus dans du code C++ et être utilisé comme un flux.

    Le texte décrivant le binaire à générer permet d'indiquer des nombres de bases décimale, hexadécimale, octale et binaire, de fournir du texte brute (sur une ligne). Il permet également de modifier l'endianness.
    (Il devrait prochainement proposer des nombres flottants et du texte multi-lignes)

    Version programme exécutable

    La version exécutable peut lire l'entrée depuis un fichier ou l'entrée standard et générer le binaire dans la sortie standard ou dans un fichier.

    La syntaxe est assez simple dont voici un exemple :

    # change l'endianness (par défaut little-endian)
    big-endian
    
    # créer un nombre (par défaut hexadécimal)
    00112233
    
    # créer un nombre dont le type est explicité (%b pour binaire)
    %b0100110111100000
    
    # les octets ne sont pas concernés par l'endianness
    88 99 aa bb
    
    # change le type de nombre par défaut
    decimal
    
    # créer un nombre décimal
    0123
    
    # une chaîne de caractères
    "ceci n'est pas un texte"

    L'exemple donnera le fichier suivant :

    $ ./binmake exemple.txt | hexdump -C
    00000000  00 11 22 33 4d e0 88 99  aa bb 7b 63 65 63 69 20  |.."3M.....{ceci |
    00000010  6e 27 65 73 74 20 70 61  73 20 75 6e 20 74 65 78  |n'est pas un tex|
    00000020  74 65                                             |te|
    00000022

    Version dans un code C++

    Son utilisation dans un code C++ est très simple. Il peut être compilé en librairie.
    Il s'utilise comme un flux et accepte les E/S standards les flux de fichiers, les chaînes de caractères…
    Notez que l'entrée doit forcément être du texte.

    Il faut alors inclure le header BinStream.h et instancier la classe BS::BinStream comme dans l'exemple suivant :

    #include <iostream>
    #include "BinStream.h"
    
    using namespace std;
    using namespace BS;
    
    int main()
    {
        BinStream bin;
        bin << "'hello world!'"
                << "00112233"
                << "big-endian"
                << "00112233";
        cout << bin;
        return 0;
    }

    Lire les commentaires

  • Grumpy : un nouveau concurrent à pythran (Journaux LinuxFR)

    Salut 'nal !

    Il y a des gars chez google qui trouvent que python est trop mou au lieu d'utiliser l'une des dizaines de façon d'accélérer python, ils ont mis au point un transpiler source à source python vers go. Le principe est assez classique. On compile notre code python en go ensuite, on compile ce code go et on obtiens notre exécutable.

    Ce n'est pas sans dommage :

    • grumpy est incompatible avec les modules C
    • grumpy n'est pas capable de faire des exec/eval/compile

    Le projet est encore asse jeune et il manque pas mal de choses, notamment une grande partie de la bibliothèque standard et les décorateurs (l'évolution des fonctionnalités peut être suivi ici : https://github.com/google/grumpy/wiki/Missing-Features).

    Si ce projet est un projet open source sous licence Apache v2 et dispo sur github (https://github.com/google/grumpy), sa raison d'être principale est d'être utilisé pour l'API de Youtube. Il semble que les gars de youtube n'ont pas envie de passer de python 2.7 à python 3 et préféreraient passer à ça.

    Lire les commentaires

Les hommes se contentent de tuer le temps en attendant que le temps les
tue.
-+- Simone de Beauvoir -+-