Claude SIMON a écrit 539 commentaires

J'en suis parfaitement conscient. Ce n'est pas de la mauvaise volonté, c'est que je ne suis vraiment pas doué pour rédiger des documentations, ou pour communiquer sur mes projets de manière générale, comme le montre d'ailleurs les journaux que j'ai publiés, ainsi que le contenu de mon site Web.
Par ailleurs, ce genre d'application me permet d'améliorer le framework sur lequel il s'appuie, et que j'utilise, en tant que développeur freelance, pour les développements que je réalise pour mes clients. Donc, tout le travail de codage réalisé pour cette application me permet de proposer à mes clients du code de meilleur qualité et développé plus rapidement, ce qui est bénéfique, notamment financièrement, et pour moi, et pour le client. Par contre, tous les à-coté de ce genre de projet, comme la rédaction de documentation, sont, du point de vue financier, une pure perte de temps.
Ceci dit (ou plutôt écrit), cela ne m'empêche pas d'essayer de communiquer tant bien que mal sur mes projets, justement en publiant ce genre de journaux, dont certains commentaires contiennent d'intéressantes pistes d'améliorations. Ainsi, j'ai travaillé, suite au dernier journal, à l'amélioration du packaging de l'application, ce qui facilite son déploiement sous GNU/Linux et Windows (pour OS X, c'est loin d'être encore ça). J'ai prévu, en plus d'améliorer l'application, de mettre l'accent sur la documentation pour le prochain journal. Mais cela sera forcément très incomplet, vu l'ampleur de la tâche, mais il faut un début à tout.

Pour nous émanciper des géants du numérique : Zelbinium !

J'ai oublié de préciser que l'on peut :
- modifier le contenu d'une fiche en cliquant sur l'entrée qui lui correspond dans la liste,
- modifier le contenu d'un champ en cliquant sur son libellé,
- modifier le contenu d'une entrée d'un champ multi en cliquant sur son contenu.

Accessoirement, on peut également afficher un A propos… avec Ctrl+Shift-A. Sur certains navigateurs, cela provoque l'affichage d'une nouvelle page ; il faut alors revenir sur la page de l'application. Je n'ai pas (encore) trouvé de combinaison de touches qui fonctionnent pour tous les navigateurs, ou (mieux) le moyen d'inhiber le comportement par défaut du navigateur…

Pour nous émanciper des géants du numérique : Zelbinium !

Bon, j'ai finalement profité d'une baisse momentanée d'activité sur le serveur pour rapidement mettre la version corrigée en place…

Pour nous émanciper des géants du numérique : Zelbinium !

Merci pour le signalement.

Le bug est corrigé, mais il faudra attendre le déploiement de la prochaine version de l'application pour profiter de la correction.

Quand à l'option de déconnexion, elle est absente parce que je ne me suis pas encore pris le temps de l'implémenter…

Pour nous émanciper des géants du numérique : Zelbinium !

Le document sur le site de Stroustrup visait simplement à établir, de manière indiscutable je crois, ce pour quoi les exceptions C++ ont été conçues. Maintenant, faut-il ou non les utiliser, c'est un autre débat.

Je veux bien croire que, dans certains domaines, comme ceux des jeux vidéos, de l'embarqué, du développement de drivers, etc. il y ai des contraintes qui poussent à éviter les exceptions, mais ce qui est vrai pour ces domaines-ci ne l'est pas forcément pour les autres, les contraintes n'étant pas les mêmes…

Quand au lien Google, ma compréhension de l'anglais est certainement perfectible, mais il me semble quand même qu'ils écrivent (traduction très libre) :

• que les avantages des exceptions C++ l'emportent sur leurs inconvénients,
• qu'ils n'utilisent pas les exceptions C++ pour leur nouveaux projets parce qu'ils ont beaucoup de code ne s'appuyant pas sur les exceptions et que :
  • mélanger code avec/code sans exceptions est problématiques,
  • réécrire le code sans exceptions pour le rendre tolérant aux exceptions est trop coûteux,
• que s'ils recodaient tout from scratch, ils utiliseraient probablement les exceptions…

Donc, au final, ça m'a plutôt l'air d'un plaidoyer en faveur des exceptions C++…

Pour nous émanciper des géants du numérique : Zelbinium !

En l'état, pas grand chose ; on peut créer des fiches avec des champs textes, et réorganiser les champs d'une fiche, ainsi que les entrées d'un champs, par drag & drop, et c'est à peu prés tout. Des fonctionnalités seront ajoutées petit à petit, et feront l'objet de publications ici même.

En attendant, cette application fait office de proof of concept. Elle permet d'étudier la faisabilité, entre autres :
- de coder entièrement et uniquement en C++ une interface basée sur des technos Web,
- d'utiliser un seul et même code (C++) pour l'interface Web et pour l'interface native d'une application,
- d'offrir la possibilité de modifier entièrement l'apparence d'une application sans avoir à intervenir sur son code source, uniquement en modifiant des fichiers XSL.

Pour nous émanciper des géants du numérique : Zelbinium !

Je ne vois pas ce à quoi le terme dessus fait référence, et, quant au lien, je ne vois rien dans la biographie de l'auteur qui donne le moindre poids à ses écrits en général, et ces écrits en particulier. Par contre, j'ai trouvé ceci, dont B. Stroustrup lui-même est l'un des auteurs. Je pense que les deux premiers paragraphes de l'introduction sont on ne peut plus clairs quant à l'usage pour lesquels les exceptions C++ ont été conçues…

Pour nous émanciper des géants du numérique : Zelbinium !

Pour ceux qui sont intéressés par la suite, notamment, comme annoncé, l'interface Web, avec une démonstration en ligne, ça se passe ici.

Pour nous émanciper des géants du numérique : Zelbinium !

Donc, j'ai choisi la solution la plus facile et la plus rapide, à savoir de placer ces fichiers dans le dépôt.

La plus facile pour toi, et la plus rapide pour toi. Le problèmes que tu évoques est exactement celui résolu par les autotools ou autre framework du genre. Sans avoir à mettre des fichiers générées dans le VCS.

Le reste, ce n'est que l'adaptation aux particularités des différentes plateformes sur lequel il peut être lancé. Qu'est-ce qui sort donc de l'ordinaire, et par quoi peut-on le remplacer qui soit plus conforme aux standards en la matière ?

Tu pourrais simplement l'omettre si tu utilisais un des framework cités. Comme ça, queluqu'un d'autre que toi n'aurait pas à se former à ton outil. Tu trouveras ça inutile, mais c'est ce que je te disais plus haut : les solutions que nous t'évoquons sont utiles pour tout le monde, pas que pour toi.

J'ai l'impression que tu penses que mes Makefile sont plus sophistiqués qu'ils ne le sont réellement. Mes scripts de générations prennent en compte juste la nature du binaire à générer (exécutable ou bibliothèque) et la liste des fichiers sources. C'est tout. Pas de dépendances à gérer (il y a CEF maintenant, mais c'est une exception, et cela ne concerne qu'un seul Makefile). A nature de binaire identique, la seul chose qui change d'un Makefile à l'autre, c'est le tout début, qui contient la liste des fichiers source. Tout le reste est identique.

Si, d'aventure, j'avais effectivement fait le choix d'utiliser autotools et/ou consorts, au lieu de placer les Makefile générés dans le VCS, et bien j'y aurais placé les fichiers 'source' d'autotools et consorts, qui auraient également été générés, à l'instar des Makefile. Donc, cela n'aurait fait que déplacer le problème, si problème il y a, avec, en outre, une complexification induite par l'utilisation d'autotools et/ou consorts.

La principale différence avec XSL (mis à part que XPP n'est de loin pas aussi puissant que XSL), c'est que les directives XSL doivent être placées dans un fichier disjoint de celui qui contient le XML sur lequel on va appliquer ces directives, alors que les directives XPP, quant à elles, sont directement placées dans les fichiers XML sur lesquels elles portent.

Comme les feuilles de style « intégrées » (traduction pourrie de "embedded") ? https://www.w3.org/TR/xslt#section-Embedding-Stylesheets
Tu ne t'intéresses juste pas à ce qui existe, et c'est ce qui dérange un peu ici, je pense.

Je ne connaissais pas. J'ai un peu regardé, pas beaucoup, car il semble que ce ne soit implémenté que dans les navigateurs. Or, j'ai besoin, d'une part, de pouvoir utiliser ce mécanisme dans mes propres logiciels (pour l'appliquer sur les fichiers de configuration de mes logiciels), et, d'autre part, de pouvoir mettre ce mécanisme en œuvre via un utilitaire en ligne de commande. Mes deux utilitaires (sablotron et xsltprocess) ne semblent pas l'implémenter, et je n'ai pas trouvé d'utilitaire ou de bibliothèque qui implémente ce mécanisme. Donc, aujourd'hui, connaissant l'existence des embedded stylesheet, si j'étais confrontés aux même besoins que ceux qui m'ont poussés à développer XPP, je serais obligé de faire le même choix qu'à l'époque, à savoir développer ma propre solution.

Ceci dit, je n'ai jamais écrit que je ne m’intéressais pas aux solutions alternatives, mais que je n'utilisais pas ces solutions (forcément, puisque j’utilise mes alternatives), et c'est bien ce dernier point qui dérange. Comme déjà évoqué, si je ne m'étais pas intéressé à ce qui existe, je n’utiliserais pas XML, mais mon propre langage de balisage…

Utiliser gettext aurait impliqué un travail de codage supplémentaire, que j'économise avec le système que j'utilise.

Travail économisé une fois pour toi. Travail qui sera à fournir pour chaque personne qui souhaite s'intéresser à ce travail. C'est donc complètement inintéressant en terme de temps pour quiconque d'essayer de contribuer ou de s'intéresser à ton travail.

Je l'ai développée pour répondre aux besoins d'un client. Ce dernier devait pouvoir stocker des dates classiques, mais aussi approximatives.

Ah, intéressant, je n'avais pas vu cette fonctionnalité.

Ta réaction à bibliothèque DTE est typiquement celle que je ne comprends pas. Parce certains ne voient pas l'utilité de réimplémenter une telle bibliothèque, ces derniers décrètent que c'est une erreur, sans chercher à comprendre les motivations derrières.

Le problème c'est que je ne vais pas chercher des heures à comprendre ce que fait ta bibliothèque si j'ai l'impression qu'elle ne m'apporte rien. Pas de description, etc, je laisse tomber. Alors encore, si elle s'intégrait bien à l'existant, et que c'était utilisable en dehors de tout ton framework, pourquoi pas, mais je n'ai pas l'impression : tout semble très imbriqué, du coup je n'ai même pas espoir que cette fonctionnalité intéressante puisse être utilisée ailleurs. (déjà je fais du C, donc c'est niet)

Je comprends tout à fait que tu ne veuilles pas te plonger dans le code de cette bibliothèque (j'aurais la même réaction à ta place), mais alors, pourquoi ne pas me laisser le bénéfice du doute, c'est-à-dire de considérer que, peut-être, après tout, j'avais de bonnes raisons d'implémenter cette bibliothèque, au lieu de considérer d'office que c'était une erreur ?

on ne comprend pas, donc, au lieu d'approfondir, ou de demander des éclaircissement au développeur si l'on a pas envie de se plonger dans le code (ce que je comprends tout à fait), on se répand en généralités sans rapports pour discréditer le framework en question.

Essaye de penser que tu n'es pas au centre du monde : malheureusement, ton « standard » n'est pas le standard, et c'est en général plutôt à toi de t'adapter aux autres que l'inverse.

Et je ne dis pas ça pour t'embêter, mais juste pour que tu remettes les pieds sur terre et te rende compte que personne ne s'intéressera à ton travail si tu le présente et le développe ainsi. Ce n'est peut-être pas ce que tu cherches, mais tu disais vouloir au moins avoir des retours, et je t'explique pourquoi je pense que tu n'en auras pas.

Je ne comprend pas le rapport de ta réponse avec l'extrait de mon intervention que tu cites. Encore une fois, je n'ai jamais demandé à qui que ce soit de s’intéresser à mon framewok. Tu dis que j'ai demandé des retours ; je ne m'en souviens pas, et je ne vais pas relire l'ensemble des commentaires de ce journal, donc je vais supposer que c'est vrai, mais, ça serait, à priori, vu ce que j'avais à l'esprit en rédigeant ce journal, au sujet des particularités du logiciel, pas de la manière dont elles sont implémentées. Je pense qu'il est préférable d'avoir un bon logiciel, fût-il réalisé avec des solution non-standards, qu'un logiciel inutilisable, fût-il réalisé avec des solutions standards…

je n'aurais pas développé ce framework si je pouvais développer aussi vite et aussi bien avec d'autres outils.

Tu sais, tout programmeur a un jour pensé à faire ça. Puis on a appris le principe de « standard » : ça n'est pas toujours parfait, ça ne fait pas exactement ce qu'on veut, mais c'est ce qui permet de travailler en commun. Avec ta méthode, désolé mais tu travailleras toujours tout seul.

Peut-être pas, si c'est mes solutions qui deviennent les standards :-). Mais, je le concède, c'est mal parti, d'autant plus que ce n'est pas mon but à ce jour.

Et, en fait, le problème avec les standards, outre, qu'effectivement, cela ne permet pas toujours de réaliser ce que l'on veut, c'est surtout, et c'est bien plus grave, que cela ne permet pas toujours de réaliser ce que le client veut.

Quel est le problème de travailler seul ? Les clients ne se sont jamais plaints de mes délais (une fois qu'ils ont assimilé qu'on ne peut pas leur livrer le produit pour avant-hier), et j'ai toujours pu intégrer mes développements à l'environnement de production du client, quel qu'il soit.

De manière générale, les clients veulent un logiciel vite et bien fait. Que ce logiciel soit réalisé par une seule personne ou par plusieurs, (généralement, moins il y a de personnes impliquées, moins c'est cher, donc ils préfèrent), en utilisant ou non des solutions standards (je parle là des solutions de développement, pas des formats de fichiers), généralement peu leur chaut.

Bon courage quand même dans ta voie

Merci !

---

Développer un logiciel n'est pas trivial. Pour cette raison, la majorité des développeurs utilise les solutions qu'ils considèrent (à tord ou à raison) les plus faciles à utiliser. Pour beaucoup, apparemment, notamment au vu des commentaires ici, il s'agit des solutions 'standards'. Bien que, moi aussi, j'utilise certaines solutions standards (XML est peut-être décrié, mais c'est néanmoins un standard ; ce n'est pas une de mes inventions), il se trouve que j'ai été amené à développer mes propres solutions parce que celles existantes ne me convenaient pas. Comme toi et certains des intervenants ici n'ont pas manqués de le souligner, c'est une démarche rare. Cependant, elle n'est pas unique. Et heureusement, sinon l'écosystème informatique serait bien pauvre. Toutes les solutions considérées comme 'standards' aujourd'hui ne l'ont pas été à leurs débuts, et se sont certainement vu opposer les 'standards' de l'époque. Heureusement, cela n'a pas découragé les concepteurs de ces solutions, sinon elles ne seraient pas considérées comme les 'standards' d'aujourd'hui…

Contrairement à ce que certains pensent ici, et je me demande bien sur quel base, je n'essaie pas de promouvoir mon framewok. Je ne fais que présenter quelques logiciels que je développe, à l'instar de celui présenté dans ce journal, qui ont comme particularité d'être tous basés sur mon framework (c'est simplement un fait technique), ce qui fait qu'ils ont certains points communs (manière de gérer les traductions, les arguments de la ligne de commande, possibilité de placer des directives XPP dans les fichiers de configuration…) qui les distinguent des autres logiciels. Mon but premier est de produire des logiciels qui satisfassent ses utilisateur (et, parmi ces utilisateurs, le plus exigeant de tous : moi) , et mon framework est un outil essentiel pour parvenir à ce but. Si, parmi ces utilisateurs, il y a des développeurs qui estiment que certaines particularités de ces logiciels, et donc, par conséquent, du framework sur lequel ils sont basés, sont suffisamment intéressantes pour contrebalancer le fait qu'il ne s’appuie pas sur des solutions 'standards', alors peut-être que, de concert, on pourra mettre en place les éléments qui lui permettront de gagner en popularité. Ou pas.

Pour nous émanciper des géants du numérique : Zelbinium !

De ce que je sais, les exceptions ont été conçues pour faciliter la gestion des erreurs, quelles qu'elles soient. Je ne vois pas en quoi la nature de l'erreur change quoi que ce soit, d'autant plus lorsqu'elle est basée sur ces notions d'attendu/inattendu, pour autant qu'il y ai une définition précise et univoque des ces notions. En outre, la nature d'une même erreur peut varier selon le contexte. Reprenons l'exemple ci-dessus, en supposant que l'interface soit une interface Web. On peut envisager que, lors de la validation du formulaire, avant son envoi, un script JS soit exécuté pour vérifier si le champ est bien rempli, et n'envoyer le formulaire qu'à cette condition, ou, sinon, signaler à l'utilisateur qu'il lui faut remplir ce champ. Au niveau du code C++, le contenu du champ ne peut, théoriquement, jamais être vide, mais c'est une bonne pratique que de le vérifier tout de même, on ne sait jamais. Du coup, si cette erreur se produit tout de même (il peut y avoir un bug dans le code JS), erreur attendue ou inattendue ?

Pour nous émanciper des géants du numérique : Zelbinium !

pas d'exception

Ça, ça ne va pas changer, je déteste les exceptions en C++. Et je ne vois pas bien où je pourrais en mettre.

J'ai un jour dû écrire un logiciel en C de haute disponibilité, qui devait tourner 24h/24, 7j/7, sur un PC industriel équipé d'un watchdog, histoire qu'il reboot automatiquement si mon logiciel devait planter. Du coup, la plupart de mes fonctions comportaient pléthore de if dont l'unique objet était de remonter à la fonction appelante les erreurs détectées dans les fonctions appelées. Je trouvais que cela rendait le programme presque illisible, car il était difficile de distinguer parmi tous ces if lesquels étaient 'algorithmiques', et lesquels étaient dédiés à la gestion d'erreurs.

Pour améliorer cela, j'ai implémenté en C, en m'appuyant sur la bibliothèque setjmp, un mécanisme, sous forme d'un jeu de macros, dont je me suis rendu compte plus tard qu'il s'apparentait aux exceptions C++, que je ne connaissais pas à l'époque. D'ailleurs, quand je suis passé au C++, j'ai réimplémenté ces mêmes macros en m'appuyant sur les exceptions, au lieu de la bibliothèque setjmp. J'utilise toujours ces macros pour la gestion des erreurs, et, bien que, par défaut, elles s'appuient sur les exceptions C++, on peut, à l'aide d'une option de compilation, basculer sur la bibliothèque setjmp, pour une utilisation dans un environnement où les exceptions ne seraient pas disponibles.

Quand ma production consistait essentiellement en utilitaires en ligne de commande, l'exception était interceptée grosso-modo dans le main pour afficher un message d'erreur. Par contre, depuis que j'écris des daemon, l'exception est interceptée à la fonction racine du thread dans lequel elle est lancée, pour afficher un message d'erreur dans un log, voire relayer ce message au client, avant de terminer le thread en question. Mais le thread principal continue toujours de tourner, ainsi que les autres threads, prêts à répondre aux requêtes des différents clients.

Pour les interfaces graphiques, l'exception est interceptée dans la boucle de gestion des événements. Par exemple, si l'utilisateur valide un formulaire en oubliant de remplir un champ obligatoire, une exception est lancée qui remonte jusqu'à cette boucle, affiche un message signalant la nécessité de remplir le champs oublié, et ensuite laisse tout loisir à l'utilisateur de remplir le champ en question, comme s'il ne s'était rien passé.

En ce qui me concerne, les exceptions (ou la setjmp en C) facilitent grandement le développement de logiciels…

Pour nous émanciper des géants du numérique : Zelbinium !

J'ai présenté un logiciel dont j'ai commencé le développement, en mettant en exergue quelques caractéristiques. Pour ceux que cela intéresse et qui voudrait en savoir plus, je répondrais volontiers à leurs questions. Quant à ceux qui prétendent qu'il y a des outils plus adaptés que ceux que j'utilise pour coder ce genre de logiciel, je veux bien en débattre, mais il faudrait qu'il y déjà ai matière à, c'est-à-dire des éléments concrets et pas seulement des généralités ; je ne vais pas passer en revue toutes les solutions qui existent dans le domaine pour tenter de deviner ce à quoi ils font référence…
C'est tout ce qu'il y a à comprendre dans ce journal et mes commentaires. Pour ceux qui ont compris autre chose, j'en suis désolé pour eux, mais je n'y peux rien…

Donc, non, je ne veux pas que l'on me pose des questions techniques ; je signifie seulement que, pour qu'il y ai débat sur la pertinence de mon code, cela ne peut se faire sans éléments techniques. Et les commentaires dans le code, c'est généralement pour en faciliter la compréhension, et certainement pas pour y placer un argumentaire pour tenter de convaincre de la supériorité technique dudit par rapport à d'autres solutions (ceci dit, tu y mets ce que tu veux, dans les commentaires de ton code…). Au sujet de la dépréciation de mon code, je ne faisais que reformuler la notion de discrédit évoqué dans un précédent commentaire, qui n'était même pas une réponse à l'un de tiens ; il ne faut pas tout prendre personnellement. Et tu ne m'apprend rien en écrivant que je promeus mal mon code ; j'ai moi-même écrit ici, et à plusieurs reprises, que je ne sais pas communiquer sur mes projets. Et je ne vois pas où j'ai pu ne fût-ce que suggérer que je désirais que les gens investissent quoi que ce soit sur mon code. Et enfin, si je réponds des banalités, c'est uniquement aux questions auxquelles on ne peut faire que ce genre de réponses…

Pour nous émanciper des géants du numérique : Zelbinium !

Il y a une contradiction dans tes propos de manière générale ; d'un côté tu expliques que tu ne pourrais pas être plus efficace avec les autres outils, et de l'autre tu avoues ne pas avoir beaucoup regardé ce qui se fait ailleurs.

Si, j'ai bien regardé ce qui se faisait ailleurs, mais, comme cela ne répondait pas à mes besoins, je n'ai pas utilisé.

Dans la mesure où il existe des tas de frameworks libres de qualité, éprouvés par des milliers de codeurs/applications depuis des années, qui eux aussi se vantent de permettre de faire des applications de qualités rapidement etc…, tu peux comprendre qu'aller se plonger dans ton code pour y trouver d'hypothétiques qualités parce que tu ne peux pas expliquer ce que ton framework apporte par rapport à la concurrence est plutôt rebutant.

Comme je l'ai indiqué dans le pénultième paragraphe de mon précédent commentaire, je comprends parfaitement que l'on ne veuille pas se plonger dans le code de mon framework. Mais alors, pourquoi affirmer que ce framework est globalement nettement moins bon que les autres (bon, il y a des aspect où il est clairement moins bon, notamment en ce qui concerne la documentation) ? Mon framework, j'en ai commencé le codage il y a plus de 15 ans. J'ai regardé tout au long de ces années ce qui se faisait chez la 'concurrence', mais j'ai à chaque fois découvert au moins un aspect rédhibitoire, dont je ne me rappelle plus à ce jour, qui fait qu'au final j'ai continué à utiliser mon framework. Et donc, je ne peux rien dire concernant les autres framework car, contrairement à certains ici, je ne parle d'un sujet que si je le connais suffisamment.

Par exemple tu aurais pu en profiter pour expliquer quelles bibliothèques de dates tu as essayées et en quoi la tienne est meilleure.

Çà fait trop longtemps que je l'ai codée pour me rappeler précisément tout ce qui a entouré sa genèse. Mais, au lieu de la déprécier, pourquoi ne pas avoir écrit "Moi, j'utiliserais telle bibliothèque, qui fait ça, ça et ça ; pourquoi ne pas l'avoir utilisée ?", auquel cas je pourrais répondre, par exemple, que je ne la connaissais pas, qu'elle n'existait pas à l'époque, ou bien encore qu'il lui manque telle ou telle fonctionnalité. Bref, on pourrait enfin avoir un véritable débat…

Pour nous émanciper des géants du numérique : Zelbinium !

On me reproche des abstractions soit-disant inutiles dans mon framework, mais les commentaires eux-mêmes ne portent essentiellement que sur des abstractions ; c'est difficile d'argumenter dans ces cas là. Il y a néanmoins quelques points concrets qui sont évoqués auxquels je vais tenter de répondre.

Les noms abscons. Je m'en suis justifié plus haut. Et surtout, je ne pense pas que le problème vienne des noms en soi, mais plutôt de l'absence de documentation au sujet des binaires concernés. Je n'aime pas rédiger de la documentation, car je suis très mauvais en cela. Mais j'essaie quand même d'en écrire, tant bien que mal, comme en témoigne le contenu de mon Wiki.

Les fichiers générés contenus dans le VCS ; je pense que tu entends par là le contenu du dépôt mercurial. Les seuls fichiers générés qu'il contient sont les Makefile, et les .h contenant les APIs des backends. Ces fichiers sont générés à l'aide de scripts stockés sur ma machine de développement principale, celle avec laquelle je travaille la plupart du temps. Si je ne mettais pas ces fichiers dans le dépôt, je serais obligé de les régénérer sur chacune des mes autres machines de travail, et donc d'installer ces scripts et leur environnement d'exécution sur ces machines, ce qui est loin d'être évident vu la diversité des machines (il y a là des machines sous Windows, Linux, MacOS, Android et même Maemo…). Donc, j'ai choisi la solution la plus facile et la plus rapide, à savoir de placer ces fichiers dans le dépôt. Il y a aussi un .xml correspondant à l'API d'un backend. A vrai dire, celui-ci n'y a été mis que récemment, à l'occasion de la rédaction de ce journal ; en temps normal, je ne place pas ces fichiers dans le dépôt.

Pour le contenu des Makefile, je ne vois pas le problème, mais je n'y connais à vrai dire pas grand chose sur le sujet. Le cœur du Makefile, qui se situe à la fin du fichier, est tout ce qu'il y a de plus classique (règle de construction du binaire à partir des fichiers objets, règle de construction des fichiers objets à partir des fichiers sources). Le reste, ce n'est que l'adaptation aux particularités des différentes plateformes sur lequel il peut être lancé. Qu'est-ce qui sort donc de l'ordinaire, et par quoi peut-on le remplacer qui soit plus conforme aux standards en la matière ?

xppq. La principale différence avec XSL (mis à part que XPP n'est de loin pas aussi puissant que XSL), c'est que les directives XSL doivent être placées dans un fichier disjoint de celui qui contient le XML sur lequel on va appliquer ces directives, alors que les directives XPP, quant à elles, sont directement placées dans les fichiers XML sur lesquels elles portent. Le principe derrière XPP est le même que celui du préprocesseur C. XSL n'a pas du tout la même approche. A noter que j'utilisais XSL bien avant d'avoir écrit xppq ; je l'ai donc écrit car il répondait à un besoin auquel XSL ne pouvait répondre.

Pour les traductions, je n'utilise pas gettext, car je réutilise le même mécanisme que pour mes fichiers de configuration. Utiliser gettext aurait impliqué un travail de codage supplémentaire, que j'économise avec le système que j'utilise.

Les dates. Je pense que tu te réfères à la bibliothèque DTE. Je l'ai développée pour répondre aux besoins d'un client. Ce dernier devait pouvoir stocker des dates classiques, mais aussi approximatives. Il y a, en effet, certains personnages dont on ne connaît pas avec précision les dates de naissances et/ou de décès. Avec cette bibliothèque, on peut stocker des dates au jour prés, mais aussi seulement au mois, à l'année, à la décennie… prés. Comme le surcoût de cette bibliothèque est négligeable par rapport à celle d'une bibliothèque de gestion de dates classique, j'en ai fait ma bibliothèque standard.

---

Ta réaction à bibliothèque DTE est typiquement celle que je ne comprends pas. Parce certains ne voient pas l'utilité de réimplémenter une telle bibliothèque, ces derniers décrètent que c'est une erreur, sans chercher à comprendre les motivations derrières. Et c'est cette même approche de mon framework en général que l'on retrouve dans les commentaires ; on ne comprend pas, donc, au lieu d'approfondir, ou de demander des éclaircissement au développeur si l'on a pas envie de se plonger dans le code (ce que je comprends tout à fait), on se répand en généralités sans rapports pour discréditer le framework en question.

Quand à ma soi-disant méta-blague, ce n'en est pas une, méta ou non. C'est la réelle motivation qu'il y a derrière mon framework. Je suis un développeur professionnel, et je n'aurais pas développé ce framework si je pouvais développer aussi vite et aussi bien avec d'autres outils. Ceci dit, je suis tout-à-fait prêt à envisager que je me suis fourvoyé, mais, de grâce, appuyez vos écrits avec des exemples concrets ; il s'agit de Logiciel Libre après tout, et les sources sont facilement accessibles (même pas besoin de les télécharger !).

Pour nous émanciper des géants du numérique : Zelbinium !

Je parle d'une hostilité envers mes technos, pas envers moi. Je ne me sens victime d'aucune cabale. Je constate simplement qu'à chaque fois que j'évoque certaines technos, comme XML/XSL(T), ou que j'associe technos Web et C++, on assiste systématiquement à une levée de bouclier, sans que jamais l'on avance le moindre argument valable justifiant cette aversion.

Et effectivement, j'emploie XML/XSL(T) depuis longtemps, bien plus longtemps que ne le suggère les journaux que j'ai publié. J'ai commencé à utiliser XML/XSL(T) en conjonction avec XUL(Runner), ce qui remonte grosso-modo à 2004. A l'époque déjà, et régulièrement depuis, j'ai étudié les alternatives, sans qu'aucune ne s'est révélée à la hauteur de mes attentes (et ceux de certains de mes clients) en comparaison avec XML/XSL(T).

Concernant la tonne de code, c'est l'ensemble de mon framework, dont les technos présentées ici ne représentent qu'une faible partie. Ce framework couvre un large éventail de fonctionnalités, d'où sa taille.

Pour ton exercice, une seule phrase suffit : me faciliter le développement de logiciels de qualité.

Comme je l'ai déjà écrit dans une de mes précédentes réponses, je suis conscient que j'ai de sérieuses lacunes en matière de communication, mais, encore une fois, pour susciter l'intérêt sur un sujet, communiquer mal est toujours mieux que de ne pas communiquer du tout. Et si le logiciel et si mal accueilli, c'est aussi parce qu'il est difficile à déployer avec les package fournis. Comme je l'ai écrit dans une autre réponse, c'est à cause de CEF, sur lequel s'appuie mon logiciel pour l'interface native. Mais je travaille à l'amélioration du packaging.

Je ne veux pas attirer du monde sur mes technos ; je la présente simplement au cas où cela intéresserait des personnes, auquel cas j'échangerais volontiers sur le sujet avec ces dernières. Et pour celles qui trouvent ces technos inadaptées, il n'y a pas de problèmes non plus, je discuterais tout aussi volontiers avec ces dernières de l'intérêt de mes technos.

Pour nous émanciper des géants du numérique : Zelbinium !

C'est tout à fait cela ; tous les logiciels développés à l'aide de cette boîte à outils ont été financés pas mes clients, et je n'en dispose donc pas librement, d'où l'impossibilité des les publier. De ce fait, j'ai commencé, à titre personnel, le développement du logiciel présenté ici. Comme je l'ai indiqué dans le titre, ce n'est que le commencement. Les toutes prochaines versions porteront sur la consolidation des mécanismes de base (version Web, développement de plugins relatifs à de nouveaux types de champs…), ainsi que sur l'amélioration du packaging, afin de faciliter le déploiement du logiciel par toute personne qui s'y intéresse. Puis seront, petit à petit, développées les fonctionnalités qui permettront à ce logiciel de remplir les objectifs que je lui ai fixé, objectifs qui pourront évoluer en fonction des suggestions de ceux qui l'auront testé (ce qui devrait prochainement être facilité par la mise en ligne d'une version de démonstration).

Pour nous émanciper des géants du numérique : Zelbinium !

Je suis en train de développer un Logiciel Libre, que je présente ici à titre de démonstration de certaines technos, en attendant que le logiciel soit suffisamment avancé pour présenter un intérêt en lui-même. Ces technos sont incluses dans un framework, et je compte les réutiliser à travers ce framework (je les utilise d'ailleurs déjà) pour développer d'autres logiciels, ceux de mes clients, mais également des logiciels pour mon propre usage, auquel cas je placerais ces derniers sous licence libre, et ils feront probablement l'objet d'une publication sur ce site, à l'instar de ceux que j'ai déjà publiés.
En publiant ce journal, je n'attends rien en retour, mais s'il y a des retours, je les étudierais attentivement, comme je l'ai fait pour les commentaires publiés jusqu'à présent, et cela quelque soit la nature de ces retours.
Quant à la qualité auquel je fais référence, c'est celle, comme je l'ai déjà écrit, perçue par les utilisateurs de mes logiciels et dont ils me font part au travers de leurs retours. Même si certains autres critères qualitatifs sont importants, ils demeurent néanmoins secondaires face à ceux qui conditionnent la satisfaction des utilisateurs.
Quand aux principes que tu listes, ça correspond, grosso-modo, à ma pratique professionnelle. D'ailleurs, je ne vois pas ce qui, dans ce journal ou ailleurs, suggère que cela puisse ne pas être le cas. Et, plus précisément, j'ai déjà développé pour mes clients et livré des applications qui mettent en œuvre ces technos, et les retours que j'en ai sont excellents. Mais comme je ne peux pas publier ces applications, et que j'ai, en outre, envie de pousser ces technos dans leurs retranchements, j'ai commencé à développer l'application qui fait l'objet de ce journal.
Avec ce journal, et certains autres que j'ai publiés, j'ai remarqué une certaine hostilité envers mes technos, probablement parce qu'elles vont à l'encontre de certains dogmes. Mais, ni dans ce journal, ni dans aucun autre, malgré les tentatives répétées de certains, personne n'a réussi à mettre en défaut mes technos d'une quelconque manière. Tant que cela demeurera le cas, je continuerais à développer et à présenter des logiciels basées sur ces technos, et tant pis pour ceux qui les rejettent. Ce qui ne signifie pas que je ne suis pas ouvert à la critique, car je n'ai pas la prétention d'avoir crée quoique ce soit de parfait…

Pour nous émanciper des géants du numérique : Zelbinium !

Cependant, ma techno permet à tout un chacun de modifier l'interface :
- à l'aide d'un simple éditeur de texte, sans avoir mettre en œuvre d'autres outils (compilateur ou autres…),
- essentiellement juste en connaissant HTML et XSLT/XML ; à défaut, il pourra s’adresser à n'importe quel développeur Web digne de ce nom.

Tu optimise pour le mauvais problème.

Le développeur web, il va préférer faire du web. Il a ses outils, sa communauté, ses navigateurs.

Le développeur natif, il va faire du natif.

Et il y a un troisième type de développeur, dont je suis peut-être l'unique représentant aujourd'hui (j'espère que non), qui veut développer du Web, et du natif, tout en maintenant un seul et unique code commun aux deux (ce qui va faire l'objet d'un prochain journal, comme signalé dans celui-ci).

Le boite qui veut modifier un soft, elle a des développeurs en interne pour faire ca, ou elle sous traite.
Le fait que ca soit modifiable avec un simple éditeur de texte ne change rien au fait que le tooling est très important. Debugger/view inspector/logger etc. Tu enlève le compilo de la chaîne, cool, mais on a toujours besoin de ces autres outils. Au final, tu te retrouves avec le même problème sur le bras (cf mon point sur les compromis, le tien est tres mauvais ici).

Outils qui sont familiers à n'importe quel développeur Web. Donc, si l'utilisateur ne veut pas se coltiner ces outils pour la modification de l'interface, il trouvera facilement quelqu'un pour le faire à sa place. En tout cas, plus facilement qu'avec une application native classique sur MacOS, iOS, Windows…

Quel est l'intérêt de déployer une appli native basée sur des technos web, quand on a un browsers installé sur toutes les machines, ce qui élimine entièrement le problème du deployment/packaging etc? (À nouveau les compromis, tu te retrouves avec le pire des 2 mondes si tu part sur une techno hybride).

De pouvoir déployer la même application indifféremment dans sa version Web et/ou sa version native, sans rien modifier à son code. Bon, après, reste le vieux débat Web vs natif, mais qui, dans le cadre de mon appli. est sans intérêt, puisqu'on la déploie dans la forme que l'on veut.

Dit autrement, tu résouds un problème qui n'existe pas.
Les customisations qui ne sont que purement cosmétique sont par définitions triviales, et donc à très faible valeur ajoutée. Optimiser pour ce cas est une perte de temps.
Les customisations non triviales vont requérir des ingénieurs (vs bien falloir écrire du code pour gérer telle ou telle fonctionnalité différemment), qui maîtrisent donc la technologie et qui n'auront aucun problème à compiler une appli.

L'interface de mon appli. est en HTML5. J'offre à l'utilisateur la possibilité de modifier ce code HTML5 à volonté sans avoir à solliciter le développeur de l'application, et, au pire, mais ce n'est pas indispensable, en sollicitant le développeur Web de son choix. C'est tout. Maintenant, il en fait usage ou non, c'est son problème ; simplement, la possibilité existe.

A priori, mais je n'ai pas encore approfondi le sujet, cela devrait permettre de modifier une application pour, par exemple, l'adapter à l'usage des mal/non-voyants

L'accessibilité va plus loin qu'un simple problème de contraste.

Jette un œil à ce qu'ios/OS X font dans ce domaine si tu me crois pas. Ca demande systématiquement beaucoup de taff, dans la conception même de l'appli, et dans son implémentation. Même sous iOS qui premache 90% du boulot pour toi, tu te retrouves à devoir écrire du code custom à droite à gauche. C'est pas quelque chose que tu greffes après coup en changeant un peu les vues.

Soit dit en passant, ca te fait pas un peu peur de ne pas avoir approfondi le sujet? Disons que c'est un point central de ta technos, comment peut tu prétendre avoir fait les bon choix si tu n'as pas d'idée précise des cas d'utilisation?

Non, ce n'est pas un point central, c'est juste un des avantages. Et ce que je n'ai pas approfondi, ce sont les possibilités de HTML dans ce domaine. Si elles ne sont pas encore suffisantes, il y a de fortes chances que cela se développe par la suite. Le cas échéant, ça sera à la portée de n'importe quel développeur Web d'adapter l'appli. Mais, encore une fois, cela dépend de HTML, pas de ma techno.

A l'origine, je générais directement le .h, mais, en passant par le XML, cela ouvrait la possibilité de générer l'API dans un autre langage, en utilisant un autre fichier XSL.

Ce que je dit, c'est que l'api en question, c'est du code. Écrit la en code directement, plutôt que de la decrire en xml pour ensuite générer du code. T'as rien à gagner à l'écrire en xml, c'est infiniment plus verbeux et casse gueule.
La philosophie sous jacente à ce genre de technos, c'est que ca permettait de générer des stubs client et serveur automatiquement. Sauf que depuis, on s'est rendu compte que c'est vachement plus simple et pratique de juste écrire le code. Les stubs ne servent à quasiment rien, et dans les rares cas ou ils servent, t'as plus vite fait de les générer à partir de l'interface écrite en code. Cf par exemple ce que fait Jersey qui te génère ton wadl à partir de l'appli.

L'API en question contient du code, mais pas le code du backend. En gros, elle expose les objets gérés par le backend sous forme d'objets C++, et elle sérialise simplement les valeurs des différents paramètres des différentes méthodes de ces objets pour qu'ils puissent transiter via le canal de communication avec le backend. Et ça, c'est du code chi emm pénible à écrire, donc je préfère que l'ordinateur le fasse à ma place (c'est l'un des buts de l'informatique, non ?). Il n'y a pas l'ombre du soupçon de code du backend dans cet API, ni d'ailleurs dans le XML qui est utilisé pour la générer. J'ai mis un lien dans le journal sur un fichier contenant une telle API, ainsi que sur le fichier XML correspondant ; tu pourras t'en persuader toi-même.

Bon, j'ai encore regardé sur le Web de quoi il s'agissait, et je ne vois vraiment pas en quoi cela s'applique à ce projet. Pourrais-tu fournir une définition de ce concept, pour être sûr que l'on parle de la même chose, et m'indiquer un exemple de ce qui, dans mes technos, te paraît y correspondre ?

Tu passes beaucoup de temps à construire une plateforme qui émule de façon très pauvre la plateforme sur laquelle elle tourne.
Le concept de backend par exemple: pourquoi introduire un tel système? Ceux qui veulent parler à un backend réseau le feront plus vite et efficacement avec une api rest, tout en ayant une plus grande latitude de choix technologiques.
Le html5: les développeurs auront plus vite faite de coder pour un navigateur plutôt que d'utiliser ta version. Au final, tu construit une plateforme qui émule la plateforme sur laquelle elle tourne, et n'apporte pas grand chose, à part des contraintes.

Ma plateforme n'émule rien du tout. Une appli. native basée sur cette plateforme est, du point de vue de l'interface, une appli. Web, mais débarrassée de tous ce qui est relatif au réseau. Son interface est rendu par Chromium, mais dans une version débarrassée de toute l'interface nécessaire à la navigation Web. Et, coté traitement, on a tous les avantages du natif, c'est-à-dire qu'il n'est nullement besoin de passer par une couche REST ; on a accès directement au backend. Et cette plateforme permet de déployer la même appli en tant que qu’application Web, sans rien changer au code, et donc toujours sans avoir à recourir à une surcouche REST.

Pour nous émanciper des géants du numérique : Zelbinium !

Ok, donc visiblement, on parle de simple définition d'ui en déclaratif? Tu fais pas de bindings (e.g. Définir dans le xml que ce champ reçoit le contenu de la variable foo du contrôleur)?

Ben, au final, le code derrière l'UI, c'est simplement du bête HTML5, similaire à ce qu'on trouve dans la plupart des pages Web ; il est simplement mis en forme à l'aide de XSLT… CEF, c'est, grosso-modo, le navigateur Chromium, mais sans les éléments d'interface qui en font un navigateur Web, c'est-à-dire juste le moteur de rendu. Tout aussi grosso-modo, CEF est à Chromium ce que XULRunner est à Firefox (bon, je ne sais si ça va parler à beaucoup de monde, ça). Mon appli donne à CEF (donc Chromium) du XML et du XSL, et CEF se charge de transformer ça en HTML, dont il assure également le rendu.

Effectivement, la plupart des technos ont une forme de compilation, ça évite de se taper le surcoût de parser du xml à la volée pour qq chose qui n'est pas censé être changé après le packaging de l'appli. L'exception, de mémoire, c'est le truc de Facebook, components il me semble, et eux ont un besoin bien précis (j'y reviendrais).

Si rares sont ceux qui le font c'est parce que le besoin est faible. Changer un storyboard et relancer l'appli sous iOS, c'est moins d'une seconde. Tu changes juste une ressource qui est rapide à compiler, tu touches pas le code, ça va vite.
Pour ceux qui veulent modifier l'ui d'un logiciel libre, c'est d'une part assez rare, et d'autre part généralement un peu plus compliqué que juste changer le layout. Optimiser pour la simplicité de compilation n'est pas un bon calcul.

Je ne comprend pas trop ta dernière phrase. Cependant, ma techno permet à tout un chacun de modifier l'interface :
- à l'aide d'un simple éditeur de texte, sans avoir mettre en œuvre d'autres outils (compilateur ou autres…),
- essentiellement juste en connaissant HTML et XSLT/XML ; à défaut, il pourra s’adresser à n'importe quel développeur Web digne de ce nom.

A priori, mais je n'ai pas encore approfondi le sujet, cela devrait permettre de modifier une application pour, par exemple, l'adapter à l'usage des mal/non-voyants, sans pour cela avoir à impliquer le développeur de l'application. Je pense que pour faire la même chose avec les autres technos citées dans ce journal, il faudrait l'intervention d'un développeur. Accessoirement, cela permet facilement au développeur de déléguer la réalisation du design de l'interface, vu qu'il ne manque pas de personnes ayant les compétences nécessaires (développeurs Web). Personnellement, n'ayant aucune affinité particulière avec HTML et consorts (CSS, JS…), c'est quelque chose qui m'arrange bien.

Bon, quand je parle de l'utilisateur, il peut aussi s'agir d'une entreprise qui adapte l’interface du logiciel à sa charte graphique, par exemple…

Ce qu'il se passe pour Facebook est qu'ils ont une appli gigantesque, dont le contenu change en permanence et en temps réel, maintenue par des dizaines de personnes et releasee tous les 15 jours. la modifier sans tout peter est très dur. Le feed se met à jour constamment et affiche les likes/commentaires etc en temps reel.

Le modèle traditionnel "modifie la vue pour afficher les données" marche mal, parce qu'il ya trop d'état différents pour chaque vue, et donc calculer le diff est dur.
Leur solution à ce problème, c'est de partir sur un modèle 100% événementiel/stateless. C'est plus simple de tout balancer et de rerendre les vues quand les notifications de changement de données arrivent. Charge à la team du framework de recycler les vue pour que ca rende toujours à 60fps sans bouffer toute la ram du device.
Le fait que les vues se recharges automatiquement à chaud est juste un effet de bord sympa, c'est tout, c'est pas un but en soi.

En effet. J'ai cité cela pour juste souligner la facilité avec laquelle on peut modifier l'interface.

Bref, assez parlé de Facebook, retournons à xdh chose.
- quel problème xdh-chose essaye de résoudre?
- en quoi ce problème est pertinent?
- en quoi la solution de xdh améliore l'état actuel?

Je pense que tu parle des attributs data-xdh-.... Ça n'est pas censé résoudre un problème en particulier, c'est juste mon approche pour gérer :
- pour les data-xdh-onevent(s), la mise en place des gestionnaire d’événements,
- pour les xdh-data-cast(s), l'accessibilité (je ne trouve pas de terme adéquat pour désigner le fait qu'un élément soit hidden/disabled…).

Il y a également les data-xdh-widget, mais qui ne sont pas (encore) utilisés dans cette appli, et qui sont dédiés à la gestion des widgets basés sur jquery, qui semblent assez répandus.

Tout ça permet de confier au logiciel la mise en place du code JS généralement mis en œuvre pour ces usages.

Un des concepts de base en ingénierie est qu'on ne résoud jamais vraiment un problème. On transforme un problème en un autre, mais cet autre problème vient avec ses inconvénients. Si les nouveaux inconvénients sont moins nombreux/courants/ennuyeux que ceux qu'on avait a la base, on a gagné. En d'autres termes, on fait des compromis.
Un compilateur rend plus simple l'écriture de code, par exemple, mais le langage vient avec ses tares, et cache le fonctionnement sous jacent de la machine. En pratique, c'est un gain net.

Étant le développeur de cette appli, je m'abstiendrais de me prononcer sur ce point ; on pourrait m'accuser de manquer d'objectivité :-).

J'ai du mal, personnellement, à voir le gain sur le compromis que tu fais ici. Tu gagnes sur le code, mais tu te retrouves avec plus de 1000 lignes de xml aride pour une appli triviale. ça coûte cher le setup de l'appli, même les monstres à là spring font tout ce qu'ils peuvent pour réduire ca le plus possible (et eux font beaucoup plus que toi avec ce setup).

Là je pense que tu parle des fichiers de configuration (les .xcfg). Le problème vient du packaging. En réalité, mes fichiers de configurations sont plus simples que ceux qui sont fournis dans les packages (comme on peut le voir en regardant les version hébergées dans le repository mercurial dont l'adresse est donné dans le journal), car ils s'appuient sur un préprocesseur XML, ce qui permet d'utiliser des macros, et de répartir le contenu sur plusieurs fichiers. La version packagée est celle après application du préprocesseur XML ; c'est comme si on livrait les sources d'un programme C/C++ après les avoir passés par le préprocesseur C. C'est certainement quelque chose qui devrait être amélioré, mais ce n'est pas évident à réaliser. Ceci dit, ça reste du XML, mais il ne sert qu'à remplir une registry interne. On peut parfaitement envisager de remplir cette registry à l'aide d'un autre format, comme JSON par exemple…

Le xml est particulièrement aride à lire, très long, tres verbeux et ca se répète énormément. Ça fait 15-20 ans qu'on sait que les UI déclaratives, c'est cool, mais il faut un éditeur riche pour que ça marche. Ça va plus vite à écrire, et ça permet d'avoir une vue de l'ensemble.
Le xml pour générer les stubs back/front end, on sait depuis soap que c'est une très mauvaise idée. C'est vilain, verbeux et ca résoud quasiment aucun problème, ca en rajoute juste.
Dans l'autre sens, ça marche mieux (par exemple ce que fait jaxrs avec les wadl). La tendance "xml pour générer des stubs" avait le vent en poupe ya 15 ans, tout le monde en revenu parce que c'est un enfer à maintenir et ca ne résoud pas vraiment de problème. C'est plus simple/lisible/naturel d'écrire une interface en code directement.

Pour le XML relatif à l'interface, et celui des fichiers de configuration, j'espère que mes réponses ci-dessus sont assez claires (sinon, ne pas hésiter de me demander des précisions). Pour celui concernant l'API des backend, il s'agit juste d'un fichier intermédiaire, qui n'est pas utilisé lors de l'exécution de l'application. A l'origine, je générais directement le .h, mais, en passant par le XML, cela ouvrait la possibilité de générer l'API dans un autre langage, en utilisant un autre fichier XSL.

Bref, désolé de tailler un costard, mais j'ai beaucoup de ma à voir un intérêt au framework, et à mon avis, ce genre d'approche diminue la qualité plus qu'autre chose.

Inutile d'être désolé. Pour l'instant, tout ce que j'ai lu concernant les autres technos me renforce dans mon opinion que les miennes sont parfaitement viables et légitimes, en théorie du moins. Et c'est justement l'un des buts de l'appli présentée dans ce journal de les mettre à l'épreuve de la pratique.

Aussi, pour ne pas perdre trop de temps avec ça, j'ai établis quelques règles de nommage ; malheureusement, ces règles donnent des noms parfois un peu abscons, mais c’est le prix à payer si l'on veut des noms pas trop longs.

Et bien changes les règles. Rajoutes des voyelles, ça coûte pas plus cher et ça fait des mots lisibles et prononçables.

Là encore, c'est un problème de packaging. Si l'application était correctement packagé, l'utilisateur ne serait jamais exposé à ces noms ; il aurait juste à cliquer sur l'une ou l'autre icône, auxquelles on pourrait donner un nom plus expressif. Mais, vu l'état de l'application, il me semble plus important de me concentrer sur le fond que sur la forme…

Le commentaire sur l'inner platform effect se rapportait au framework, pas aux noms :)

Bon, j'ai encore regardé sur le Web de quoi il s'agissait, et je ne vois vraiment pas en quoi cela s'applique à ce projet. Pourrais-tu fournir une définition de ce concept, pour être sûr que l'on parle de la même chose, et m'indiquer un exemple de ce qui, dans mes technos, te paraît y correspondre ?

Pour nous émanciper des géants du numérique : Zelbinium !

Je suis sûr que si, par exemple tu sais que tu fais des templates quand tu en fait (quand tu utilise <>).

Étant donné que c'est quand même du C++, je pense que la présence de templates n'a rien de surprenant…

Globalement pour me donner envie de lire les 50k SLOC (Source Lines Of Code) de code que constitue ton xdhdq, il faut quelque chose qui parle un peu plus aux gens. Moi perso je ne développe pas en C++ depuis pas mal de temps, j'ai pas un grand plaisir à bouffer autant de code.

De l'autre coté c'est dommage de ne pas s'intéresser à l'existant parce que ça constitue une source d'inspiration importante.

En fait, les prémices de mon framework datent d'une vingtaine d'année. A l'époque, je voulais utiliser la STL, mais il était fortement déconseillé dans la documentation de l'utiliser en production. Du coup, j'ai développé mes propres bibliothèques. Après, j'ai regardé l'existant, mais sans aller jusqu'à regarder les détails de l'implémentation, vu que, globalement, cet existant ne m'apportait rien de plus que ce que je n'avais déjà avec mon framework…

Personnellement je n'appellerais pas xdhdq un hello world. C'est plus une vitrine. Le hello world, c'est le code minimal qui permet d'utiliser le cas nominal de ton framework. Par exemple c'est ce qui permet d'avoir une fenêtre avec un bouton dessus et quand tu clique dessus le bouton change de couleur (ou le texte change). Je présume que ça tiens en 3 fichiers C++ et 2 fichiers XML/XSL.

Là, j'avoue, j'ai fauté. Le fait est que, lorsque je démarre le développement d'une nouvelle application, je lance un script qui me met en place une application avec quelques fonctionnalités de base. Ainsi, la première page de l'application permet, soit de créer un nouveau projet, soit de sélectionner l'un de ceux prédéfinis dans le fichier de configuration, soit d'ouvrir un fichier contenant un projet. La seconde page, dont le contenu est conditionné par le choix fait à la première page, permet, soit de continuer sans backend, soit d'en sélectionner un parmi ceux prédéfinis dans le fichier de configuration (ou du projet), soit de charger directement la bibliothèque dynamique correspondant au backend, soit encore de saisir l’adresse et le port du backend auquel l'application doit se connecter. L'essentiel du code de cette application correspond en fait à la gestion des ces fonctionnalités. Les fichiers C++ et XSL correspondant aux fonctionnalités au cœur de l'application sont ceux commençant par Fields (un .h, un .cpp, et deux .xsl).

Pour nous émanciper des géants du numérique : Zelbinium !

Si tu veux parler d'une séparation frontend/backend, ou client/serveur, ça existe quand même depuis très très longtemps sous une diversité de formes impressionnate. D'une manière générale, je pense que peu de gens contestent l'utilité de séparer les algorithmes du logiciel et l'interface utilisateur.

La séparation frontend/backend, je l'avais implémenté à l'époque parce que ça me semblait une bonne idée. Vu tous les avantages que cela apporte, je me doute bien que je ne sois pas le seul à mettre en œuvre ce mécanisme, sans toutefois chercher à en savoir davantage à ce sujet. Je l'ai simplement mentionné à titre informatif, sans vouloir impliquer que cela soit une exclusivité de mon framework.

Après, qu'il faille recompiler la partie UI ou modifier le code pour modifier l'interface, ça dépend un peu du type de logiciel, mais ça ne me semble pas forcément primordial. J'ai du mal à voir ce que ça change en termes de maintenabilité du code, par exemple. Si tu as un code super-complexe qui te génème une interface graphqiue à partir de fichiers XML super complexes, tu vas avoir des bugs de partout, et il est très improbable de motiver les gens à apprendre le "framework". Typiquement, pour un logiciel libre, ça veut dire que tu te coupes de la possibilité de recevoir des patches ; un utilisateur ne va pas passer plusieurs mois à se former sur ton framework pour corriger un bug.

Le code pour générer l'interface n'est pas complexe en soi ; ce qui peut être complexe, c'est le code HTML/CSS, et éventuellement JS (sachant que l'on peut mettre du XHTML/CSS/JS directement dans le fichier XSL), mais cela dépend uniquement de ce que veut l'utilisateur. Les fichiers XSL fournis avec l'application ne contiennent que des instructions XSL relativement basiques. Quand au XML, il n'est pas complexe non plus, car il ne contient que les données, et quelques informations associées, destinées à être affichées.

L'isolement technologie a un coût, spécialement pour du logiciel libre. Si tu utilises un binding gtk pour perl, tu as de grandes chances que beaucoup de bricoleurs puissent en un coup d'œil comprendre ce que tu fais. Par ailleurs, être capable de faire tourner ton soft sans passer 3 jours à installer l'environnement de travail peut aussi aider. Au contraire, si le saut technologique est important, cette première étape est rédibitoire. Par exemple, j'ai été faire un tour sur ton github, juste pour cliquer sur quelques fichiers C++ au hasard. Clairement, ton code C++ n'est pas du C++, c'est une sorte de dialecte du C++ qui repose sur des appels de macro dans tous les sens. C'est peut-être justifié, mais ma réaction, c'est "qu'est-ce que c'est que ce bordel, c'est même pas du C++ ce truc". Entre ça et le code généré, j'ai l'impression que comprendre la logique de ton framework nécessite plusieurs semaines de travail. Si en plus tu n'arrives pas à expliquer l'intérêt d'utiliser ce type de technologie, tu vas galérer pour trouver une base d'utilisateurs à mon avis.

Je n'essaye pas de mettre l'accent sur mon framework, d'autant plus qu'il n'est pas documenté (pas dans le sens 'documentation pas rendue publique', mais dans le sens 'documentation réellement inexistante'). Il se trouve que j'ai développé, et que je compte encore développer, quelques logiciels que j'ai placé sous licence libre, et qui me semblent donc parfaitement qualifiés pour faire l'objet de quelques journaux sur ce site. Maintenant, que les gens ne s'y intéresse pas, ou ne s’intéresse qu'au logiciel, ou bien s'intéresse au framework sur lequel ces logiciels s'appuient, c'est leur affaire, tout en étant bien conscient que mes lacunes en matière de communication ne facilite pas les choses, sachant néanmoins qu'il y a plus de chance que les gens s'y intéresse en communiquant mal sur le sujet, qu'en ne communiquant pas du tout. Si, malgré cela, des personnes sont intéressées par ce que je fais, je leur apporterais volontiers tout éclaircissement qui leur paraîtrait nécessaire.

Pour ce qui est de l'installation du logiciel, je suis parfaitement d'accord qu'elle est, dans sa forme actuelle, quelque peu rédhibitoire. Mais ce n'est pas dû à mes logiciels proprement dit, mais à CEF, sur lequel mes logiciels s'appuient dans leur version native. Pour Windows, j'ai essayé de simplifier l'installation en fournissant un package auto-suffisant. Pour les autre environnements, je voudrais pouvoir faire la même chose, mais je ne sais pas faire (ce qui ne veut pas dire que ce n'est pas possible). Tous les autres logiciels que j'ai publié et qui ne dépendent pas de CEF sont installés après décompression de l'archive en lançant simplement un make à la racine de l’archive. Je suis en train d'essayer de mettre en place la même procédure pour ce logiciel-ci, mais ça nécessite de se plonger dans les arcanes de CEF, ce qui prend du temps…

Répondre de manière semi-agressive aux commentaires ne risque pas forcément d'aider non plus, d'ailleurs. Tu t'attendais peut-être à ce que les gens te répondent "c'est génial ton truc, comment personne n'y a jamais pensé avant", mais visiblement, s'ils te disent qu'ils n'ont pas compris et que ça ne leur paraissait pas spécialement nouveau ni même intéressant, ça n'est pas dans le but de te blesser. Si tu es dans l'état d'esprit de répondre "vous êtes tous des cons qui n'y connaissez rien", ça ne va pas être très constructif. Il ne faut pas non plus que ça bride ton entousiasme, si tu penses que ton truc vaut le coup, fonce. Mais n'oublie pas "eat your own dog food": Si ta techno permet de développer sans effort des logiciels super facilement, alors le mieux est de fournir ces logiciels toi-même, jusqu'à ce que les gens se demandent "mais comment ce type peut-il maintenir autant de softs de qualité?", ce qui les amènera sur le côté technique. L'approche inverse me semble au contraire très risquée, pusiqu'il est normal pour quelqu'un de sain mentalement de rejeter une nouvelle technologie sans avoir une bonne raison de s'y intéresser.

Il ne me semble pas avoir répondu de manière semi-aggressive. Par contre, j'ai l'impression que mon refus de me plier à certains dogmes auxquels quelques personnes semblent attachées est vécu par ces dernières comme un affront… Comme je l'ai écrit plus haut, je ne m'attends à rien du tout en publiant ce genre de journal. Je suis développeur freelance, j'adore ça, et j’utilise mon framework pour développer les applications demandées par mes clients, qui en sont d'ailleurs très satisfait. En outre, j'utilise quotidiennement avec délice, professionnellement et à titre privé, plusieurs applications, dont certaines disponibles sur mon site, que j'ai développées et qui sont basées sur mon framework (donc, le dogfooding, je connais). Quelques soient les réactions à mes journaux, elles ne changeront rien à cela, ni d'ailleurs, rassure-toi, à mon intention de continuer à développer ce logiciel et d'autres, dont les évolutions feront l'objet de journaux ici même.

Pour nous émanciper des géants du numérique : Zelbinium !

Si tu parles de la possibilité de définir une UI en déclaratif, ya de quoi faire. NeXT/Apple le font depuis le début des années 90, flex le faisant ya 10 ans, Android le fait depuis un bail, qt le fait avec creator et je serais surpris si ms avait pas ca depuis un bail.

J'ai essayé QML (je pense que c'est à cela que tu fais référence avec Qt), et j'ai fait un peu d'Android, mais ça date d'il y a pas mal de temps. Pour Microsoft, il y XAML auquel j'ai jeté un œil, mais cela fait longtemps aussi. Or, il me semble bien que toutes ces technos nécessite une sorte de compilateur. Le mécanisme qui est mis en œuvre dans mon logiciel ne nécessite pas de compilation. Il n'est même pas nécessaire de relancer le logiciel pour voir les modifications. Comme je l'avais écrit dans un des commentaires ci-dessus, j'avais déjà fait quelque chose de similaire, bien que pas aussi poussé, en utilisant XUL, mais je n'ai jamais entendu parler d'un autre logiciel utilisant XUL dans ce but, ce qui n'a rien d’étonnant, vu que XUL n'a guère était employé en-dehors des produits Mozilla.

Si tu parles de la possibilité de modifier le comportement de l'appli depuis du xml, deux choses:
- on a fait plus simple qu'xml pour décrire des comportements
- ça fait un bail aussi qu'on sait que c'est pas une bonne idée (si Apple a jamais porté les bindings d'interface builder sous iOS, c'est pour une bonne raison). C'est un cauchemar à maintenir, et apporte au final tres peu.

XML ne sert qu'à exposer les données, et quelques informations associées, qui doivent être affichées, sans même la moindre indication sur la manière dont ces données doivent être affichées.

Bref, j'ai un peu laissé tomber quand j'ai vu que le nom de l'appli était xdhqxddqt et que t'avais un autre nom de projet a peu près pareil, à 2-3 d/h/x prêt. Ça me donne vachement l'impression d'un inner platform effect si tu veux mon avis.

Avec les applis que je développe pour les clients et mes applis personnels, tous contenant plusieurs binaires, ça fait un paquet de noms à trouver. Aussi, pour ne pas perdre trop de temps avec ça, j'ai établis quelques règles de nommage ; malheureusement, ces règles donnent des noms parfois un peu abscons, mais c’est le prix à payer si l'on veut des noms pas trop longs. Quand à l'inner platform effect, je ne connaissais pas, et, vu ce qu j'ai lu à ce sujet, je ne vois pas trop le rapport entre ça et le nom de mes projets/applis…

Pour nous émanciper des géants du numérique : Zelbinium !

Comme je l'ai indiqué au début du journal, l'intérêt du logiciel, en l'état, ne réside pas dans ses fonctionnalités, très limitées pour le moment, mais des technos mis en œuvre. En l’occurrence, l'une dans les technos permet de modifier l'interface graphique du logiciel sans avoir à intervenir sur ses sources. Comme il s'agit d'un logiciel libre, il est censé offrir la liberté de le modifier, et cela par la mise à disposition de ses sources. Avec cette techno, il est encore plus facile d'appliquer cette liberté à son interface, puisque qu'il n'est pas nécessaire de modifier ses sources pour cela. N'ayant connaissance d'aucune autre techno qui offre cette possibilité, et ce site traitant des valeurs attachées au Libre, je pensais que cette techno pouvait intéresser son lectorat, d'où ce journal.

Concernant cette techno, et les autres présentées dans ce journal, toute les affirmations ne sont pas des promesses concernant de futures caractéristiques, mais la description de caractéristiques existantes, et chacun peut s'en persuader en consultant les sources. Je suis conscient que je suis loin d'exceller dans l'art de la communication, et que mes écrits en pâtissent, et c'est pour cela que je m'applique à fournir les réponses les plus pertinentes possibles aux différents points soulevés dans les commentaires.

Que ce soit dans ce journal, ou dans d'autres, on se gausse souvent que j'emploie XML/XSL, ou certaines autres combinaisons de technos, parce que, paraît-t-il, il en existe maintenant de plus récentes pour faire la même chose, mais en mieux. C'est quelque chose que je suis tout à fait prêt à admettre, mais certainement pas uniquement sur la base d'affirmations péremptoires qui ne sont étayées d'aucun élément probant. A titre d'exemple, j'attends toujours que l'on m'indique quelle est cette technologie qui est tellement mieux que XML/XSL(T), et en quoi elle est mieux.

Pour nous émanciper des géants du numérique : Zelbinium !

Je ne peux pas être plus précis ; n'ayant quasiment jamais utilisé d'autres framework que le mien, je ne peux pas dire en quoi il se distingue. J'ai juste un jour commencé à coder quelques bibliothèques, regroupant des fonctionnalités que j'utilisais souvent, bibliothèques que je modifie, lorsque c'est nécessaire, pour les rendre plus faciles à utiliser et/ou plus performantes. Puis je leur ai rajouté d'autres bibliothèques, qui prenaient en charge d'autres fonctionnalités que j'avais été amené à implémenter au grès des différents développement que j'ai réalisés, histoire de pouvoir disposer de ces fonctionnalités sans avoir à les réimplémenter. Et c'est l'ensemble de ces bibliothèques qui constitue mon framework. Je n'ai pas cherché à mettre en œuvre des techniques particulières ; la forme que prend l'API est juste celle que je trouve la plus pratique à l'usage. Et la terminologie ci-dessus ne m'est pas suffisamment familière pour pouvoir dire si elle s'applique ou non à l'API de mon framework…

Pour ce qui est du "Hellow World!", c'est un peu le but du logiciel présenté dans ce journal, dans son état actuel, vu le peu de fonctionnalités qu'il implémente. Sinon, pour ce qui est de la technologie que j'appelle XDHTML et qui se concentre sur l'interface graphique, il y le logiciel que je présente à cette adresse : http://q37.info/computing/epeios/apps/xdhdq/.

Pour nous émanciper des géants du numérique : Zelbinium !

L'avantage de la transformation XSL, c'est qu'elle est implémentée nativement sur la plupart des navigateurs (en tout cas, les plus populaires). C'est un élément clef dans la technologie que je présente dans ce journal.

Sinon, peut-être parce que je l’utilise quotidiennement depuis de nombreuses années, mais je n'ai aucune difficultés avec XSL ; il faut dire que, probablement parce que j'ai toujours un contrôle total sur le flux XML entrant, je n'utilise que des fonctionnalités relativement basiques.

Pour nous émanciper des géants du numérique : Zelbinium !