Programmation lettrée

Un article de Wikipédia, l'encyclopédie libre.
Aller à : navigation, rechercher

La programmation lettrée (ou programmation littéraire) est une approche de la programmation préconisée par Donald Knuth qui se veut une alternative au paradigme de programmation structurée des années 70[1].

« Je crois que le temps est venu pour une amélioration significative de la documentation des programmes, et que le meilleur moyen d'y arriver est de considérer les programmes comme des œuvres littéraires. D'où mon titre, « programmation lettrée ».

Nous devons changer notre attitude traditionnelle envers la construction des programmes : au lieu de considérer que notre tâche principale est de dire à un ordinateur ce qu'il doit faire, appliquons-nous plutôt à expliquer à des êtres humains ce que nous voulons que l'ordinateur fasse.

Le praticien de programmation lettrée peut être vu comme un essayiste, qui s'attache principalement à l'exposition du sujet et à l'excellence du style. Un tel auteur, le dictionnaire à la main, choisit avec soin les noms de ses variables et explique la signification de chacune. Il cherche à obtenir un programme qui est compréhensible parce que les concepts ont été présentés dans le meilleur ordre pour la compréhension humaine, en utilisant un mélange de méthodes formelles et informelles qui se complètent l'une l'autre[1]. »

— Donald Knuth, Literate Programming

Le paradigme de programmation lettrée, tel que conçu par Knuth, s'éloigne de la contrainte d'écrire des programmes dans l'ordre imposé par l'ordinateur, et à la place permet aux développeurs de concevoir leurs programmes dans l'ordre requis par la logique et le fil de leur pensée. Les programmes lettrés sont écrits comme une exposition ininterrompue de la logique dans un langage naturel, à la manière d'un essai, dans lequel des macros qui masquent les abstractions et la complexité sont incluses.

Des outils de programmation lettrée sont utilisés pour obtenir deux représentations à partir d'un fichier source lettré : l'une utilisable par un compilateur ou exécutable, le code « emmêlé », et une autre pour la lecture comme une documentation formatée, qui est dite « tissée » à partir de la source lettrée. Alors que les premiers outils de programmation lettrée étaient spécifiques à un langage de programmation, les suivants sont devenus indépendant du langage et existent au-dessus de celui-ci.

Concept[modifier | modifier le code]

Un programme lettré est une explication de la logique du programme en langage naturel, comme l'anglais, entremêlée avec des morceaux de macros et de code source traditionnel. Les macros, dans un fichier source lettré, se présentent comme des titres ou des phrases en langue humaine, qui décrivent les abstractions créées au moment de résoudre le problème et cachent le morceau de code ou la macro bas-niveau. Ces macros sont similaires aux algorithmes en pseudo-code souvent utilisés dans l'enseignement des sciences informatiques. Ces phrases explicatives deviennent de nouveaux opérateurs, créés à la volée par le programmeur, formant un méta-langage au-dessus du langage de programmation compréhensible par l'ordinateur.

Un préprocesseur est utilisé pour analyser les hiérarchies arbitraires, ou les « toiles interconnectées de macros », pour produire le code source compilable avec une commande (tangle, emmêler) et la documentation avec une autre (weave, tisser). Le préprocesseur permet aussi d'extraire des macros et d'ajouter du contenu à une macro déjà définie à n'importe quel endroit du texte, permettant ainsi de s'affranchir du besoin de garder à l'esprit les restrictions imposées par les langages de programmation traditionnels et d'éviter d'interrompre le flux de pensée.

Avantages[modifier | modifier le code]

Selon Knuth, la programmation lettrée permet d'écrire des programmes de grande qualité[1], car elle force les programmeurs à exposer clairement les pensées derrière le code, rendant les mauvaises décisions de conception plus évidentes. Knuth affirme aussi que la programmation lettrée fournit un système de documentation de premier ordre, qui n'est pas un ajout au code, mais est érigé naturellement dans le processus d'exposition de la pensée, durant la création du programme[1]. La documentation résultante permet à l'auteur de reprendre le fil de sa pensée là où il l'avait arrêtée, longtemps après, et permet aux autres programmeurs de comprendre la construction du programme plus facilement.

Ceci diffère de la documentation traditionnelle, dans laquelle un programmeur se voit présenté le code source organisé selon les contraintes du compilateur, et doit en déchiffrer l'intention selon le code et les commentaires qui y sont associés. Le méta-langage de la programmation lettrée est aussi dit faciliter la pensée en général, donnant une meilleure vue d'ensemble du code et augmentant le nombre de concepts que l'esprit peut retenir et utiliser avec succès. Selon Knuth, la programmation lettrée permettrait donc aussi d’accroître grandement la qualité du code produit [1].

L'application de ce concept à la programmation à large échelle est présentée avec TeX, écrit en programmation lettrée et très utilisé dans le domaine de l'édition scientifique.[réf. souhaitée]

Méconceptions[modifier | modifier le code]

La programmation lettrée est souvent assimilée à tort[2] à une simple documentation générée à partir d'un seul document source mixant code et commentaires, ou à des commentaires volumineux inclus dans le code. Cette méconception a poussé à considérer les outils d'extraction de commentaires, comme le Plain Old Documentation de Perl, comme des « outils de programmation lettrée ». Cependant, parce que ces outils n'implémentent pas les « toiles de concept abstraits » proposées par les macros en langage naturel, ou ne fournissent pas la possibilité de changer l'ordre du code source, de celui imposée par la machine à celui pratique pour l'esprit humain, ils ne peuvent pas être appelés outils de programmation lettrée tel que défini par Knuth[2].

Exemple[modifier | modifier le code]

Un exemple classique de programmation lettrée est l'implémentation du programme de compte de mots wc d'Unix. Knuth a présenté une version CWEB de cet exemple dans le chapitre 12 du livre Literate Programming. Le même exemple a plus tard été réécrit pour l'outil de programmation lettrée noweb[3]. Cet exemple fournit une bonne illustration des éléments principaux de la programmation lettrée.

Création de macros

Le morceau de code du programme lettré wc[3] suivant montre comment les phrases arbitraires en langage naturel sont utilisées en programmation lettrée pour créer des macros, qui agissent comme des « opérateurs » dans le langage de programmation lettrée, et masquent les morceaux de code ou les autres macros. La notation de balisage consiste en des doubles chevrons (« <<…>> ») qui indiquent les macros, le signe « @ » indiquant la fin d'une section de code dans un fichier noweb. Le symbole « <<*>> » indique la « racine », le nœud parent duquel l'outil de programmation lettrée va étendre la toile de macros. En réalité, on peut extraire le code source de n'importe quelle section ou sous-section (c'est-à-dire, un morceau de code désigné par « <<nom du morceau>>= », avec le signe égal), et un programme lettré peut donc contenir plusieurs fichier de code source à extraire.

La fonction de wc est de compter les lignes, mots et/ou caractères dans une 
liste de fichiers. Le nombre de lignes dans un fichier est […](plus 
d'explications)
 
Ici, voici un résumé du fichier wc.c qui est défini par le programme noweb 
wc.nw :
    <<*>>=
    <<Fichier d'en tête à inclure>>
    <<Définitions>>
    <<Variables globales>>
    <<Fonctions>>
    <<Le programme principal>>
    @
 
Nous devons inclure les définitions d'entrée/sortie standard, puisque l'on veut
envoyer la sortie formatée à stdout et stderr.
    <<Fichier d'en tête à inclure>>=
    #include <stdio.h>
    @

Notez aussi que le démêlage des morceaux de code peut être fait n'importe où dans le fichier texte de programmation lettrée, et pas nécessairement dans l'ordre où ils sont affichés dans le morceau qui les référence, mais dans celui demandé par la logique, reflétée dans le texte explicatif qui enveloppe le programme complet.

Le programme comme une toile – les macros ne sont pas que des noms

Les macros ne sont pas la même chose que les « noms de section » dans les documentations habituelles. Les macros de programmation lettrée peuvent masquer n'importe quel morceau de code, et être utilisées dans n'importe quelle structure du langage machine bas niveau, souvent à l'intérieur des opérateurs logiques comme « if », « while » ou « case ». Ceci est illustré par l'extrait suivant du programme lettré wc[3].

Le morceau de code présent, qui effectue le compte, a été l'un des plus simples à écrire. Nous regardons chaque caractère et changeons l'état s'il commence ou finit un mot.
 
    <<Parcourir le fichier>>=
    while (1) {
      <<Remplir le tampon s'il est vide; arrêter à la fin du fichier>>
      c = *ptr++;
      if (c > ' ' && c < 0177) {
        /* Codes ASCII visibles */
        if (!in_word) {
          word_count++;
          in_word = 1;
        }
        continue;
      }
      if (c == '\n') line_count++;
      else if (c != ' ' && c != '\t') continue;
      in_word = 0;
        /* c est un retour à a ligne, une espace ou une tabulation. */
    }
    @

En fait, les macros peuvent se placer dans n'importe quel morceau de code ou d'autres macros, et sont ainsi plus générales que le « découpage » ascendant ou descendant, ou le découpage en sections. Knuth indique que lorsqu'il a réalisé ceci, il a commencé à penser au programme comme une « toile » de différentes parties[1].

L'ordre de la logique humaine, pas celle du compilateur

Dans un programme lettré noweb, en plus de l'ordre libre de leurs explications, les morceaux derrière les macros, une fois introduits avec « <<…>>= », peuvent être continués à n'importe quel endroit du fichier en écrivant simplement « <<nom du morceau>>= » et en ajoutant plus de contenu à ceux-ci, comme l'extrait suivant le montre (le signe « + » est ajouté par le formateur du document pour la lisibilité et n'est pas dans le code)[3] :

 
Le compte total doit être initialisé à zéro au début du programme. Si nous avions fait ces variables locales à main, nous aurions dû faire cette initialisation explicitement. Cependant, les variables globales en C sont automatiquement initialisées à 0. (Ou plutôt « statiquement initialisées », vous saisissez ?)
 
    <<Variables globales>>+=
    long tot_word_count, tot_line_count,
         tot_char_count;
      /* Nombre total de mots, de lignes et de caractères. */
    @
Retenir le cours de la pensée

La documentation d'un programme lettré fait partie de l'écriture du programme. Au lieu de commentaires proposés comme des petites notes sur le code source, un programme lettré contient les explications des concepts à chaque niveau, les niveaux les plus bas étant relégués à une place appropriée, ce qui permet une meilleure communication des idées. Les extraits du wc lettré ci-dessus montrent comment l'explication du code et sa source sont entremêlés. Une telle exposition des idées crée un flux de pensée qui se rapproche d'un travail littéraire. Knuth a écrit une « nouvelle » qui explique le code du jeu de stratégie Colossal Cave Adventure[4].

Outils[modifier | modifier le code]

Le premier outil de programmation lettrée publié a été WEB, introduit par Donald Knuth en 1981 pour son système de composition de documents TeX. Il utilise Pascal comme langage de programmation bas niveau et TeX pour la composition de la documentation. Le code source complètement commenté de TeX a été publié dans TeX: The program, volume B de de la série de 5 volumes Computers and Typesetting. Knuth avait déjà utilisé de manière privée un système de programmation lettrée appelé DOC dès 1979. Il a été inspiré par les idées de Pierre-Arnoul de Marneffe[5]. Le programme libre CWEB, écrit par Knuth et Silvio Levy, WEB adapté au langage C et C++, tourne sur la plupart des systèmes d'exploitation et peut produire de la documentation TeX et PDF.

D'autres implémentations du concept de programmation lettrée sont noweb et FunnelWeb, tous deux indépendants du langage de programmation du code source. Noweb est aussi bien connu pour sa simplicité : seulement deux conventions de balisage et deux commandes à invoquer sont nécessaires pour l'utiliser, et permet de formater le texte en HTML plutôt que d'utiliser le système TeX.

FunnelWeb est un autre outil de programmation lettrée qui peut produire de la documentation HTML. Il a un langage de balisage plus compliqué (avec « @ » échappant chaque commande de FunnelWeb), mais a des options plus flexibles.

Nuweb peut traduire un simple fichier de programmation lettrée en n'importe quelle quantité de fichiers sources et utilisant de multiples langages de programmation, et possède une documentation en LaTeX. Il procède en une seule invocation de commande, sans avoir deux commandes séparées pour l'emmêlage et le tissage (« tangle » et « weave »). Il n'est pas aussi extensible que noweb, mais peut utiliser le paquet de listings de LaTeX pour proposer du pretty-printing et le paquet hyperref pour générer des liens dans la sortie PDF. Il a aussi des fonctionnalités de référencement croisé extensibles, incluant des références dans le code généré permettant de retrouver sa position dans la documentation, sous forme de commentaires ainsi que de chaîne de caractères que le code peut utiliser pour reporter son comportement. Vimes est un vérificateur de types pour la notation Z qui montre l'usage de nuweb dans une application pratique. Environ 15 000 lignes de code source nuweb sont extraites en environ 15 000 lignes de C/C++ et plus de 460 pages de documentation. (voir les liens externes.)

Molly est un outil de programmation lettrée écrit en Perl, dont l'objectif est de moderniser et d'étendre la programmation lettrée avec le « pliage HTML » et les « vues virtuelles » du code. Il utilise le langage de balisage de noweb pour les sources lettrées. (voir les liens externes.)

Codnar est un outil de programmation lettrée inversé disponible sous forme de Gem Ruby (voir les liens externes). Au lieu d'extraire le code source de la documentation, le document lettré est extrait du code source. Ceci permet à ces fichiers source d'être édités et maintenus normalement. L'approche est similaire à celle utilisée par des outils populaires de documentation d'API, comme la JavaDoc. Ces outils, cependant, génèrent une documentation de référence, tandis que Codnar génère une description linéaire et narrative du code, similaire à celle créée par les outils de programmation lettrée habituels. Codnar peut coexister avec les outils de documentation d'API, permettant à un manuel de référence et à une explication narrative d'être générés à partir de la même collection de fichiers source.

Leo est un éditeur de texte structuré qui supporte de manière optionnelle les langages de balisage de noweb et CWEB. L'auteur de Leo mélange deux approches différentes : premièrement, Leo est un éditeur de texte structuré, ce qui aide la gestion de larges textes; ensuite, Leo inclut des idées de programmation lettrée, qui dans sa forme la plus pure (c'est-à-dire, la manière dont les outils de Knuth et d'autres, comme noweb, l'utilisent) est possible avec un certain degré d'inventivité et l'utilisation de l'éditeur d'une manière pas exactement prévue par son auteur (dans des nœuds @root modifiés). Cependant, ceci et d'autres extensions (les nœuds @file) rend la structuration du programme et la gestion du texte facile et d'une certaine manière similaire à la programmation lettrée[6].

La langage de programmation Haskell possède un support natif de programmation semi-lettrée, inspiré par CWEB mais avec une implémentation plus simple. Quand l'objectif est une sortie TeX, on écrit un fichier LaTeX où le code est marqué par un environnement donné ; LaTeX peut être configuré pour gérer cet environnement, pendant que le compilateur Haskell cherche les bons marqueurs pour identifier les expressions Haskell à compiler, retirant la documentation TeX comme si elle était en commentaire. Cependant, comme décrit plus haut, ce n'est pas de la programmation lettrée dans le sens entendu par Knuth. La nature fonctionnelle et modulaire[7] de Haskell rend la programmation lettrée directement dans le langage plus aisée, mais n'est pas aussi puissante que celle des outils WEB où « tangle » peut réorganiser le code dans un ordre arbitraire.

Voir aussi[modifier | modifier le code]

  • noweb – un outil de programmation lettrée
  • TeX – un programme écrit en programmation lettrée

Références[modifier | modifier le code]

  1. a, b, c, d, e et f (en) Donald E. Knuth, « Literate Programming », The Computer Journal, British Computer Society, vol. 27, no 2,‎ 1984, p. 97–111 (DOI 10.1093/comjnl/27.2.97, lire en ligne [PDF])
  2. a et b (en) Mark-Jason Dominus, « POD is not Literate Programming », Perl.com,‎ 20 mars 2000
  3. a, b, c et d (en) Norman Ramsey, « An Example of noweb »,‎ 13 mai 2008 (consulté le 4 janvier 2009)
  4. Le jeu, aussi connu comme ADVENT, a été à l'origine écrit par Crowther en environ 700 lignes de FORTRAN; Knuth le refond dans l'idiome WEB. Il est disponible sur literateprogramming.com ou sur le site de Knuth.
  5. Pierre Arnoul de Marneffe, Holon Programming – Report PMAR 73-23, Université de Liège, Service d'Informatique,‎ décembre 1973
  6. (en) Edward K. Ream, « Leo's Home Page »,‎ 2 septembre 2008 (consulté le 4 janvier 2009)
  7. John Hughes, Why Functional Programming Matters, Institutionen för Datavetenskap, Chalmers Tekniska Högskola,,‎ 9 janvier 2002 (lire en ligne)

Pour aller plus loin[modifier | modifier le code]

Liens externes[modifier | modifier le code]