Claude SIMON a écrit 549 commentaires

Concernant Windows, wxWindows a été renommé en wxWidgets suite à une demande (légitime ?) de Microsoft…

Zelbinium, la programmation ludique

Ça dépend des bits considérés. Je me référais à ceux au plus proche du matériel, ceux que l'on peut déduire du signal électrique qui transite par le câble reliant le modem à l'appareil émetteur/récepteur des données. Le débit de ces bits devrait être pour le moins égal aux bauds, évidemment seulement lors des périodes durant lesquelles il y a émission/réception de données.

Zelbinium, la programmation ludique

Du temps où j'utilisais un modem analogique, je m'étais intéressé à ce rapport entre bauds et bit/s. Voilà ce que j'en ai retenu et qui, pour ce que j'en ai compris, ne semble par être contradictoire avec ce qu'on trouve sur Wikipedia.

Le baud est l'unité de mesure du nombre de variations par seconde d'un signal. Si la variation consiste en deux valeurs différentes d'une seule grandeur physique, alors on a un nombre de bit/s transmis équivalent aux bauds. Si la grandeur physique variait sur plus de deux valeurs, alors chaque variation du signal permet d'encoder plus d'un seul bit, et le nombre de bit/s est alors supérieur aux bauds (mais au prix d'une plus grande sensibilité du signal aux parasites). On pouvait également faire varier plus d'une grandeur physique du signal à la fois, toujours dans le but d'encoder plus d'un bit par variation du signal.

Le signal transmis par les modems analogiques (et ça vaut, je pense, aussi pour l'xDSL et la fibre) est caractérisé par trois grandeurs physiques : la fréquence, l'amplitude, et la phase. Rien qu'en faisant varier (moduler est le terme consacré, d'où la désignation de mo(dulateur)dem(odulateur), mais là, je ne vous apprend rien…) en même temps ces trois grandeurs sur seulement deux valeurs, on multipliait le débit du signal en bit/s par trois par rapport aux bauds (chaque grandeur physique pouvant encoder un bit). Débit que l'on pouvait encore accroître, comme écrit préalablement, en augmentant le nombre de valeurs autorisées par grandeur physique. Donc, normalement, le nombre de bits par secondes ne peut être inférieur aux bauds.

Zelbinium, la programmation ludique

Pour ceux pour qui l'installation sous macOS échouait, j'ai publié une version 0.1.1 qui devrait corriger le problème…

Zelbinium, la programmation ludique

En fait, avec UnJSq, certaines opérations auraient plutôt un rendu coté client (même si rien ne s'oppose à ce que ce soit coté serveur), et, pour certaines autres, le rendu serait plutôt hybride. On ne va donc pas choisir UnJSq en fonction de ce critère. D'ailleurs, pour moi, cette histoire de rendu, c'est de la cuisine interne, dont le développeur devrait ne pas avoir à se préoccuper, sauf cas particuliers.

Pour en revenir aux frameworks JavaScript, je ne les ai évidemment pas tous étudiés. Ils sont bien trop nombreux. Mais, de ce que j'en ai vu, ils ont tous leur logique propre, même s'ils ont certains concepts en commun, qu'il est nécessaire d'assimiler. En outre, comme c'est des frameworks, cela signifie qu'ils prennent le contrôle de l'application.

UnJSq n'est pas un framework, c'est une bibliothèque, qui s'utilise comme n'importe quelle autre quelle autre bibliothèque Node.js et, du coup, le développeur garde le contrôle de l'application. Le principe de base de UnJSq, c'est que, pour chaque évènement pour lequel une action est déclarée, le développeur indique simplement les modifications à opérer sur le DOM. On voit que l'on reste là sur des concepts simples et intuitifs pour peu que l'on comprenne un tant soit peu le fonctionnement des navigateurs web…

Zelbinium, la programmation ludique

Moi-même, je suis développeur C++, donc, à priori, pas vraiment porté sur le web. Mais des clients m'ont demandé d'ajouter une interface web à certains logiciels que je leur avais développé. Comme je n'avais pas envie de me coltiner JavaScript ou consorts, ni les frameworks afférents, j'ai écrit un ensemble de bibliothèques pour pouvoir faire du développement web uniquement en C++, mais pas à la sauce CGI, comme cela existait déjà. UnJSq n'est qu'un wrapper faisant le lien entre Node.js et ces bibliothèques C++…

Zelbinium, la programmation ludique

C'est clair que UnJSq n'est pas fait pour le développeur frontend. Le gars qui utilise VueJS ou consort, il ne va pas utiliser UnJSq, et donc se mettre à node, pour faire du frontend s'il n'est pas déjà sous node par ailleurs.

UnJSq est fait pour le développeur backend sous node qui veut faire du frontend tout en restant sous node. Le but de UnJSq est d'offrir à ce genre de développeur la possibilité de faire du frontend sans avoir à recourir à un framework JavaScript…

Zelbinium, la programmation ludique

Je vais m'appuyer sur un exemple concret, à savoir http://vuejs.org/v2/guide/#Handling-User-Input.

Avec UnJSq, pour avoir l'équivalent, on va créer un fichier XSL, appelons-le Main.xsl, avec le contenu suivant :

<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet version="1.0" 
  xmlns="http://www.w3.org/1999/xhtml" 
  xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
  <xsl:output method="html" encoding="UTF-8"/>
  <xsl:template match="/">
    <div>
      <input type="textbox" id="Message" value="Hello UnJSq!"/>
      <button data-xdh-onevent="Reverse">Reverse Message</button>
    </div>
  </xsl:template>
</xsl:stylesheet>

On va ensuite créer un fichier Javascript, appelons-le main.js, avec le contenu suivant :

const unjsq = require('unjsq');

function newSession() {
    return new unjsq.DOM();
}

function acConnect(dom, id) {
    dom.setLayout("", new unjsq.Tree(), "Main.xsl");
}

function acReverse(dom, id) {
    dom.getContent("Message",
        (result) => dom.setContent("Message", result.split('').reverse().join(''))
    );
}

function main() {
    unjsq.register([
        ["Connect", acConnect], // À l'action 'Connect' on va affecter la fonction 'acConnect(...)'.
        ["Reverse", acReverse], // À l'action 'Reverse' on va affecter la fonction 'acReverse(...)'.
    ]);

    /* Ici, on lance le serveur, en déclarant 'NewSession'
    comme la fonction à lancer à chaque nouvelle session,
    'reverse', le répertoire dans lequel sont stockés
    tous les fichiers relatifs à cette 'application',
    et 'Connect', l'action à lancer suite à la connexion
    de l'utilisateur (qui va afficher la première page). */
    unjsq.launch(newSession, "reverse", "Connect");

}

main();

On place ces deux fichiers dans un répertoire nommé reverse, on lance le tout avec node reverse/main.js, après avoir installé UnJSq, et on observe le résultat en ouvrant un navigateur web à l'adresse http://localhost:8080/.

La grosse différence, c'est que le code Javascript qui va effectuer l'action associée au bouton est, non pas exécuté par le navigateur comme c'est le cas avec Vue.js, mais par node. Bon, pour un truc aussi simple, on aura aussi vite fait de mettre un onclick="..." sur le bouton (ça vaut aussi pour Vue.js), mais, l'avantage avec UnJSq, c'est que le développeur node n'est pas obligé de jongler entre node pour le backend, et un de ces framework Javascript pour le frontend : il peut tout faire avec node.

Zelbinium, la programmation ludique

À titre d'information, comme personne ne l'a cité, il y a aussi l'Odroid-C2.
Je l'avais pris à l'époque parce qu'on pouvait y installer une Debian 64 bits, alors que, pour le Raspberry Pi 3, bien qu'il soit également 64 bits, seule une Debian 32 bits était disponible (ça a peut-être changé depuis).
Le fichier /etc/apt/sources.list pointe uniquement sur ftp.debian.org, mais il y a des fichiers secondaires qui pointent sur http://oph.mdrjr.net/meveric.
Je l'utilise en headless pour tester les logiciels que je développe sur de l'ARM 64 bits, et ça fonctionne vraiment bien (autant l'Odroid que mes logiciels).

Zelbinium, la programmation ludique

Il n'existait pas beaucoup de parsers XML à l'époque. J'avais utilisé expat un temps, avant de l'abandonner pour je ne sais plus quelle raison.

Ceci dit, d'avoir codé mon propre parser XML m'a simplifié le développement de mon préprocesseur XML, car j'ai pu facilement rajouter des fonctionnalités au parser . Si j'avais conservé expat comme parser, cela n'aurait pas été aussi simple…

Zelbinium, la programmation ludique

En lisant ce journal, je me suis dit que j'ai bien de la chance.

Il y a pas mal d'année de cela, j'ai codé, en C++, un parser que j'utilise encore intensivement. Bon, c'est un parser XML, pas JSON, mais la problématique est la même.

J'ai d'abord mis en place un système de callbacks. Le parsage était assuré par une fonction à laquelle je passais en paramètre, en plus du flux contenant les données à parser, une classe abstraite, dont une des méthodes virtuelles était appelée par le parser à chaque fois qu'il rencontrait un token, la méthode appelée dépendant de la nature du token rencontré.

Ce parser me servait essentiellement à désérialiser des structures de données, et, à l'usage, le système de callbacks ne s’avérait guère pratique. Il fallait en effet systématiquement mettre en place un automate pour garder trace du contexte pour pouvoir traiter correctement chaque token rencontré.

J'ai alors modifié le parser de manière à ce qu'il me rende la main à chaque token rencontré, et je le relançais autant de fois que nécessaire jusqu'à ce que l'ensemble des données soient traitées. Du coup, plus besoin de callbacks. Son utilisation consistait, à chaque balise rencontrée, à lancer un fonction dédiée au traitement du contenu de cette balise, et qui retournait à la fonction appelante une fois ce contenu traité. Donc, plus besoin d'automate ; la fonction en cours d'exécution lors du traitement d'un token me renseignait sur le contexte.

Quand j'ai lu ce journal, je me suis dit : "je dois avoir le même problème avec mon parser XML". Mais, après examen du code de mon parser et de la manière dont je l'utilisais, il s'est avéré que non. Pourtant, j'ai écrit ce parser de manière vraiment naïve, sans souci d'optimisation d'aucune sorte. Et je m'en sers notamment, en plus de la désérialisation, pour remplir ce que j'appelle une registry, grosso-modo un arbre auquel on peut affecter des attributs à chaque nœud, arbre qui, entre autres, me sert à stocker les paramètres de configuration de mes logiciels.

Du coup, je ne vois pas trop comment les parser JSON puissent soit-disant être aussi mauvais, compte tenu que, d’après l'expérience que j'ai des parser, la manière dont le parsage est réalisé dépend de la structure des données représentées par le fichier JSON (ou XML) parsé !

Ou alors, comme dit, j'ai simplement de la chance…

Zelbinium, la programmation ludique

Ne serait-ce pas plutôt «the latter» (avec deux t) ?

Zelbinium, la programmation ludique

Comme indiqué plus haut, je factorise mon code à outrance, ce qui fait qu'une grosse partie est commune à toutes les applications que je développe. Lors du développement de ce code, dont le cœur l'a été il y a plus de dix ans, j'avais à l'esprit les problématiques de sécurité, et j'ai fait mon maximum pour éviter les failles. Ce qui, je le concède volontiers, ne garantit en rien qu'il n'y en ai pas. Toujours est-il que ce code est déployé chez de nombreux clients, dans certains cas dans le cadre d'applications client/serveur accessibles au grand public et avec une fréquentation élevée.

Jusqu'à présent, aucun client ne m'a remonté de problèmes de sécurité. Cela peut arriver demain, auquel cas, après correction de la faille, je développerais une batterie de tests pour tester la correction, et pour tenter de détecter d'autres failles similaires. Mais, à ce jour, je ne vais perdre de temps à développer des tests pour tenter de déceler des failles dont on n'a jamais détecté la moindre trace…

Quand au code que je mets à disposition sous licence Libre, comme celui faisant l'objet de ce journal, j'attire l'attention sur la section 15 et la section 16 du fichier LICENCE fournit avec les sources. Partant de là, libre à l'utilisateur de, au choix,

• auditer mon code (tâche ardue, mais pas impossible ; c'est de l'Open Source après tout),
• le soumettre à une batterie de tests,
• me demander de développer une batterie de tests.

Pour la dernière option, cela sera bien entendu réalisé contre rémunération, sauf s'il parvient à me fournir un test case mettant en évidence une faille qui justifie le développement de cette batterie de tests.

Encore une fois, même si moi-même je ne le fais pas, je conseille fortement tout un chacun de soumettre son code à un maximum de tests. Mais, concernant mon code, avec l'historique qu'il a, le gain que m'apporterait ces tests par rapport au temps que je passerais à les développer n'est pas rentable, à aucun point de vue, en particulier, mais pas seulement, du point de vue financier. D'autant plus que, et ton commentaire va également dans ce sens, aucune batterie de test ne peut garantir l'absence de failles.

Pour résumer, compte tenu de l'historique de mon code, de la manière dont il se comporte chez moi (j'utilise quotidiennement plusieurs logiciels que j'ai développés et qui contiennent donc ce code) et chez mes clients, je considère qu'il n'est pas plus vulnérable que la majorité des codes réalisés avec un minimum de sérieux et, de ce fait, probablement soumis à une batterie de tests. Mais je suis tout à fait disposé à réviser mon jugement, pour peu que l'on me soumette un test case prouvant mon erreur, et non pas seulement des considérations théoriques.

Quoi qu'il en soit, je te remercie pour tes remarques qui m'ont données l'occasion de m'expliquer davantage sur le sujet.

Zelbinium, la programmation ludique

Je suis tombe sur ce code dans ton fichier src/parser.cpp :

(...)

Est ce que tu peux expliquer ce que sont qRH, qRB, qRR, qRT, qRE et d'ou ils viennent ?
(Je suis au boulot et je peux pas charger ca dans un IDE pour tester :D )

Ce sont des macros qui datent de l'époque où je codais en C, lorsque j'avais implémenté un équivalent des exceptions, qui n'existaient pas alors, à l'aide de la bibliothèque setjmp.

Grosso modo, qRB correspond à try, qRR à catch, et qRT à l'accolade fermant du bloc du catch. Les autres macros servent à gérer les variables utilisées pour la gestion des erreurs.

Elles sont définis ici et les version d'origines, basées sur setjmp.h, sont visibles là.

D'un point de vue algorithmique, comme elles sont uniquement dédiées à la gestion des erreurs, elles peuvent être ignorées.

Zelbinium, la programmation ludique

D'abord, merci de contribuer du code, c'est sympa. 

Merci de t'y intéresser :-).

Pour le feedback :
1) Il y a genre aucun commentaires dans le code, dur pour qui que ce soit de t'aider si ils ne peuvent pas comprendre ce que le code fait

En fait, je ne cherche pas de contributeurs, car cela poserait des problèmes de licence. Le code est, par défaut, disponible sous AGPL, mais c'est sous une autre licence, moins contraignante, qu'il est disponible pour mes clients. Je peux publier ce code sous n'importe quelle licence, car j'en suis l'unique auteur. Mais s'il contient des contributions de tiers, cela sera beaucoup plus compliqué…

En fait, bien plus que des contributeurs, c'est des utilisateurs que je recherche, qui puisse me remonter les éventuels problèmes. C'est d'ailleurs pour pour cela que j'ai migré mon code sur github, qui est l'une, voire la plus populaire des forges logiciels, pour que les utilisateurs disposent d'outils qui leurs sont familiers.

Ceci dit, je pense que ce qui manque à mon code, c'est bien plus une documentation expliquant les principes généraux que des commentaires. Mais, comme c'est moi qui ai écrit le code et que je l'utilise tous les jours, je ne suis probablement pas objectif…

2) Les noms de variables/methodes/etc… sont imbitables pour le commun des mortels (aucune idée de ce que lcl, qCDTOR, etc… sont)

En effet, d'où ce que j'écrivais ci-dessus, de la nécessité d'avoir une documentation explicative. J'envisage de publier une série d'utilitaires mettant chacun en avant une fonctionnalité bien précise de mes bibliothèques, et d'en écrire la documentation correspondante à ce moment-là. Mais, compte tenu du travail que cela représente, il faudrait qu'il y ai une réelle demande à ce niveau-là, ce dont je ne suis pas convaincu, pour me lancer.

3) Exposer un parser écrit en C++ à des documents venant de sources inconnues ( = internet) est super dangereux, est-ce que tu as fais des passes de fuzzing sur ce parser au minimum ?

Bon, je vais me faire huer, mais la vérité est que j'écris très peu de tests en tant que tels. Ce n'est pas que j'y sois opposé, et je conseille fortement d'en écrire, mais le fait est, et ça fait un paquet d'années que je développe, que j'ai très bien pu m'en passer jusqu'à présent. Ceci dit, je factorise mon code très en amont du développement, ce qui explique peut-être cela. Le préprocesseur, et le parser que lequel il s'appuie, qui font l'objet de ce journal, sont récents en tant que addon Node.js, mais le code C++ qu'il y a derrière existe depuis probablement presque dix ans, et est mis en œuvre dans tous les développements que j'ai réalisés depuis. C'est donc du code qui est utilisé très intensivement. Certes, ça ne garantit rien en soi, mais, plus un code a d'utilisateurs, plus rapidement les problèmes sont détectés (et, à priori, corrigés), et c'est pour cela que je cherche à accroître le nombre de ses utilisateurs…

Zelbinium, la programmation ludique

Pour ceux qui ne connaissent pas (c'était mon cas il n'y pas encore bien longtemps), il est possible d'essayer le paquet en ligne, grâce à RunKit.

À titre d'exemple, copiez le code ci-dessous dans le champ de saisi, puis cliquez sur le bouton vert (run) situé en-bas à droite de ce même champ :

var xppq = require("xppq");
var str = require("string-to-stream");

var xml = '<?xml version="1.0" encoding="UTF-8"?> <SomeTag xmlns:xpp="http://q37.info/ns/xpp/" AnAttribute="SomeAttributeValue">  <SomeOtherTag AnotherAttribute="AnotherAttributeValue">TagValue</SomeOtherTag>  <xpp:define name="SomeMacro">   <xpp:bloc>Some macro content !</xpp:bloc>  </xpp:define>  <YetAnotherTag YetAnotherAttribute="YetAnotherAttributeValue">   <xpp:expand select="SomeMacro"/>  </YetAnotherTag> </SomeTag>';

function write(text) {
    console.log(text);
}

write( xppq.componentInfo() );
write( xppq.wrapperInfo() );

function callback(token, tag, attribute, value) {
    switch (token) {
        case xppq.tokens.ERROR:
            write(">>> ERROR:  '" + value + "'\n");
            break;
        case xppq.tokens.START_TAG:
            write("Start tag: '" + tag + "'\n");
            break;
        case xppq.tokens.ATTRIBUTE:
            write("Attribute: '" + attribute + "' = '" + value + "'\n");
            break;
        case xppq.tokens.VALUE:
            write("Value:     '" + value.trim() + "'\n");
            break;
        case xppq.tokens.END_TAG:
            write("End tag:   '" + tag + "'\n");
            break;
        default:
            throw ("Unknown token !!!");
            break;
    }
}

xppq.parse(new xppq.Stream( str(xml)).on('error', (err) => console.error('>>> ERROR : ' + err)), callback);

---

(Pour ceux qui connaissent RunKit, pourquoi process.stdout.write(...) ne fonctionne-t-il pas, et y a-t-il moyen d'avoir quelques chose d'équivalent, mis à part console ?)

Zelbinium, la programmation ludique

En tant que freelance, je me présente parfois comme développeur fullstack (pas exactement sous cet intitulé, mais il y a fullstack dedans). Ce que personnellement j'entends par là, c'est la capacité de pouvoir développer une application de A à Z, de l'interface utilisateur au moteur de base de données (si requis), et cela sans préjuger des technos utilisées. Cette définition n'est sans doute pas universelle, mais le fait d'utiliser ce terme, et c'est la raison pour laquelle je l'emploi, c'est que ça éveille la curiosité de mes interlocuteurs, la plupart ne connaissant pas ou peu ce terme.

Zelbinium, la programmation ludique

Si je me souviens bien, il fût un temps où, lors de l'édition de liens d'un programme C, seuls les 6 premiers caractères d'un symbole étaient pris en compte, et la casse était ignorée. D'où, sans doute, la concision des identifiants de la bibliothèque standard…

Zelbinium, la programmation ludique

Tout le monde le sait : les lois de la physique évoluent tous les jours.

Euh non ; je pensais naïvement qu'elles étaient immuables, et que c'étaient nos connaissances les concernant qui évoluaient…

Zelbinium, la programmation ludique

Merci ! Content que ça plaise !

Pour les pièces faites avec l'Amiga, j'utilisais un tracker, probablement Protracker. Pour les sons, je piochais dans ceux qui étaient fournis avec.

Pour le MIDI, les sons sont ceux d'origine de la Sound Blaster AWE32 que j'utilisais à l'époque. Elle m'avait coûtée une petite fortune, mais c'était l'une des meilleurs carte son de l'époque.

J'ai ajouté un PDF de la partition de la pièce 'OMS0964'. Comme la pièce n'est pas achevée, il manque certaines choses comme les nuances, ou encore les articulations…

Zelbinium, la programmation ludique

En fait, ce sont plutôt des exercices de style, beaucoup étant inachevés.

Les premières sont de ma période Amiga, aux timbres aisément reconnaissables, et limitées à 4 canaux, mais je m'étais quand bien amusé.

Les dernières sont du pur MIDI.

'rosscset' n'a évidemment pas été composée par moi ; c'est une transcription (ce n'est pas vraiment le terme adéquat) que j'ai réalisée pour explorer les possibilités du MIDI.

Les voici : http://q37.info/download/music/

Zelbinium, la programmation ludique

Pour la composition proprement dite, j'utilise un séquenceur MIDI + un clavier MIDI. Vu que le style de musique que je compose contient de nombreuses variations de tempo, je n'utilise que très rarement le métronome du séquenceur. Je joue en premier une voie significative, soit celle qui a la mélodie, soit une des voies d'accompagnement, et je rajoute les autres voies en me servant de cette voie comme base rythmique.
Le processus décrit dans mon précédent message sert juste à créer la partition correspondante.
Étant donné que, comme indiqué ci-dessus, je ne me sers que très rarement du métronome (je laisse le tempo par défaut, et je me contente de couper le son du métronome), il n'y a aucune correspondance entre la pulsation du métronome et ce que je joue. Or, comme le séquenceur s'appuie sur la pulsation du métronome pour en déduire la figure des notes d'après leur durée, la partition que ce dernier me génère est absolument injouable, sans compter qu'elle n'a de loin pas le rendu obtenu avec 'Lilypond'.

Zelbinium, la programmation ludique

je serai curieux d'avoir des retours de personnes qui composent avec les différentes solutions

Pour mes compositions et mes transcriptions, je les saisis voie par voie, fragment mélodique par fragment mélodique, à l'aide d'un petit utilitaire que j'ai écrit, et qui fonctionne de la manière suivante.
Dans un premier temps, il est en mode saisie de notes, dans lequel je joue la mélodie au clavier MIDI sans tenir compte des durées. Je lui fais rejouer la mélodie note par note, un appui sur une touche du clavier non MIDI le faisant passer d'une note à l'autre, un appui sur une note du clavier MIDI remplaçant la note en cours par la nouvelle note, ce qui me permet de corriger les erreurs.
Une fois toutes les notes de la mélodie correctement saisies, je bascule en mode saisie de durées.
Là aussi, le logiciel me joue la mélodie précédemment saisie note par note, et, pour chaque note, j'appuie sur une touche du pavé numérique, ce qui lui affecte une durée et le fait passer à la note suivante. '0' pour une ronde, '1' pour une blanche, '2' pour une noire, '3' pour une croche et ainsi de suite, en utilisant '.' si la note est pointée.
Je lui fais jouer toute la mélodie en tenant compte des durées, pour vérifier si elle est correcte, et corrige si nécessaire.
Une fois que le fragment mélodique est correct, je lui fais générer un fichier 'XML' qui décrit la mélodie, à l'aide de balises de mon cru. J'applique ensuite une transformation 'XSL' sur ce fichier 'XML', en utilisant un fichier 'XSL' spécialement écrit dans ce but, ce qui me génère le fragment mélodique au format 'Lilypond'. J'insère ce fragment dans le fichier 'Lilypond' global de l'œuvre, puis j'utilise 'Frescobaldi' pour ajouter les nuances, les articulations…
Et j'obtiens au final une superbe partition dont la présentation n'a rien à envier à ceux produits par les logiciels commerciaux, et ce sans avoir à saisir notes et durées dans le format 'Lilypond'.

Zelbinium, la programmation ludique

On peut mettre les options après SRC et DEST sans problèmes. C'est surtout que l'argument de --exclude est relatif par rapport à SRC, donc il ne faut pas mettre $(dossierSource) dans le PATTERN, et ce qui est indiqué ci-dessus devrait fonctionner…

Zelbinium, la programmation ludique

Je possède une tablette Android (ARM) sous CyanogenMod qui me permet d'aller sur le web sans avoir à allumer mon ordinateur de bureau, me sert de liseuse, et sur laquelle je peux compiler et lancer les logiciels que je développe. D'ailleurs, le logiciel que j'utilise le plus sur cette tablette est celui que je présente dans ce journal.

Comme il s'agit d'un logiciel natif en ligne de commande, j'ai installé Lil'Debi pour disposer de l'environnement de compilation adéquat, et également pour disposer d'un environnement GNU/Linux, auquel je peux me connecter à distance via SSH. La finalité de mon logiciel est de produire un fichier HTML, et j'affiche celui-ci dans un navigateur web sous Android, ce dernier ayant accès au système de fichiers de Lil'Debi.

À l'origine, je faisais tourner mon logiciel sur un Nokia N900, et c'était beaucoup plus simple parce que le N900 dispose d'un véritable environnement GNU/Linux. Malheureusement, l'écran du N900 est trop petit pour déchiffrer une partition. D'où l'utilisation d'une tablette, avec installation de Lil'Debi, pour me retrouver à peu prés avec le même environnent que celui du N900. Le problème, c'est que Lil'Debi rend la tablette poussive.

Du coup, j'ai repéré une tablette Intel hybride Android/Windows, ce qui m'offre les possibilité suivantes :
- Soit de remplacer Windows par une distribution GNU/Linux,
- soit d'installer Cygwin pour y retrouver un environnement à la GNU,
- soit de l'utiliser avec Android comme ma tablette actuelle, sachant qu'elle devrait pouvoir encaisser plus facilement Lil'Debi étant donné qu'elle a beaucoup plus de RAM, Windows oblige.

Au final, je cherche l'équivalent de mon N900 en tablette 10" ou plus, et le modèle que je décris ci-dessus s'en approche le plus, sachant que j'aimerais, en plus, en lui adjoignant un trackball et un clavier, pouvoir m'en servir de machine de développement secondaire, lorsque je suis en déplacement, et qu'il faut donc qu'elle soit assez costaude…

Zelbinium, la programmation ludique