Outils de programmation visuels, pourquoi ne fonctionnent-ils pas directement avec l'AST?

25

J'ai trouvé plusieurs outils de programmation visuelle open source comme Blockly et ses amis, et d'autres projets hébergés chez Github, mais je n'ai trouvé aucun qui fonctionne directement avec l'arbre de syntaxe abstraite.

Pourquoi donc?

Je demande parce qu'une fois que j'ai découvert que chaque compilateur a une phase dans le processus de compilation où il analyse le code source en AST, il était évident pour moi que certains outils de programmation visuels pourraient en profiter pour donner au programmeur des moyens pour éditer l'AST directement de manière visuelle, et aussi pour faire l'aller-retour de la source au nœud-graphe, puis de nouveau à la source si nécessaire.

Par exemple, on pourrait penser que du visualiseur JavaScript JavaScript à un véritable outil de programmation visuelle JavaSript, il n'y a pas trop de différence.

Alors, qu'est-ce que je manque?

rraallvv
la source
10
Les AST sont très verbeux et peu pratiques pour la programmation. Ils ont été conçus pour les compilateurs, pas pour les programmeurs.
Yuval Filmus
1
Qu'entendez-vous par «travailler directement avec l'arbre de syntaxe abstraite»? On peut dire que tous les outils basés sur des blocs comme Blockly modifient l'AST: ils représentent les bords par imbrication (ou empilement, si vous préférez le voir de cette façon), et l'utilisateur peut modifier l'arborescence par (par exemple) glisser-déposer.
Michael Homer
C'est une grande question que beaucoup d'entre nous qui aimons les compilateurs ont eu. Je pense que la réponse courte est que si vous pouviez faire cela et le rendre convivial, les gens l' utiliseraient. Le seul problème est que c'est un gros "si".
Mehrdad
2
Avez-vous regardé Lisp ? "[Ce n'est pas] tant que Lisp a une syntaxe étrange que Lisp n'a pas de syntaxe. Vous écrivez des programmes dans les arbres d'analyse qui sont générés dans le compilateur lorsque d'autres langues sont analysées. Mais ces arbres d'analyse sont entièrement accessibles à vos programmes. Vous pouvez écrire des programmes qui les manipulent. "
Wildcard

Réponses:

28

Un grand nombre de ces outils font travailler directement avec l'arbre de syntaxe abstraite (ou plutôt, une visualisation unique à une directe de celui - ci). Cela inclut Blockley, que vous avez vu, et les autres langues basées sur des blocs et des éditeurs comme il ( Scratch , Crayon code / Droplet , Snap! , GP , sol carrelé grâce , etc.).

Ces systèmes ne présentent pas de représentation traditionnelle des graphes des sommets et des arêtes, pour des raisons expliquées ailleurs (espace et difficulté d'interaction), mais ils représentent directement un arbre. Un nœud, ou bloc, est l'enfant d'un autre s'il se trouve directement, physiquement à l'intérieur du parent.


J'ai construit l'un de ces systèmes ( Tiled Grace , papier , papier ). Je peux vous assurer que cela fonctionne directement avec l'AST: ce que vous voyez à l'écran est une représentation exacte de l'arbre de syntaxe, sous forme d'éléments DOM imbriqués (donc, un arbre!).

Capture d'écran du code imbriqué Tiled Grace

Il s'agit de l'AST d'un code. La racine est un nœud d'appel de méthode "for ... do". Ce nœud a des enfants, en commençant par "_ .. _", qui a lui-même deux enfants, un nœud "1" et un nœud "10". Ce qui apparaît à l'écran est exactement ce que le backend du compilateur recrache au milieu du processus - c'est fondamentalement comment le système fonctionne.

Si vous le souhaitez, vous pouvez le considérer comme une disposition d'arbre standard avec les bords pointant vers l'écran vers vous (et occlus par le bloc en face d'eux), mais l'imbrication est une manière aussi valide de montrer un arbre comme un sommet diagramme.

Il "effectuera également l'aller-retour de la source au nœud-graphique, puis reviendra à la source si nécessaire". En fait, vous pouvez voir cela se produire lorsque vous cliquez sur "Affichage du code" en bas. Si vous modifiez le texte, il sera ré-analysé et l'arbre résultant sera rendu pour que vous puissiez le modifier à nouveau, et si vous modifiez les blocs, la même chose se produit avec la source.


Pencil Code fait essentiellement la même chose avec, à ce stade, une meilleure interface . Les blocs qu'il utilise sont une vue graphique du CoffeeScript AST. Il en va de même pour les autres systèmes basés sur des blocs ou des tuiles, bien que certains d'entre eux ne rendent pas l'aspect d'imbrication aussi clair dans la représentation visuelle, et beaucoup n'ont pas de véritable langage textuel derrière eux, donc le " arbre de syntaxe "peut être un peu illusoire, mais le principe est là.


Qu'est - ce que vous manque, alors, est que ces systèmes vraiment sont travaillent directement avec l'arbre de syntaxe abstraite. Ce que vous voyez et manipulez est un rendu économe en espace d'un arbre, dans de nombreux cas littéralement l'AST produit par un compilateur ou un analyseur.

Michael Homer
la source
6

Au moins deux raisons:

  1. Parce que le code source est une représentation beaucoup plus concise. La présentation d'un AST sous forme de graphique occuperait beaucoup plus d'espace visuel.

    Les programmeurs apprécient d'avoir autant de contexte que possible - c'est-à-dire d'avoir autant de code présent en même temps sur l'écran en même temps. Le contexte les aide à mieux gérer la complexité. (C'est une des raisons pour lesquelles de nombreux programmeurs utilisent ces petites polices folles et ces énormes écrans de 30 pouces.)

    Si nous essayions d'afficher l'AST sous forme de graphique ou d'arbre, la quantité de code que vous pourriez insérer sur un seul écran serait beaucoup moins importante que lorsqu'elle est représentée sous forme de code source. C'est une énorme perte de productivité pour les développeurs.

  2. Les AST sont destinés à la programmation de compilateurs, pas à une compréhension facile par les programmeurs. Si vous preniez une représentation AST existante et la visualisiez visuellement, il serait probablement plus difficile à comprendre pour les développeurs, car les AST n'étaient pas conçus pour être faciles à apprendre pour les développeurs.

    En revanche, le code source est généralement conçu pour être lisible / compréhensible par les développeurs; il s'agit normalement d'un critère de conception critique pour le code source, mais pas pour les AST. Les AST ne doivent être compris que par les rédacteurs du compilateur, et non par les développeurs de tous les jours.

    Et, dans tous les cas, la langue AST serait une seconde langue que les développeurs devraient apprendre, en plus de la langue source. Pas une victoire.

Voir également /software//q/119463/34181 pour d'autres raisons potentielles.

DW
la source
2
"En revanche, le code source est conçu pour être lisible / compréhensible par les développeurs" - contre-exemple: la plupart des esolangs, Perl, Lisp
John Dvorak
1
"Parce que le code source est une représentation beaucoup plus concise."; "La langue AST serait une langue seconde que les développeurs devraient apprendre, en plus de la langue source" - ce sont des arguments contre tous les PL visuels, mais cela n'aide pas à expliquer la distinction qui préoccupe l'OP.
Raphael
"(C'est une des raisons pour lesquelles de nombreux programmeurs utilisent ces petites polices folles et d'énormes écrans de 30".) "- si vous avez besoin d'un écran à gros cul pour afficher suffisamment de contexte, peut-être que vous codez en spaghetti?;)
Raphael
1
@Raphael Peut-être, mais c'est moins d'efforts pour y jeter de l'argent que de refactoring!
Kroltan
3
@JanDvorak, ... LISP est un contre-exemple parce que l'AST est le langage - ce qui lui donne son pouvoir expressif; écrire du code LISP qui recompile votre autre code LISP est aussi simple que d'écrire du code qui modifie les structures de données LISP standard ... qui sont exactement ce dans quoi le code LISP est écrit . Il y a une raison pour laquelle cela a duré plus d'un demi-siècle - le design de la famille est inhabituellement expressif. Go devait avoir ses extensions asynchrones plongées profondément dans la langue et le runtime; pour Clojure, c'est juste une bibliothèque. Voir aussi: Battre les moyennes .
Charles Duffy
3

L'AST typique des compilateurs est plutôt complexe et détaillé. La représentation graphique dirigée deviendrait rapidement assez difficile à suivre. Mais il existe deux grandes zones de CS où les AST sont utilisés.

  1. Les langages Lisp sont en fait écrits comme AST. Le code source du programme est écrit sous forme de listes et directement utilisé par le compilateur et / ou l'interpréteur (selon la variante utilisée).
  2. Les langages de modélisation, par exemple UML, et de nombreux langages spécifiques au domaine visuel utilisent des notations graphiques qui sont des graphes de syntaxe abstraite efficaces (ASG) à un niveau d'abstraction plus élevé que le langage à usage général typique AST.
CyberFonic
la source