Claude SIMON a écrit 549 commentaires

Alors, mon hypothèse, et ce n'est rien de plus qu'une hypothèse, c'est que, plus un code est ancien et factorisé, plus rapidement les bugs introduits pas des modifications interagissant avec ce code sont détectés. J'ignore dans quelles proportions chacun de ces critères influe sur le résultat final, en admettant mon hypothèse fondée, mais mon code étant très ancien (informatiquement parlant) et très factorisé, il cumule de toute manière les deux avantages. Je ne sais pas en quel langage tu développes, mais, en terme de factorisation, il y a moyen d'atteindre des sommets avec les templates du C++.

Du code réputé mature, pour moi, ce n'est non seulement du code qui fait exactement ce pourquoi il est conçu, mais également qui te fournit une information pertinente si on lui demande de réaliser des choses qui n'ont pas de sens. Au début du développement de mes bibliothèques, il m'arrivait d'avoir des bugs que j'imputais en premier lieu à mes bibliothèques pour me rendre compte qu'au final le bug se situait dans le code appelant ces bibliothèques. J'ai donc modifié mes bibliothèques de telle manière que, si cette situation se reproduit, elles produisent un message qui me permette facilement de détecter l'origine du bug.

Il m'arrive également d'introduire des, disons, comportements indésirables lorsque je modifie une de mes bibliothèques, mais, sans doute parce que le code est très factorisé (encore une fois, ce n'est qu'une hypothèse), le code fautif est rapidement mis à contribution et donc son comportement erratique détecté.

Il faut savoir que, chaque jour, de manière automatisé, des utilitaires que j'ai développés, et qui sont donc basés sur mes bibliothèques, sont utilisés de manière intensive. Ces utilitaires, je les recompile régulièrement. Aujourd'hui, il est rare qu'un bug induit par des modification de mes bibliothèques ne soient détectés qu'après recompilation de ces utilitaires, mais peut-être qu'auparavant, c'était eux qui faisaient office de tests, rendant inutile l'écriture de tests spécifiques…

Zelbinium, la programmation ludique

L'argument de dire que quand on utilise de vieux algo / structure de données donne moins de bug ne prouve rien ! D'autant plus que les contraintes de l'époque ne sont plus les mêmes aujourd'hui …

Mais je n'entend rien prouver du tout. J'expose un fait, et j'avance une explication. Si tu en as une meilleure, je suis preneur.

Les problèmes d'allocation mémoire, ce n'est qu'une infime partie des bugs qui ne sont pas détectés par les outils d'analyse de code généralement …

Possible, mais les bugs que j'ai exposé dans mon précédent commentaire constituent la quasi-majorité de ceux que je rencontre, et le fait est qu'ils sont relatifs de manière générale à la gestion de la mémoire dynamique.

Il y a tout un tas de problèmes que tu ne peux pas détecter même en diversifiant les contextes de combinaison d'appel de tes fonctions, avec en vrac :

• les effets de bord de ré-utilisation des ressources déjà utilisées
• les effets de bord dû aux accès concurrentiels
• les effets de bord dû au fait que tu ne contrôle pas l’environnement d’exécution ou les entrés de tes fonctions
• etc.

Problématiques que j'ai prises en compte lors du développement de mes bibliothèques. Et les problèmes qui m'auraient échappés, vu depuis combien de temps j'utilise ces bibliothèques, il y a belle lurette que les bugs afférents se sont révélés et que je l'ai ai corrigés (là encore, c'est juste une hypothèse, mais je n'en vois pas d'autre ; et je le rappelle : l'élément-clef de ma méthode de développement, c'est la factorisation).

Bref, tout ça pour dire qu'à mon humble avis, me concernant, c'est très difficile et peu rassurant de ne pas avoir à minima du test unitaire à l'intérieur des API qu'on écrit soit même.

Je ne vois pas où est la difficulté, mais je suis parfaitement d'accord ; savoir que du code a passé une batterie de tests, unitaires ou autres, est très rassurant pour celui qui l'a développé, et je ne fais pas exception. Peut-être suis-je le développeur le plus chanceux de l'univers, mais pourquoi diable irai-je écrire des tests qui, en l'état actuel du code que je développe, ne me servirait qu'à me faire perdre du temps ?

Zelbinium, la programmation ludique

Ben déjà, je compile systématiquement (avant livraison) avec Visual C++, g++ et clang sous GNU/Linux, macOS et Windows, pour IA-32, AMD64 et AArch(32|64) (ARM), et je ne laisse passer aucun warning. Ça doit déjà éliminer pas mal de bugs. Ensuite, je n'appelle jamais les fonctions C de la bibliothèque d'allocation dynamique de la mémoire (malloc, calloc, free…), et c'est rarissime que je fasse appel (au sens propre et au sens figuré) aux opérateurs new et delete. Et quand je les utilise, là je fais extrêmement attention, notamment pour éviter les fuites mémoires.

Lorsque j'ai besoin de mémoire dynamique (dont la gestion est reconnu être à l'origine de nombreux bugs), j'utilise des objets dont le développement a débuté il y a plus de 15 ans, et que j'utilise systématiquement. Après tout ce temps, la probabilité qu'il subsiste un bug est très faible. Les seuls bugs liés à la gestion de la mémoire lorsque j'utilise mes bibliothèques sont au nombre de deux : soit je n'ai pas initialisé un objet, soit je passe un objet par valeur au lieu de le passer par référence. Et le système de gestion d'erreur de mes bibliothèques me permet de rapidement déterminer quel est l'objet concerné, et de corriger ce qui ne va pas.

Je ne manipule jamais directement la mémoire ; pas de tableau de pointeur, ou de pointeur sur un tableau. Je n'utilise jamais l'opérateur [] pour accéder à un élément de tableau ; j'utilise à la place des opérateurs de mes objets.

Le corollaire de ceci, c'est que, pour les boucles, je ne me rappelle même plus la dernière fois que j'ai écris un for (en fait, si, mais ce n'était pas du C/C++). Si je veux parcourir un conteneur, nommons-le C par exemple, c'est toujours de la manière suivante :

sRow Row = C.First();

while ( Row != qNIL ) {
 // Traitement sur C( Row ).

 Row = C.Next( Row );
}

Du coup, jamais de bug lié à un dépassement de limites. À noter que les indexes des conteneurs sont typés, ce qui fait que, si jamais j'utilise l'index d'un conteneur pour accéder à un élément d'un autre conteneur, j'ai tout de suite une erreur lors de la compilation.

Lorsque je livre une nouvelle version d'un logiciel suite à l'implémentation d'une nouvelle fonctionnalité, je le fais juste après quelques tests manuels pour voir si la fonctionnalité est implémenté correctement. Il se peut que parfois le client découvre un cas de figure pour lequel le logiciel ne se comporte pas comme il faut, mais c'est généralement très vite corrigé. Et là, écrire des tests ne servirait à rien, puisque si je n'ai pas pensé à tester ce cas de figure manuellement, je n'aurais pas non plus penser à écrire le test correspondant.

Quant aux régressions, dont l'un des but des tests est de faciliter la détection, le fait est que c'est rarissime que j'y sois confrontés. La seule explication que je vois c'est que je suis extrêmement rigoureux, notamment en ce qui concerne la factorisation, que j'applique dés que la possibilité s'en présente.

Honnêtement, à chaque fois que je livre un logiciel, j'ai un peu mauvaise conscience, vu que, contrairement à ce qui semble se pratiquer à la lecture des différents commentaires, je ne le soumets qu'à quelques tests manuels. Mais tout mes clients ont toujours été satisfait de mes prestations, ce qui permet de me consacrer exclusivement au développement de nouvelles fonctionnalités et à leur amélioration, tâche autrement plus intéressante que de coder de tests. Le jour où cette absence de tests devient problématique, et bien je m'y mettrais aussi, ou peut-être changerais-je de métier…

Zelbinium, la programmation ludique

https://github.com/epeios-q37

Zelbinium, la programmation ludique

Je vais sans doute me faire lyncher, d'autant plus que l'on n'est pas vendredi, mais comme chacun y va de son expérience personnelle pour ériger en règle absolue qu'on ne saurait produire du logiciel de qualité sans le soumettre à une batterie de tests, il n'y a pas de raison que je ne fasse pas part de la mienne comme exception à cette règle.

Alors, que ce soit bien clair : FAITES DES TESTS ! Vos développements logiciels ne s'en porteront que mieux ; les miens n'y font pas exception.

Comme tout un chacun, j'aurais l'esprit plus tranquille si je livrais mes logiciels après leur avoir fait passer avec succès une batterie de tests. Mais le fait est que le codage de ces tests prend plus de temps qu'il ne m'en ferait gagner. C'est donc une activité que je ne peux me permettre en tant que développeur professionnel, car, le temps étant de l'argent, elle est économiquement non justifiable. Pour être honnête, il me faut aussi avouer que je préfère de loin coder de nouvelles fonctionnalités que des tests (et je ne suis probablement pas le seul)…

J'ai bien été confronté à quelques bugs qui auraient été détectés nettement plus précocement, et donc corrigés plus facilement et plus rapidement, si j'avais pris la peine de soumettre le logiciel concerné à des tests, mais cela m'est arrivé tellement rarement que cela ne peut justifier l'écriture systématique de tests pour tous mes logiciels. Oui, même l'exception à la règle a son exception :-).

Mon cas est sans doute exceptionnel, voire unique, mais c'est probablement dû à la manière unique, ou du moins exceptionnelle, que j'ai de développer.
Je suis développeur C++, mais je n'utilise aucune bibliothèque C++ (en particulier, je n'ai jamais utilisé la STL), ni même C standard. J'utilise mes propres bibliothèques. Et à chaque fois que je développe une nouvelle fonctionnalité, j'essaie de la généraliser au maximum, ou d'en extraire un maximum de sous-fonctions, pour les inclure à ces bibliothèques. Ce qui fait que je n'utilise que du code factorisé au maximum. Or, plus un code est factorisé, plus il est utilisé, et ses bugs sont donc d'autant plus rapidement détectés et corrigés. Ce qui rend probablement les tests superflus dans mon cas.

Encore une fois, même si moi j'arrive à m'en passer, FAITES DES TESTS !!!

Avant de vous lancer dans des commentaires enflammés, en voici quelques-uns sur le sujet déjà publiés en ces lieux : https://linuxfr.org/users/fredx/journaux/ce-qu-on-demande-a-un-developpeur-aujourd-hui#comment-1471811

Zelbinium, la programmation ludique

Comme Zim est évoqué, et que je suis passé de Zim à QOwnNotes pour les raison suivantes, peut-être que ce dernier peut convenir, vu qu'il a un menu Encryption.

Contenu de la note avant chiffrage :

# Test encryption

Ceci est le contenu à encrypté.

## un titre markdown
### un autre titre markdown

Un *peu* de :

- **mise** en 
-  forme.

et après chiffrage :

# Test encryption

<!-- BEGIN ENCRYPTED TEXT --
LCJ6QbKhajOIUgg3xsfEUrNNfkcwYPGsCNjEhxoLZ6cYQHFX451dAvTsPT6MlyxmAFDFSZ35xv/1IgP/G0mvea5aczIT3scl2riEiyq/59URMACd6r7mPA1AElxiwv/5zKMUVFOtOUh3p7jOUH5uIZXfdoMdK2FM8rcSsJVOtZk=
-- END ENCRYPTED TEXT -->

Après chiffrage d'une note, il y a un sous-menu Edit encrypted note qui demande le mot de passe, puis permet d'éditer la note chiffrée, sans avoir à la déchiffrer au préalable, la note modifiée restant chiffrée.

Zelbinium, la programmation ludique

Demain (mercredi 11 juillet) est le dernier jour des RMLL 2018, qui ont lieu à Strasbourg. Donc, si vous êtes dans le coin, c'est l'occasion ou jamais d'y assister.

Accessoirement, c'est également ce jour que j'y donnerais 3 conférences (mes premières !) sur le toolkit Atlas (http://atlastk.org/), à propos duquel j'ai publié cet article : https://linuxfr.org/users/epeios/journaux/atlas-toolkit-sur-la-route-du-libre.
Si cela vous intéresse, n'hésitez pas : https://2018.rmll.info/users/114 ; je serais enchanté de vous y accueillir !

Zelbinium, la programmation ludique

Ce qui manque à JSon, et à Yaml aussi, qui fait que je leur préfère XML pour les fichiers de configuration, ce sont les espaces de noms…

Zelbinium, la programmation ludique

On prend un afficheur de documents et on le transforme en plateforme d'exécution d'applications… Tout va bien ?

Les applications web, c'est le même principe, me semble-t-il. Faudrait-il donc les bannir également ?

Zelbinium, la programmation ludique

D'après wikipedia :

Electron est un framework permettant de développer des applications multi-plateformes de bureau avec des technologies web (JavaScript, HTML et CSS).

Donc, à priori, ça ne paraît pas illogique qu'il s'appuie sur un navigateur web.

Partant de là, si j'ai bien compris, ceux qui sont réfractaires à Electron, ils le ne sont pas à Electron en lui-même, mais, de manière général, au principe d'utiliser des technologies web pour développer des applications bureau (ou Android). Me goure-je  ?

Zelbinium, la programmation ludique

Du coup, Atom va-t-il être abandonné, vu qu'ils ont déjà VS Code ?

Zelbinium, la programmation ludique

Juste par curiosité, c'est quoi le problème avec Electron ?

Ce n'est pas la première fois que je vois des commentaires suggérant qu'Electron présente quelques défauts rédhibitoires, mais sans préciser lesquels. Et, vu la note du commentaire, ça à l'air d'être un avis assez répandu.

Je l'utilise (pas de manière classique, il est vrai), ainsi que des logiciels qui s'appuient dessus, et je dois avouer que je ne vois pas trop quel est le problème avec Electron…

Zelbinium, la programmation ludique

Ça fait quelques temps que je cherche à remplacer Zim. Je l'avais sélectionné à l'époque parce que c'était le seul que j'avais trouvé avec lequel on peut hiérarchiser les notes, mais j'ai toujours eu du mal avec son système de mise en forme.

En soit, le système n'est pas mauvais, mais je comme je ne saisissais pas souvent de nouvelles notes, je me mélangeais toujours les pinceaux avec le balisage de Zim et celui de DokuWiki, que j'utilise nettement plus souvent.

Par ailleurs, comme j'utilise de plus en plus souvent markdown, j'ai cherché un logiciel de prise de notes qui utilise ce format. J'ai essayé Joplin et Boostnote, mais il leur manque à tout deux la hiérarchisation des notes. Mais là, je viens de découvrir QOwnNotes.

Je viens de l'installer ce matin, donc je n'ai pas beaucoup de recul. En ce qui me concerne, il me convient à priori, car les notes sont en markdown, et, bien que ce soit un peu caché, il semblerait qu'on puisse hiérarchiser les notes.

Quand aux desiderata du posteur :

• on peut exporter des notes, mais apparemment juste une à la fois,
• il y a un menu d'importation de notes Evernote,
• on peut chercher dans le corps des notes,
• tri alphabétique ou par date,
• il y a des boutons de mise en forme,
• pas de version pour mobiles, mais prend apparemment en charge ownCloud et NextCloud.

Je n'ai pas encore eu le temps de faire le tour de l'application, ni de faire des tests poussés, donc ce que j'ai écris est à prendre avec des pincettes.

Zelbinium, la programmation ludique

Le site à été un peu modifié, surtout la homepage, pour fournir un meilleur aperçu, dés la première page, de ce en quoi consiste le projet. Il peut être nécessaire de recharger la page (CTRL-F5) pour voir les modifications…

Zelbinium, la programmation ludique

Salut,

Salut !

Tu as toute mon oreille, mais pour commencer, il n'y a pas de code sur la doc (allé jusqu'à la section 4). Un exemple ? Comment ça s'articule ? Regarder un long main.js n'aide pas, et voir des fichiers .xls n'ai pas encourageant.

Le code des exemples se trouvent dans les repository dont on trouve les liens sur la homepage. Cependant, ayant fait peu de Java/JavaScript/PHP, et c'était il y a longtemps, il y a probablement moyen de rendre le code des exemples plus compréhensible. C'est typiquement le genre de retour que j'aimerais avoir de la part de personnes développant dans l'un de ces langages.

J'ai ajouté unes petite section sur la structure d'une application basée sur le toolkit Atlas. Et c'est des fichiers .xsl, pas .xls :-), mais j'y reviendrais plus tard.

Ces infos importantes que je cherchais apparaissent tard (section 2): c'est pour écrire des SPA, il y a un binaire C++, on doit qd même avoir node.js (aïe, mais voyons), l'interface est en fait Électron (…mmh. Autant dire qu'on peut envoyer sur Électron facilement), il y a un client et un serveur.

Je ne voulais pas être trop technique dés la première page ; ceci dit, j'y parle déjà de SPA. Quant au fait qu'il y ai un binaire C++ (en fait, il y en a même plusieurs), c'est juste pour justifier certains choix en terme de packaging, dont l'utilisation de Node.js. En outre, le serveur web est actuellement basé sur Node.js.

Le problème, c'est que je ne connais actuellement pas suffisamment les outils entourant PHP ou Java pour, d'une part, packager le toolkit, surtout les binaires, juste en utilisant les outils propres à chaque langage, et, d'autre part, mettre en place un serveur web sans procédure d'installation compliquée. C'est pour cela que j'utilise Node.js pour le serveur web, et le package manager de Node.js, à savoir NPM, pour packager le toolkit. Mais, à terme, Node.js ne sera plus nécessaire pour les bindings Java et PHP (et les autres langages qui seront pris en charge à l'avenir). Évidemment, pour le binding Node.js, Node.js sera toujours requis, puisque c'est la finalité de ce binding…

Avant d'utiliser Electron, je m'appuyais sur CEF (et même avant cela, pour ce qui n'était encore que les prémisses de ce qui allait devenir le toolkit Atlas, XULRunner), mais Electron est beaucoup plus facile à déployer que CEF, et plus populaire. J'aurais aussi pu utiliser les composants dédiés à l'affichage de contenus web de bibliothèques comme GTK(+)/Qt/wxWidget/…, mais le déploiement aurait aussi posé problème. À terme, Electron sera mis en œuvre de façon à ce que le développeur ne remarquera même pas que c'est ça qui est utilisé. Déjà maintenant, le développeur n'interagit pas directement avec Electron…

Quant à l'architecture client/serveur, c'est ce qu'il y a de plus simple pour faire communiquer Electron ou le serveur web, qui est basé sur Node.js, avec un logiciel Java ou PHP. Bien qu'il soit intéressant de pouvoir garder cette configuration, la communication se fera peut-être, à terme, également via d'autres canaux…

Je n'ai pas compris si on édite les fichiers xls. Perso, e n'ai jamais approché xlst, je t'invite à expliquer un peu plus dans ta doc.

Comme dit, c'est XSL(T), pas XLS(T); rien à voir donc avec le format Microsoft :-).

En fait, j'aurais pu utiliser un autre moteur de template, comme ceux utilisés dans certains framework JavaScript, mais l'avantage avec XSL, c'est que c'est implémenté dans la plupart (totalité?) des navigateurs web graphique (et dans Electron), donc la transformation est réalisée coté client, en n'ayant rien à installer, tout en pouvant être réalisée coté serveur si nécessaire.

Le principe est de créer un arbre (ce qui est facilité avec l'objet Tree du toolkit Atlas) contenant les données à afficher, et de générer le HTML à afficher dans le navigateur/Electron en appliquant une feuille de style XSL sur l'arbre en question. La structure de l'arbre est totalement libre ; on organise les données absolument comme l'on veut. Si les données sont issues d'une base de données, la structure de l'arbre reflète généralement celle de la base de données. Maintenant, bien que XSL ne soit pas très populaire, la documentation sur le sujet ne manque pas, écrites par des personnes bien plus compétentes sur le sujet que moi. Cependant, s'il y a des points précis qui ne sont pas clairs dans les fichiers XSL fournis avec les exemples, je les expliciterais bien volontiers.

Pas clair pour moi: est-ce que le site a été écrit avec ? Y a-t-il une sorte de routeur (pour avoir de belles urls) ? Dans la démo le filtre est "statique", on doit appuyer sur entrée, est-il possible d'en avoir un dynamique ? (type select2, ajax-based)

Le site est basé sur un CMS qui se contente de servir des pages écrites en markdown.

Il n'y a pas de routeur. D'après ce que j'en ai compris, cette notion de routeur est surtout associée à l'architecture MVC, mais comme je n'ai pas approfondi le sujet, ma compréhension de la chose est très parcellaire. En tout cas, je n'en ai pas vu l'utilité, donc cela n'est pas implémenté, tout en n'excluant pas la possibilité d'une implémentation future, le jour ou j'en aurais compris tout les tenants et aboutissants.

Honnêtement, j'ai fait au plus simple, mais avoir un filtre dynamique devrait déjà être possible. Cependant, je réfléchis à une solution ou le filtre ne se déclencherait pas en cours de saisie, mais un court délai après que l'utilisateur ai saisi le dernier caractère.

Dans la démo j'ai cliqué sur Create, j'aurais bien eu un bouton retour (pas d'intégration avec le navigateur ?), j'ai mis du tps à voir Cancel, tout en bas. Dans un TodoMVC généralement on peut marquer une tâche comme faite, pas vu ici.

Je n'ai pas trop compris l'histoire de l'intégration au navigateur. Je suis d'accord que la démo n'est pas très ergonomique, mais mes compétences en HTML et CSS ne me permettent de faire guère mieux (contributeu(rs/ses) bienvenu(e)s…). Mais attention, la démo en ligne n'est pas celle du TodoMVC. À l'époque où j'ai commençais à écrire une démo, je ne connaissais pas le projet TodoMVC. J'en ai donc écris une en m'inspirant vaguement d'un truc que j'ai trouvé sur le web. Je n'ai écrit les versions de l'application TodoMVC que plus tard, pour que les gens puissent avoir un élément de comparaison (ce qui est le but du projet TodoMVC), mais je ne voyais pas l'intérêt de la mettre en ligne, vu qu'elle fait exactement ce que font les version présentes sur le site du projet TodoMVC et dont on peut facilement voir une démonstration en ligne…

Je vais regarder et viens donner des nouvelles dans un moment :)

Merci déjà de ce premier retour, et je suis bien sûr preneur de tout autre à venir…

ps: ah mais oui, le "hide descriptions" est dynamique lui ! J'aurais bien vu un filtre dynamique, de suite ça claque plus.

J'ai spécialement mis cette case à cocher pour que justement on comprenne que la page n'est pas régénérée à chaque action. C'était plus simple à mettre en œuvre que le filtre dynamique, mais je vais réfléchir à l'implémentation de ce dernier.

Zelbinium, la programmation ludique

Dans ton message, la première ligne de ton code c'est :

<ul>

Il faut simplement la remplacer par :

<ul style="letter-spacing: normal;">

(l'attribut avant le > fermant, pas après…).

C'est le plus simple. Dans ce cas de figure, passer par une classe n'apporte vraiment pas grand chose…

Zelbinium, la programmation ludique

Le problème, c'est que le code ci-dessus est imbriqué dans un div sur lequel est appliquée une classe CSS nommée pure-g-r. Or, cette classe, définie dans https://cdnjs.cloudflare.com/ajax/libs/pure/0.3.0/pure-min.css, fixe letter-spacing à -.31em, d'où l'apparence du texte. Une solution serait de placer un attribut style="letter-spacing: normal;" directement dans le code ci-dessus, par exemple dans l'élément ul, ou alors de définir dans un fichier CSS une classe définissant cette même propriété et de l'appliquer à ce même élément ul. Je suis plutôt un béotien en matière de CSS, donc je ne garantis pas que ce soit la bonne façon de procéder pour résoudre ce genre de problème…

Zelbinium, la programmation ludique

M'est avis que Zobzob a quand même de de bonnes chances de se réveiller à temps, parce que l'araignée, aussi maligne soit-elle, n'a absolument aucun repère pour pouvoir suivre précisément la bonne trajectoire. Sauf pour le dernier, elle doit parcourir chaque segment, soit en visant un point situé à une certaine distance de son coin le plus proche, soit en suivant un angle déterminé. Je n'ai pas fait le calcul, mais, l'un comme l'autre ont l'air d'avoir des valeurs difficiles à suivre au jugée. Pas sûr qu'elle parvienne à suivre la trajectoire en restant dans la marge d'erreur lui permettant d'arriver à temps. Ceci dit, si elle est équipée d'un télémètre laser, par exemple, c'est tout à fait jouable…

Zelbinium, la programmation ludique

Bien sûr que si, sauf que ce savoir, je l'ai acquis et je m'en sers en-dehors du cadre de Marp (comme, par exemple, la rédaction de contenus pour ce site), alors que le savoir que j'aurais à acquérir pour me servir d'Impress ne me servira que pour Impress, ou, au mieux, pour d'autres logiciels du même type (PowerPoint ?)…

Zelbinium, la programmation ludique

En ce qui la coloration syntaxique, ça a fonctionné out of the box chez moi. Il devine même le langage la plupart du temps.

Zelbinium, la programmation ludique

En fait, Impress a une transition qui permet de faire apparaître les éléments d'une liste l'un après l'autre, mais j'ai dû chercher sur le Web, et même avec cette explication, en partie parce qu'elle portait sur la version anglaise de Impress alors que j'ai la version française, j'ai du m'y reprendre à plusieurs fois avant de réussir. Ça m'a presque pris plus de temps que de programmer mppq.

Zelbinium, la programmation ludique

Entre un logiciel que, je cite, «on a besoin d'apprendre à utiliser», et un logiciel qui m'a permis d'aboutir au résultat désiré sans avoir rien à apprendre (markdown, je connaissais déjà, et HTML/CSS, sans le pratiquer énormément, j'en connaissais suffisamment pour obtenir le résultat désiré), appelle ça un problème entre la chaise et le clavier si tu veux, mais moi je préfère le logiciel qui me permet d'obtenir le résultat désiré sans avoir rien apprendre.

Zelbinium, la programmation ludique

Je projette de créer une startup pour supplanter Google, donc je m'entraîne au traçage.

Plus sérieusement, c'est juste parce que http://q37.info/s/w/marp, c'est plus facile à retenir que http://yhatt.github.io/marp/ (sachant que http://q37.info/ est un site dont je maîtrise le contenu).

Zelbinium, la programmation ludique

J'étais d'abord parti sur un script bash, à coups de awk, sed et consorts, donc quelque chose qui se lance de la ligne de commande. N'ayant rien trouvé (je n'ai pas non plus cherché durant des plombes), quitte à devoir programmer quelque chose, autant le faire dans le langage avec lequel je suis le plus efficace, à savoir le C++. Personnellement, ça ne me dérange pas de lancer un utilitaire en ligne de commande, d'autant que, pour mppq, c'est à ne faire qu'une seule fois, juste avant de générer le PDF. Et j'ai juste mis mppq à disposition au cas où il y en aurait qui serait dans la même situation que moi.

Ceci dit, c'est clair que ce serait plus élégant si on pouvait lancer la fonctionnalité directement à partir de Marp. Techniquement, ça ne serait pas trop difficile à mettre en place, et je m'en occuperais volontiers, mais cela compliquerait énormément l'installation du logiciel, et donc son packaging. C'est pour cela que je ne le propose même pas, ayant la quasi-certitude que le responsable de Marp refuserait, et à raison, d'autant plus qu'il ne doit pas être compliqué de développer l'équivalent de mppq en JavaScript, ou en un langage qui ne complexifierait pas l'installation du logiciel.

Quant à réaliser ce développement moi-même, non merci. J'ai mppq qui me satisfait, donc cela ne m'apporterait rien et, ayant déjà eu à réaliser des développement dans divers langages, dont encore récemment Java, JavaScript et PHP, j'évite autant que faire se peut de renouveler l'expérience, hors C++ évidemment…

Zelbinium, la programmation ludique

Comme indiqué plus haut, c'est en effet une application Electron, qui est émanation de l'éditeur Atom (Electron s'appelait d'ailleurs Atom Shell avant d'être rebaptisé), de la même manière que XULRunner était une émanation de Firefox (oui, ça date…). VSCode, c'est comme si Microsoft avait développé Edge en s'appuyant sur XULRunner (abstraction faite de la licence…).

En fait, Electron est une application Node.js ; vous trouverez le fameux répertoire node_modules, propre à npm, le gestionnaire de paquet de Node.js, dans le répertoire dans lequel est installé Electron. On peut d'ailleurs utiliser n'importe quel paquet npm avec Electron. Il suffit, après installation desdits paquets, de lancer un electron-rebuild fournit par le paquet du même nom.

Après avoir utilisé Chromium Embedded Framework, j'utilise maintenant Electron pour développer les interfaces desktop de mes applications. Parce que Electron est plus complet et les application basées dessus beaucoup plus simples à installer, surtout sur macOS. C'est dû à la manière, identique pour toute les plateformes, de lancer une application Electron. Il suffit d'un fichier JavaScript et d'un package.json référençant ce fichier (avec quelques petites choses en plus). On lance alors Electron en passant en paramètre le répertoire contenant le package.json en question, ou alors on lance Electron sans paramètre, et on drag&drop sur la fenêtre qui s'ouvre le dossier correspondant au dit répertoire.

Comme c'est du Node.js, c'est donc du JavaScript au départ, mais on peut parfaitement écrire tout le code en C++ (on ne se refait pas…) grâce au mécanisme des addons de Node.js. Du coup, je l'utilise autant pour les logiciels propriétaires de mes clients, que pour les Logiciels Libres que je développe. Et tout ça, dans un cas comme dans l'autre, dans le strict respect des licences, puisque Electron est diffusé sous licence MIT…

Zelbinium, la programmation ludique