Historique

Les deux voies de recherche initialement explorées ont été d’une part une approche visuelle des lan-gages de programmation traditionnels, et d’autre part des approches plus innovantes comme la program-mation par démonstration. Ces systèmes se sont souvent révélés intéressants mais ont vite rencontré de gros problèmes lors de leur emploi dans des projets de taille réaliste, ce qui les a cantonnés au statut de “langages jouets”. Les VPLs ont ainsi été considérés comme impropres à effectuer des tâches de taille réaliste.

De nombreux travaux ont été effectués avec un certain succès pour essayer de résoudre ces problèmes, comme par exemple n’utiliser les langages visuels qu’à certains stades du développement d’un

pro-Paradigmes 57 gramme ou encore spécialiser ces langages pour des domaines d’application bien définis. Il existe ce-pendant toujours de nombreux problèmes comme le facteur d’échelle (scalability) ou la lisibilité des programmes et le défi original, c’est-à-dire proposer des VPLs assez expressifs et généraux pour aborder une gamme de problèmes de programmation toujours croissante, est toujours un sujet actif de recherche. On trouve néanmoins aujourd’hui des VPLs commerciaux spécialisés, comme LabVIEW [11], ou plus généraux, comme Prograph [65], qui ont une base conséquente d’utilisateurs.

3.3 Paradigmes

Les VPLs ayant moins de restrictions sur la façon d’exprimer les programmes d’un point de vue syn-taxique, il devient possible d’explorer de nouveaux mécanismes de programmation qui n’étaient pas envisageables dans le passé mais qui sont rendus possibles aujourd’hui par la montée en puissance des processeurs et des cartes vidéo qui permet l’utilisation d’interfaces graphiques haute-résolution et d’en-vironnements supportant le multi-fenêtrage (métaphore du bureau) [91].

Le but principal de la recherche sur les VPLs est d’améliorer le processus de création de programmes informatiques tout en réduisant les efforts mentaux du programmeur. Il s’agit de : 1orendre la program-mation accessible à une certaine catégorie de personnes (qui ne sont pas forcément des programmeurs, mais par exemple des personnes ayant des connaissances dans le domaine du problème à résoudre) 2o améliorer la justesse, au premier sens du terme, de la programmation, 3o améliorer la vitesse à la-quelle la tâche de programmation est accomplie (productivité).

Les stratégies mises en œuvre pour arriver à ces fins sont les suivantes [43] :

– être concret : c’est-à-dire essayer d’exprimer certains aspects du programme au moyen d’ins-tances ;

– être direct : l’utilisateur doit avoir l’impression de manipuler directement des objets par ses ac-tions ;

– être explicite : un aspect de la sémantique est explicite dans l’environnement s’il est déclaré direc-tement (textuellement ou visuellement), sans que le programmeur n’ait à l’inférer ;

– fournir un retour visuel immédiat : afficher automatiquement les conséquences de l’édition de parties du programme. Le terme liveness [205] catégorise l’immédiateté avec laquelle un retour sémantique visuel est automatiquement fourni pendant l’édition. Les différents degrés de liveness sont décrits dans la section 3.4.2.

Les sections suivantes dressent un panorama des différents paradigmes existants, en illustrant chacun d’eux par un ou plusieurs exemples.

3.3.1 Flot de contrôle

L’approche flot de contrôle (controlflow) consiste à représenter graphiquement les structures de contrôle communément rencontrées dans les langages de programmation textuels, telles que les boucles, les appels

FIG. 3.6 : VIPR, Représentations statique et dynamique des instructions séquentielles s1, s2 et s3

de procédures, les branchements conditionnels et le parallélisme. Cette approche peut donc être consi-dérée comme une transposition directe dans le domaine visuel de langages de programmation textuels conventionnels.

VIPR

VIPR [104, 52] est un langage de programmation visuel utilisant la topologie pour coder sa séman-tique, les relations topologiques utilisées étant l’imbrication des cercles et la connection des objets. Des dimensions visuelles comme la taille ou la couleur des objets ne codent pas de sémantique. Il est inspiré de Pictorial Janus [131], mais modélise des constructions impératives conventionnelles. Une étape de computation est représentée (figure 3.6) par la fusion de deux cercles. Un anneau contenant un label op-tionnel représente une condition (figure 3.7a). Le résultat de la fusion de deux cercles est l’exécution de l’action associée au cercle le plus intérieur des deux fusionnés. Ces actions peuvent être des instructions d’affectation ou des déclarations d’entrée/sortie. La figure 3.7b illustre un appel de fonction.

Comme le montre la figure 3.8, les programmes VIPR deviennent rapidement complexes et difficiles à lire, ce qui rend le langage assez peu résistant au facteur d’échelle (section 3.4.1). L’environnement propose des mécanismes de navigation qui agrandissent (zoom) les parties du programme éditées ou s’exécutant. Il est aussi possible de paramétrer le niveau de détail d’une vue. Malgré cela, il semble difficile d’obtenir une vue globale du programme et de comprendre son but, les entités occupant beaucoup de place et la représentation des structures de contrôle étant peu intuitives.

VamPict

VamPict [12] est un langage très simple utilisé pour illustrer la spécification d’un langage basé sur le paradigme du flot de contrôle en VAMPIRE (section 3.3.3), un langage visuel pour la spécification d’autres langages de programmation visuels.

Paradigmes 59

FIG. 3.7 : VIPR, Structures de contrôle

FIG. 3.9 : Vampire : saisie de a puis b, calcul de c, affichage de c

La figure 3.9 donne un exemple de programme VamPict. Ce programme demande à l’utilisateur d’en-trer deux valeurs dont il calcule et affiche le produit. Une partie de la spécification VAMPIRE du langage VamPict est décrite dans la section 3.3.3. Le programme s’exécute en fonction des règles de réécriture visuelles exprimées en VAMPIRE. Dans le cas de VamPict, le flot est orienté du haut vers le bas, de la gauche vers la droite (le carré entourant l’instruction de calcul du produit représente le curseur d’exécu-tion).

Les langages basés sur ce paradigme peuvent aussi adopter une représentation diagrammatique (boîtes reliées par des flèches). Le flot de contrôle est adapté aux problèmes de contrôle réactif (réaction à des événements). Les données sont souvent représentées et manipulées sous forme textuelle, limitant l’apport d’une représentation visuelle aux seules structures de contrôle ; mais celles-ci n’étant souvent pas très intuitives (la représentation visuelle d’entités abstraites n’est pas évidente et s’avère souvent plus lourde que l’équivalent textuel), l’intérêt de ce paradigme est limité. Il peut néanmoins être intéressant, par exemple dans le cadre de l’animation d’algorithme (but éducatif).

3.3.2 Flot de données

Le flot de données (dataflow) est l’approche la plus utilisée dans les produits commerciaux. Un pro-gramme dataflow est constitué d’un réseau d’objets représentant des opérations. Chaque objet possède un (ou plusieurs) port(s) par lequel les données arrivent (ports d’entrée). Les résultats des opérations sont envoyés par d’autres ports (ports de sortie) vers d’autres objets. Ceux-ci sont reliés par des segments qui symbolisent des conduits par lesquels transitent les données. Les états des différents composants sont donc modifiés au cours du temps. La figure 3.10 montre un exemple de programme dans le langage com-mercial LabVIEW détaillé plus loin. Avec le paradigme du flot de données, le programmeur se concentre sur les relations entre données, pas sur la manière d’effectuer les opérations. Dans une approche dataflow

Paradigmes 61

LabVIEW [127, 136] est un langage visuel commercial de National Instruments Corp., fourni avec une importante librairie de fonctions prédéfinies et de composants d’interaction. Conçu initialement en 1986 pour l’acquisition et le traitement de données, il a évolué vers un langage plus général, permet-tant d’effectuer des simulations ou encore du traitement d’image grâce à des librairies spécialisées. Les programmes LabVIEW rappellent fortement des schémas de circuits électroniques, avec la possibilité d’associer des boutons et des afficheurs avec les différents composants du programme, ce qui rend le langage accessible à des électroniciens n’ayant pas forcément une grande expérience en programmation. Les flots de données sont typés (nombres, booléens, chaînes de caractères, tableaux). Ces types sont re-flétés visuellement par le motif et la couleur de la ligne représentant le flot. Le langage possède certaines structures de contrôle : branchements conditionnels, boucles et séquences, exprimées par l’imbrication des composants. La figure 3.10 représente un programme pour la génération de signaux. Le programme comprend notamment une boucle for et des branchements conditionnels. Dans un programme LabVIEW, une seule alternative est visible à la fois. La figure montre, pour les cinq tests présents, le code exécuté dans le cas où le booléen s’évalue à vrai (true).

Tous les composants et structures de contrôle peuvent être regroupés dans des abstractions appelées VIs (virtual instruments). Les VIs peuvent eux-mêmes être composés d’autres (sub-)VIs, pouvant être sauvés et réutilisés dans d’autres programmes. Le langage est intuitif pour qui est habitué aux circuits électroniques et permet en général d’avoir une compréhension globale du programme, principalement grâce aux virtual instruments. La séparation entre composants du programme lui-même et leurs interfaces respectives apporte aussi de la clareté.

Prograph

Prograph [66, 65] est un langage de programmation visuel orienté objet. Les classes, les méthodes et les attributs sont créés et modifiés par manipulation directe d’icônes à l’écran. L’environnement de Prograph est composé d’un éditeur, d’un interpréteur, d’un debuggeur et d’un compilateur.

Prograph propose des constructions pour spécifier des itérations, des branchements conditionnels, des opérations séquentielles ou parallèles. La figure 3.11 montre le browser de classes ; la figure 3.12 illustre deux méthodes de la classe Index : Sort et BuildValue. Le corps des méthodes est spécifié par un réseau d’icônes reliées entre elles reposant sur le paradigme du dataflow (le flux de données est orienté de haut en bas). L’accès au corps d’une méthode s’effectue par double-clic sur l’icône représentant son appel,

Paradigmes 63

FIG. 3.11 : Browser de classe Prograph

FIG. 3.12 : Exemple de méthodes Prograph

ou par le browser de classes. Toutes les méthodes possèdent une barre horizontale en haut de la fenêtre, représentant le flot d’entrée, et une barre similaire en bas de la fenêtre représentant le flot de sortie. La sémantique d’une opération varie en fonction de la forme de l’icône la représentant. Par exemple l’icône gauche de la figure 3.13 représente l’opération d’accès à un attribut, alors que la droite appelle une méthode. Pour plus de détails, voir [65].

L’éditeur fournit des mécanismes d’aide à la spécification qui limitent les erreurs syntaxiques. Il n’est par exemple pas possible de créer des connections incorrectes. L’exécution d’un programme est animée, surlignant les éléments responsables d’une erreur.

FIG. 3.14 : Cocoa wall-climber

Les langages basés sur ce paradigme peuvent être plus ou moins assimilés à des langages déclaratifs (contrairement aux langages basés sur le flot de contrôle qui sont impératifs), puisqu’ils ne requièrent pas que le programmeur se concentre sur les aspects contrôle du programme. Ces langages permettent de faire des abstractions au niveau des données et des procédures, comme les VIs (virtual instruments) de LabVIEW (voir section 3.3.2). Il est par contre difficile de gérer les événements et réactions associées dans des langages uniquement basés sur le dataflow puisqu’ils nécessitent un minimum de contrôle quant à l’ordonnancement des opérations.

3.3.3 Systèmes de règles

Le paradigme basé sur les systèmes de règles est très proche de son équivalent textuel. Le système est dans un certain état ; un ensemble de règles transforme cet état en un autre état. Chaque règle est composée d’une précondition (partie gauche) et d’une spécification de transformation (partie droite) à exécuter si la précondition est vérifiée. Les cas de conflits (plusieurs règles pouvant s’appliquer à un instant t) peuvent se résoudre de différentes manières. La plus simple consiste à appliquer la première règle rencontrée ; mais il est aussi possible d’assigner des priorités aux règles manuellement ou encore de calculer dynamiquement suivant un critère quelle règle doit être appliquée. On introduit alors un peu de contrôle dans une approche initialement déclarative.

Parmi les langages de programmation visuels basés sur les systèmes de règles, on peut citer Cocoa [197], destiné aux enfants, maintenant appelé Stagecast Creator [67]. Dans l’exemple de la figure 3.14, le personnage suit les règles définies dans la fenêtre Mascot1. La partie gauche des règles représente la précondition, la partie droite représente la transformation. On peut aussi mentionner Altaira [90] et Roadsurf [233].

Paradigmes 65 VAMPIRE (Visual Metatools for Programming Iconic Environments, [157]) est un outil de génération de systèmes de programmation icôniques lui-même implémenté comme un langage icônique2et basé sur un système de règles de réécriture graphiques.

La figure 3.15 présente les règles de réécriture qui permettent de définir l’évolution dynamique des constructions visuelles de VamPict, langage basé sur le paradigme du flot de contrôle et décrit précédem-ment. Ces règles sont respectivement Orientation du flot du haut vers le bas, Orientation du flot de la gauche vers la droite, Condition de lancement du flot de contrôle et Condition d’arrêt du flot de contrôle. La figure 3.16 illustre quant à elle Saisie textuelle d’une valeur d’entrée, Affichage d’une variable de sortie et Réalisation d’un calcul numérique simple (produit). Le carré en surimpression symbolise l’icône active. Chaque membre d’une règle possède deux fenêtres : l’une pour les paramètres visuels, l’autre pour les attributs textuels et le code SmallTalk associé.

Il peut être difficile de comprendre un programme basé sur ce paradigme dans son ensemble, puisqu’il n’y a pas réellement de vision globale de ce qu’il fait. Le choix et l’ordre d’exécution des règles ne sont visibles que lors de son déroulement. Au niveau de la conception des langages visuels, P. Bottoni [33] propose une formalisation des sessions de dialogue homme/machine par un langage visuel et montre comment des systèmes de réécriture peuvent être utilisés pour spécifier les aspects computationnels et graphiques d’un langage visuel.

3.3.4 Langages de requête

Un paradigme assez proche du précédent est celui des langages visuels permettant d’exprimer des requêtes sur des bases de données. Le terme langage de requête visuel regroupe plusieurs choses différen-tes :

– des requêtes sur des bases de données pour retrouver des images ou des animations, que ce soit de manière textuelle ou visuelle,

– des interfaces graphiques aidant à la construction de requêtes textuelles (SQL,. . . ) comme Micro-soft Access [159],

– des requêtes exprimées au moyen de primitives graphiques (partie qui nous intéresse) pour l’inter-rogation de bases de données.

Parmi ces derniers, on peut citer les travaux de M. Andries et G. Engels [8] qui proposent un langage de requête mixant des primitives textuelles et graphiques. Le modèle sous-jacent est l’EER (modèle entité relation étendu), mais devrait pouvoir s’adapter à n’importe quel type de base de données. Le but de ce langage est de combiner les avantages des requêtes textuelles et des représentations graphiques. Ainsi, la structure d’une requête est toujours de la forme select-from-where, avec possibilité d’exprimer les clauses soit de manière textuelle soit de manière visuelle. La figure 3.17 illustre une requête simple permettant de retrouver les noms et âges des personnes ayant au moins 18 ans.

2La plupart des langages visuels sont implémentés au moyen de langages textuels conventionnels. VAMPIRE permet la spécification d’un langage visuel de manière visuelle.

Paradigmes 67

FIG. 3.16 : Règles Vampire pour les opérations

permettant d’exprimer des requêtes sur des documents structurés et de réorganiser les résultats dans des structures telles que des listes ou des groupes3. XML-GL est étudié plus en détails dans le chapitre 4, ainsi que le langage de M. Erwig [86], et celui de K. Zhang [238].

Enfin, il existe plusieurs langages spécialisés dans certains types de requêtes comme ceux pour les systèmes d’information géographique. Dans [84], il est possible d’exprimer des requêtes en créant une ébauche des configurations topologiques voulues. Le système est capable de relâcher les contraintes de placement des objets ; il est possible d’utiliser les notions d’orientation, de relations spatiales entre ob-jets (traverse, recouvre, proche de) et de distance pour exprimer des requêtes plus ou moins précises. Dans ce cas, l’utilisation d’un langage visuel réduit de manière très significative la complexité de la requête, puisque les contraintes exprimées dans celle-ci sont de nature visuelle, donc multidimension-nelles. D’autre part, la correspondance entre les éléments du langage visuel et les contraintes à exprimer est directe (closeness of mapping, cf section 3.4.2), ce qui rend le langage très intuitif.

3.3.5 Programmation par démonstration

L’exemple de programmation par démonstration le plus basique est le système de macro de Microsoft Word, qui permet à l’utilisateur d’enregistrer une séquence d’actions à répéter automatiquement. Un exemple un peu plus complexe est l’éditeur d’interface graphique, qui permet de spécifier l’interface d’un programme par manipulation directe de ses composants. Ce type de système est intéressant car il augmente la facilité, et par conséquent la vitesse avec laquelle l’interface est spécifiée. Le code source permettant de créer cette interface est généré automatiquement à partir de la spécification visuelle de l’utilisateur, par exemple en Java.

Mais il existe aussi des systèmes beaucoup plus complexes capables d’inférer des programmes en généralisant les actions de l’utilisateur effectuées sur des données réelles [171], en utilisant par exemple des techniques d’intelligence artificielle. Ces systèmes permettent à des utilisateurs de créer des procédu-res générales sans avoir à programmer.

Toontalk

Toontalk [148] est un environnement interactif décrivant un monde animé, rappelant un jeu vidéo, dans lequel les enfants peuvent créer des programmes en agissant sur des objets. Ces objets représentent

Paradigmes 69

FIG. 3.18 : Toontalk : entrainement d’un robot

les différentes abstractions computationnelles disponibles. Par exemple (figure 3.18), un robot représente une méthode, une balance représente une comparaison (test) et un oiseau représente un envoi de message. Les structures de données telles que les vecteurs et tableaux sont représentées par des boîtes comparti-mentées dans lesquelles peuvent être placés d’autres objets. La généralisation des programmes s’effectue en supprimant de manière explicite certains détails fournis lors de la démonstration.

La plupart des systèmes de programmation par démonstration ne proposent pas de représentation vi-suelle du programme inféré, ce qui empêche toute action d’édition, sachant que l’inférence peut se révéler incorrecte. Il est donc difficile de savoir si le programme est correct et de corriger les erreurs. Ils de-mandent d’autre part à l’utilisateur d’envisager le processus de “programmation” d’une manière très dif-férente comparée aux méthodes de programmation conventionnelles. La programmation par démonstra-tion peut être intéressante pour des utilisateurs ne voulant pas apprendre à programmer, mais risque de dérouter les personnes ayant un peu d’expérience, voir d’engendrer des frustrations notamment du fait que le contrôle qu’a l’utilisateur sur la spécification et donc l’expressivité est nettement plus limité.

Pursuit

Pursuit [167] est un environnement de programmation visuel orienté shell puisqu’il est dédié à la manipulation de fichiers. Pursuit fournit un retour à l’utilisateur quant au programme inféré en affichant les opérations par des changements sur les objets représentant les données (fichiers, répertoires,. . . ). Si le système a inféré des opérations de manière incorrecte, il est possible d’éditer le programme.

Le système est capable d’inférer des boucles et des branchements conditionnels. La dimension couleur des objets graphiques a la même fonction que les noms de variables dans les langages textuels. Dans ces derniers, les noms de variables représentent des données. Les opérations sur ces variables affectent les données, mais pas leur nom. Dans Pursuit, les opérations sont traduites visuellement par un changement de la représentation des icônes liées aux données. La couleur n’étant pas utilisée pour traduire les opé-rations, elle permet d’identifier de manière unique un objet graphique représentant une certaine donnée

malgré le fait que son apparence change au cours du temps. Le fait que l’œil humain ne puisse

Dans le document Environnements et langages de programmation visuels pour le traitement de documents structurés (Page 57-72)