Programmation modulaire à interfaces linguistiques

Programmation modulaire…

La notion de module, dont l'archétype est Modula, est très répandue en programmation, y compris en Javascript.

Cependant avec AlgoDok on va plus loin : la notion de module se décline en micro-modules, mini-modules et modules à interface linguistique, avec des définitions précises.

Avec AlgoDok, l'importation de modules est soit statique soit dynamique et donc chaque module peut importer d'autres modules, à sa guise et à tout moment.

La notion d'interface linguistique est admissible pour tout type de module, comme le mini-module Clignoter (on peut en voir des exemples), mais a priori réservée aux modules à forte valeur ajoutée, comme GeoDyn.

… à interfaces linguistiques

Avec AlgoDok, tout module qu'on veut pouvoir décliner en plusieurs langues n'est vu des autres développeurs qu'au travers d'une interface linguistique opérationnelle permettant d'exprimer chaque action (instruction) sous la forme d'une phrase en langage vernaculaire mais exprimée suivant une syntaxe particulière exploitable en Javascript.

On dit alors qu'on élabore des modules avec ILO, ILO signifiant aussi outil en espéranto.

L'avantage est d'une part de pouvoir rapidement fournir une nouvelle version d'un module dans une autre langue, sans même l'intervention du développeur du module considéré, et d'autre part de pouvoir l'adapter rapidement à des usages linguistiques spécifiques (idiomes, jargon, etc…).

Pour une simple raison d'opportunité, seul le français est actuellement pris en compte ; une version en anglais verra le jour en 2014. Voici des exemples d'actions (instructions linguistique) comme on peut en rencontrer dans tous les documents applicatifs (voir l'exemple d'illustration spécialement conçu pour que ces instructions puissent être testées directement) :

rendre .déplaçable ("le menu") .via ("la poignée 1") ;

déplacer ("le menu") .à (400,600) ;

si (l .élément('vvc') .est ('coché')) { arrêter ("l'horloge") } sinon relancer ("l'horloge") ;

mettre .à .jour ("le temps") .avec (HMS(AlgoDok.t)) ; /* AlgoDok.t : temps écolué en sconde depuis le chargement du docapp. */

classer (toute ('instruction') .de ("la partie 2")) .comme ("grossie") ;

On peut définir des algorithmes simples en langage vernaculaire, en utilisant Algo, permettant ainsi une harmonie complète avec les instructions linguistiques d'AlgoDok. Algo est un nom générique qui permet de le décliner en autant de langues que souhaité, par exemple le français, et on peut redéfinir la fonction de traduction initiale afin de l'améliorer, comme avec le mini-module Algo-fr, comme dans l'exemple d'illustration.

L'interface linguistique d'un module est, par définition, l'ensemble des phrases possibles dont la structure est de type SVO, avec en plus des prépositions et des objets indirects. Bien entendu il s'agit d'une trame syntaxique puisqu'une action est ici un ordre en suspens, que l'on peut imaginer adressé à l'ordinateur : d'où l'usage de l'infinitif et non de l'impératif.

Quelques formes génériques (V : verbe ; ADV : adverbe ; OD : Objet Direct ; PREP : préposition ; OI : Objet Indirect), avec la syntaxe Javascript :

• • V (un_ou_plusieurs_OD) ;

  • V (un_ou_plusieurs_OD) .PREP (un_ou_plusieurs_OI) ;

  • V (un_ou_plusieurs_OD) .PREP_1 (un_ou_plusieurs_OI) .PREP_2 (un_ou_plusieurs_OI) ;

  • V .ADV (un_ou_plusieurs_OD) .PREP (un_ou_plusieurs_OI) ;

En fait il n'y a pas de limite aux formes linguistiques, donc le concepteur d'AlgoDok se garde bien de définir une grammaire a priori qui ne pourrait être que contraignante. La grammaire est opportune, celle de l'usage vernaculaire avec parfois quelques adaptations pour une exécution convenable de l'automate sous-jacent mais implicite.

REMARQUE : il n'y a aucune notion d'héritage de classe avec AlgoDok, pour des raisons profondes (la première publication sur le sujet remonte à 1993) ayant conduit à définir la notion d'affinité qu'on peut découvrir en ligne : Modélisation artéfactuelle – 1995.

En revanche AlgoDok part du principe que l'on peut désigner tout élément d'un document, vu comme un objet, soit par un nom propre (un identifiant) soit par des noms communs (une sémantique) exploitant implicitement l'affinité en remplaçant avantageux de l'héritage multiple, puisqu'il est définissable dynamiquement pour chaque objet et non pour une classe d'objets.