Pourquoi la programmation alphabétisée n'est-elle pas dominante? [fermé]

La programmation alphabétisée a de bons idéaux. Pourquoi pensez-vous que ce n'est pas courant? C'est parce qu'il n'a pas réussi à livrer?

Je l'ai vu pour la première fois dans un livre des écrits de Knuth, et j'ai pensé qu'il avait l'air soigné. Ensuite, j'ai essayé d'utiliser l'affichage de programmation littéraire pour comprendre ce qui se passait dans le programme et je l'ai trouvé plus difficile qu'il n'y paraissait. Il se peut que je sois trop habitué à parcourir les listes de programmes, mais cela m'a semblé déroutant.

Ensuite, j'ai regardé le code source, et cela m'a mis hors tension de temps en temps. Je devrais apprendre à écrire des programmes d'une manière entièrement nouvelle, avec moins de correspondance entre le texte du programme et ce que le compilateur a vu, et n'a vu aucun avantage correspondant.

De plus, les gens peuvent écrire des arguments longs et convaincants selon lesquels le code fait X alors qu'il fait réellement Y, et j'ai rencontré ma part de commentaires trompeurs. J'ai développé un penchant pour la lecture du code pour voir ce qu'il fait assez tôt. La programmation alphabétisée est l'antithèse de cela.

Je blâmerais l' effet réseau . Pour que d'autres personnes puissent modifier votre code et votre documentation, elles doivent être en mesure de le comprendre.

Cela éloigne les gens de quelque chose comme cweb / noweb, car leur utilisation vous obligerait à apprendre TeX et la syntaxe spécifique au programme en plus du langage de programmation que vous utilisez pour le projet. Cela peut être considéré comme une énorme perte de temps, surtout s'ils n'ont pas besoin de la composition mathématique qui est un gros tirage pour TeX en premier lieu. (Et pour de nombreux programmeurs d'applications, ils n'en auront vraiment pas besoin.) Au lieu de cela, ils préfèrent quelque chose comme les commentaires XML de Visual Studio, car c'est déjà populaire et bien établi.

Les endroits où j'ai vu la programmation alphabétisée décoller sont dans l'informatique scientifique / statistique, où la plupart des programmeurs ont une formation importante (aka PhDs) en mathématiques, CS ou statistiques, et sont donc déjà familiers avec LaTeX. La documentation qu'ils écrivent est plus susceptible d'inclure un grand nombre de formules compliquées qui sont mieux écrites dans TeX, et ils sont plus susceptibles de programmer en R. La proportion de programmeurs R qui connaissent SWeave est certainement beaucoup plus élevée que, disons, la proportion de programmeurs C qui connaissent cweb.

J'ai été fasciné par le concept de programmation alphabétisée à la fin des années 90 pendant mes études, et je suis toujours intrigué par l'approche de Knuth en matière de programmation et de composition. Rien que le meilleur fera l'affaire.

Le système de programmation littéraire conçu par Knuth a fait beaucoup, beaucoup plus que ce qui est immédiatement visible, à savoir qu'il a surmonté de nombreuses lacunes dans le langage de programmation sous-jacent que l'outil de génération de code a généré à partir du document source de Knuth, à savoir Pascal standard.

Pour ceux qui ont la chance de ne pas avoir essayé Standard Pascal, voici quelques points saillants.

• Pour rendre plus facile d'avoir un compilateur en un seul passage, la spécification du langage a dit que toutes les déclarations devaient venir dans un certain ordre. De la page wikipedia: "Chaque procédure ou fonction peut avoir ses propres déclarations d'étiquettes goto, constantes, types, variables et autres procédures et fonctions, qui doivent toutes être dans cet ordre." Cela signifiait que vous ne pouviez pas regrouper vos objets de manière logique dans le fichier source.
• La manipulation des cordes était plus fastidieuse qu'en C. simple.
• Les identificateurs ne pouvaient pas avoir une longueur arbitraire.
• Beaucoup d'autres choses dont je ne me souviens plus.

Toutes ces choses signifiaient que Knuth avait besoin d'un meilleur langage de programmation (il en a donc inventé un) et il utilisait Pascal comme langage d'assemblage.

La plupart des langages modernes peuvent faire ces choses sans trop d'efforts, supprimant ainsi une GRANDE partie du travail que la programmation alphabétisée devait résoudre.

Les langages modernes sont également plus expressifs, ce qui permet de réfléchir davantage au code lui-même.

Alors, que reste-t-il? La possibilité de générer une forme de documentation composée à partir du code source, et CELA existe aujourd'hui.

Pensez simplement à JavaDoc - l'API d'exécution Java est peut-être le plus gros morceau de programmation littéraire disponible aujourd'hui (sauf que le code n'est pas réellement présenté, mais il POURRAIT l'être si Java était open source depuis le début). Voir par exemple la présentation du framework de collections sur http://download.oracle.com/javase/6/docs/api/java/util/Collection.html

Je crois que des systèmes similaires existent pour .NET et d'autres programmes grand public.

Une chose que j'ai découverte lorsque j'ai eu mon aventure avec la programmation alphabétisée dans les années 90, c'est qu'elle a attiré des gens très passionnés qui voulaient faire exactement la bonne chose - et cela impliquait d'écrire leur propre système de programmation alphabétisé parce qu'aucun système existant n'était assez bon pour eux. noweb a été une bonne tentative de couper cela en fournissant un dénominateur le moins commun assez bon pour tout le monde, bien que même alors, j'ai passé la plupart de mon temps LP à développer une jolie imprimante pour cela ...

Un autre problème est qu'il est vraiment anti-agile. À certains égards, être ralenti est une bonne chose, car il vous oblige à réfléchir davantage et à bien faire les choses la première fois. D'un autre côté, documenter méticuleusement au fur et à mesure signifie qu'il existe un grand obstacle à la refactorisation de votre code. Et si vous attendez que votre code soit durci avant de le LP-ify, vous vous retrouvez avec une tâche de documentation de plusieurs jours, qui peut vraiment vous arrêter dans vos traces.

À mon humble avis, de nombreuses entreprises ont une culture contraire aux objectifs de la programmation littéraire: elles veulent des résultats plus rapides (elles ne pleurent sur la qualité que lorsque l'application est en production). Dans ma propre expérience, mes patrons avaient refusé de comprendre que des résultats plus rapides ne signifient pas "un programme exécutable le lendemain de ma demande". Pour eux, si un développeur n'est pas occupé à taper sur son clavier, il ne travaille pas, c'est "perdre son temps dans un design insensé". Oui, je sais, mon patron est un trou du cul.

Les codeurs écrivent du code non anglais.

Les codeurs n'aiment pas écrire de la documentation car cela n'aide pas l'exécution du code.

Les codeurs ne sont pas bons pour rédiger de la documentation car c'est un moyen médiocre pour exprimer leurs idées.

La programmation alphabétisée semble être l'idée de faire passer la documentation au niveau supérieur où le code est plutôt une réflexion après coup. Peut-être que cela fonctionnerait, mais pour la plupart des codeurs, cela ressemble à une documentation désagréable.

Principalement parce que les gens sont TRÈS STUPIDES. Un témoignage évident dont est un flot incessant de suppositions et de malentendus exprimés par les jeunes sur la nature de cette technique simple.

Les gens considèrent LP comme: (a) une méthode de documentation (b) une méthode d'écriture d'essais raffinés qui nécessite des compétences ou des talents spéciaux (c) n'ont tout simplement aucune idée - en tant que créateur de l'éditeur de programmation Leo, de son propre aveu etc. etc. etc.

LP est cependant simplement: (1) écrire des programmes dans un mélange de code et de phrases dans un (= n'importe quel) langage humain, où ce dernier représente d'autres morceaux de code et / ou des phrases incluses. C'est précisément ce que font les auteurs d'innombrables manuels de programmation .. et (2) c'est un simple préprocesseur qui étend ces phrases chez l'homme (qui est devenu comme si les noms des sous-programmes inclus) pour démêler le résultat DANS L'ORDRE REQUIS PAR LE COMPILATEUR (ou interprète). Sinon, on peut développer le texte écrit avec un autre petit utilitaire pour inclure des symboles de mise en forme pour transformer la "source alphabétisée" en un joli texte lisible bien formaté.

Les jeunes n'essaient jamais cette idée extrêmement simple - et fantasment ou imaginent de fausses raisons pour lesquelles ils n'essaieront jamais ou ne le feront jamais.

Fondamentalement, l'idée principale de programmer "en pseudocode" écrit dans un langage humain et de l'étendre ensuite avec un simple utilitaire de préprocesseur AIDE À GÉRER L'ATTENTION (limité, une difficulté principale pour tout programme long), un peu comme le pliage de code ou la division de votre flux de programme en fonctions / sous-programmes, nécessaires pour que vous ne vous perdiez pas dans les détails, mais totalement inutiles pour l'exécution de la machine.

Il y a 2 aspects de la programmation littéraire que je ne souhaite ont été intégrés dans la programmation grand public - l' imagerie embarquée (par exemple, des schémas de conception) et des pointeurs vers des tentatives antérieures et alternatives (par exemple, « La raison pour laquelle il est comme ça parce que j'essayé cette autre façon et cela n'a pas fonctionné parce que ... "). Ces deux aspects peuvent être traités avec doc-comments et URI.

Parce que la logique des programmes ne fonctionne pas de la même manière que nous parlons. Un programme a un flux, des conditions et des boucles bien spécifiés.

Après avoir beaucoup codé, je pense en ces termes. Mon cerveau transforme les problèmes dans le domaine cible du code exécutable. Et il est beaucoup plus efficace pour moi d'écrire cela dans un langage de programmation habituel, que d'avoir à faire l'étape de transformation supplémentaire pour faire lire mes programmes.

En fait, je crois que mes programmes sont déjà alphabétisés ... identifiants parlants, bons noms de fonction, commentaires où j'ai fait du piratage que je ne comprendrais pas moi-même immédiatement après quelques mois.

Pour conclure: Mon code Java est plus lettré par lui-même que toute programmation "lettrée" veut l'être.

J'en suis venu à lire la programmation dans l'autre sens - j'ai rêvé d'avoir le code organisé comme il me convient, pas comme le compilateur l'exige. J'ai trouvé Leo presque idéal pour cela. Il prend également en charge le suivi des fichiers modifiés à l'extérieur. Ces fichiers ne doivent pas contenir de balisage spécial, je peux donc utiliser Leo pour moi-même sans que les autres membres de l'équipe le sachent. Cette fonctionnalité - "@shadow trees" - est très prometteuse, bien que toujours un peu boguée, a besoin de plus de globes oculaires. Et il résout également le problème «oh non, tout dans un gros fichier» à la fois en organisant tout en arborescence et en prenant en charge les fichiers externes.

Pour moi, contrairement à son nom, la "programmation lettrée" ne concerne pas du tout la documentation. Je n'ai pas plus de documentation qu'auparavant. Il s'agit d'avoir une structure qui m'aide à ne pas me perdre . Je le jure surtout lors de la gestion de fichiers JSP géants (et que malgré Leo était initialement destiné principalement à Python et qu'il ne prend pas en charge le langage JSP - je dois diviser le fichier en arbre Leo manuellement!).

Je le vois comme un outil pédagogique précieux, où une dissertation sur le code peut être écrite, puis des extraits de code de travail entrelacés pour informer les lecteurs sur les façons, quoi et pourquoi du code.

En dehors d'un environnement purement éducatif, je pense que seul Knuth comprend vraiment la meilleure façon de l'utiliser.

C'est le pire de tous les mondes - vous devez écrire un programme informatique très correct et très spécifique dans une langue très non spécifique = anglais. Vous devez donc l'écrire soigneusement en utilisant exactement les phrases correctes - vous pourriez donc aussi bien écrire du code.