Construire des programmes Agtweb

La programmation

Notions de programme et de macro

Lorsqu’on sait quelles opérations effectuer pour mettre en oeuvre un algorithme, on doit envisager d’automatiser ce processus en créant un programme. Avec AlgoTouch, le principe est d’enregistrer la séquence d’opérations de l’algorithme, le logiciel se chargeant de créer le programme associé automatiquement. Avec AlgoTouch, un programme ne sera pas une longue séquence d’instructions mais sera constitué d’un ensemble de séquences courtes appelées macros.

Une macro est donc une séquence d’instructions à laquelle on donne un nom. Cela devient une nouvelle instruction, d’où le nom de macro instruction. Donc au lieu de répéter cette séquence d’instructions, on peut exécuter directement la macro. Dans ce cas, toutes les instructions qu’elle contient sont exécutées comme une seule opération. Cette façon de faire permet d’une part de simplifier la conception d’un programme et d’autre part, de faciliter la compréhension d’un programme à condition que les macros portent des noms significatifs (Echange, Tri, Calcul, etc…).

Avec AlgoTouch, on distingue deux sortes de macros : les macros simples et les macro boucles. Les macros simples sont une suite d’instructions qui s’exécutent en séquence. Ce sont des affectations, des opérations, des conditionnelles (éventuellement imbriquées), des appels de macro. Les macros boucles contiennent une structure pour répéter une séquence d’instructions avec des conditions d’arrêt.

Un algorithme peut être construit avec plusieurs macros. Une macro peut aussi contenir un appel à une autre macro. Par contre, avec AlgoTouch, une macro ne peut pas s’appeler elle-même, et un message d’erreur est affiché à l’utilisateur. A noter que ce mécanisme (appelé récursivité) existe dans les langages de programmation moderne.

Macro simple

Le programme d’une macro simple se présente de la façon suivante :

MaMacro
Do
  instructions
// ...
End

Dans ce programme, MaMacro désigne le nom du programme. Ce nom pourra être modifié pour être plus parlant. Le bloc Do contient une ou plusieurs instructions associées aux manipulations effectuées par l’utilisateur : affectations, opérations, lectures ou écritures, conditions, appel de macro (voir plus loin).

Macro boucle

La structure d’une macro qui réalise une boucle unique possède la syntaxe suivante :
From
  instructions
  ...
Until
  (condition1)
  (condition2)
  ...
Loop
  instructions
  ...
Terminate
  instructions
  ...
End
Cette syntaxe est inspirée du langage Eiffel.

Comprendre la boucle

Comment interpréter le fonctionnement de la boucle ? On parle de sémantique de la boucle.
  • La partie From est exécutée une fois.
  • Ensuite, les conditions dans la partie Until sont testées en séquence. Une condition vérifiée indique de quitter la boucle.
  • Sinon, les instructions de la partie Loop sont exécutées
  • La partie Terminate contient des instructions qui doivent être exécutées lorsque la boucle a été effectuée.
Cas particulier : lorsque la partie Until est vide, la partie Loop est exécutée une seule fois.

Construction d’un programme

Enregistrement d’un bloc

Les blocs Do, From, Loop et Terminate peuvent être enregistrés. Une liste de choix sur la barre d’outils permet à l’utilisateur de sélectionner le bloc courant.

  1. choisir le bloc à enregistrer avec la liste de choix ou en cliquant dans la zone du programme correspondant.
  2. cliquer sur Clear pour effacer le bloc si nécessaire
  3. cliquer sur Record pour commencer l’enregistrement. Si le bloc n’est pas vide, les nouvelles instructions seront ajoutées à la fin du bloc.
  4. exécuter les actions à enregistrer. Le programme est maintenant produit dans la zone de programme, en plus de la console. Quand un test est utilisé (avec une balance), l’utilisateur n’enregistrera que les actions associées au cas spécifique.
  5. cliquer sur Stop pour terminer l’enregistrement.

Ré-exécution de bloc

  1. choisir le bloc à exécuter (Do, From, Loop, Terminate)
  2. cliquer sur Play  pour exécuter le code du bloc.  L’état du système est mis à jour.

Note : lors de l’exécution du bloc Loop, une exécution multiple doit être envisagée pour vérifier que la boucle opère correctement!

Un bloc avec une instruction conditionnelle peut contenir du code manquant dans la partie else. Si le code manquant doit être exécuté :

  1. le programme est interrompu et une balance vide réapparaît indiquant la raison (la condition à traiter) et demande à l’utilisateur d’enregistrer les actions associées
  2. le système active automatiquement le mode enregistrement.
  3. l’utilisateur enregistre la séquence d’actions
  4. cliquer sur pour terminer

Notes :

  • si aucune opération ne doit être effectuée dans le bloc manquant, l’utilisateur arrête directement l’enregistrement. Dans ce cas, le bloc else est supprimé puisqu’il est vide.
  • le bloc en cours d’exécution dans lequel le code manquant a été détecté, continuera l’exécution après l’enregistrement des nouvelles instructions par l’utilisateur.
  • il est possible d’inclure un test dans la séquence manquante. Cela produira une structure
    if (condition) { } else { }

    Le bloc else contiendra à nouveau du code manquant. L’utilisateur devra trouver un nouveau cas de test pour l’enregistrer.

Enregistrement d’une condition de sortie de boucle

Dans le cas d’une macro boucle, il faut définir la ou les conditions de sortie (bloc Until). Contrairement aux autres blocs, le principe est différent.

  1. Configurer le programme en cours de création dans un état où la boucle doit s’arrêter
  2. cliquer sur Erase pour effacer les conditions de sortie si nécessaire.
  3. cliquer sur Exit condition pour faire apparaître un comparateur sous la forme d’une balance avec l’icône pour annuler éventuellement l’opération.
  4. Placer les éléments à comparer sur les plateaux de la balance. Par exemple, si la boucle doit quitter car un index i a atteint la taille du tableau (a.length), placer i et a.length sur les plateaux. Lorsque deux valeurs sont placées, l’icône apparaît.
  5. Activez la balance par un clic gauche sur l’icône. La condition associée apparaît dans le bloc Until du programme, par exemple :
    Until (i==a.length)
  6. L’utilisateur est invité à changer (étendre) éventuellement la condition.
    • Par exemple, x>y peut être changé par x>=y ou par x!=y.
    • Autre exemple, i==a.length peut être changé par i>=a.length.

Note : Enregistrement de plusieurs conditions de sortie

Opérations de saisie et d’affichage

Opération de saisie de valeur (lecture)

  1. sélectionner la variable à affecter
  2. puis le menu Opération → Saisir valeur.
  3. une fenêtre de dialogue apparaît demandant de saisir la nouvelle valeur et la question qui doit être demandée à l’utilisateur lors de la ré-exécution de cette opération. Quand le programme est exécuté, une fenêtre de dialogue affichera la question et attendra la valeur à affecter à x.

Raccourcis :

  • effectuer un clic droit sur la variable.
  • déposer le clavier sur la variable

Note : si cette action est effectuée pendant un enregistrement, une instruction dite d’entrée est produite. Par exemple :

Read "Question " x

Opération d’affichage d’une valeur (écriture)

  1. sélectionner la variable à afficher
  2. puis le menu Opération → Afficher valeur
  3. une fenêtre de dialogue apparaît avec la valeur de la variable et le message qui doit être affiché lors de la ré-exécution de cette opération. Quand le programme est exécuté, une fenêtre de dialogue affichera le message et la valeur de x.

Raccourci :

  • déplacer la variable sur l’écran

Note : si cette action est effectuée pendant un enregistrement, une instruction dite de sortie est produite. Par exemple :

Write "Message " x

Opérations sur les macros

Créer une macro

  1. Menu Macro → Créer macro simple ou Créer macro boucle.
  2. l’utilisateur fournit un nom et un rôle, une macro du type choisi est créée.
    • La macro est représentée sur l’écran par un carré avec son nom. Au centre, apparaît une icône en forme de roue dentelée .
    • Cette macro devient la macro courante. Son code (avec des blocs vides) s’affiche dans la zone Instructions.
  3. Le ou les blocs de la macro peuvent être enregistrés.
Notes :
  • Une macro “voit” tous les éléments de l’algorithme courant (variables globales)
  • Une macro peut être renommée avec un identifiant approprié (menu Élément → Renommer). Le nom de la macro est mis à jour partout dans le code.
  • Le rôle de la macro peut être modifié lors du renommage.

Sélection de la macro courante

Pour  éditer une macro existante, sélectionnez la macro directement sur l’écran.
  • le programme de la macro apparaît dans la zone Instructions.

Renommage d’une macro

Comme les variables, les constantes, les variables index et les tableaux, les macros peuvent être renommées pour définir un identificateur plus explicite. Le rôle de l’élément peut également être redéfini.

  • Sélectionnez la macro
  • Menu Élément → Renommer
  • Tapez un nouveau nom et modifiez le rôle si nécessaire.

Note : la macro est renommée mais son nom est remplacé également dans les macros où elle est appelée.

Exécuter une macro

Pour exécuter entièrement une macro en mode manuel ou en mode enregistrement :

  1. sélectionner la macro sur l’écran
  2. choisir le menu Macro → Exécuter

Raccourci : effectuer un clic gauche sur l’icône au centre de la macro.

Le code entier de la macro est exécuté en une fois, puis l’affichage est mis à jour. Dans le cas de l’enregistrement d’une séquence, le nom de la macro apparaît dans le programme (c’est un appel).

Note sur le code manquant :
Lors de l’appel d’une macro, si celle-ci doit exécuter du code manquant, soit dans son code, soit dans le code d’une macro appelée, le programme s’arrête et produit le message “Bloc de code manquant”. L’utilisateur doit alors :

  1. sélectionner la macro concernée
  2. repérer le bloc responsable de l’erreur, celui qui contient encore un TODO
  3. définir le contexte adéquat pour atteindre le TODO
  4. exécuter le bloc

Le programme s’arrêtera pour enregistrer les instructions du bloc manquant.

Programmes erronés ou trop complexes

Un mauvais choix dans le critère d’arrêt d’une boucle peut entraîner une répétition infinie du corps. On parle de boucle infinie. Afin d’éviter que le programme AlgoTouch soit bloqué en attente de terminaison d’une telle boucle, l’exécution s’arrête automatiquement au bout d’un certain temps. En fait, si le nombre de blocs exécuté dépasse une certaine valeur (quelques milliers), ce qui correspond à quelques secondes d’attente. Le message suivant s’affiche : “Probable boucle infinie”. Ceci ne signifie pas forcément que le programme est erroné. Cependant, ne pas oublier qu’AlgoTouch est un outil à usage pédagogique destiné à mettre en place des algorithmes. Il n’a pas vocation à tester des algorithmes complexes qui nécessitent un temps de calcul important. 

Simplifier une macro boucle

Avec une macro boucle, il est possible de créer un programme qui ne nécessite pas de boucler. Dans ce cas, n’enregistrer qu’un bloc, par exemple le bloc Loop. Lorsque l’exécution est démarrée, le bloc de la boucle est exécuté une fois. Cependant, il est préférable d’utiliser une macro simple.

On peut transformer une macro boucle en macro simple. Il suffit de choisir le menu Macro → Simplifier. Le logiciel vérifie qu’il n’y a pas de conditions de sortie sinon il ne fait rien. Ensuite, toutes les instructions des blocs From, Loop et Terminate sont placées en séquence dans le bloc Do d’une macro simple.

Affichage du code dans différents langages

Pour voir le code de la macro en cours dans différents langages, choisir le menu Affichage → Afficher la zone d’exportation

Une nouvelle zone apparaît dans la partie droite. Choisir l’onglet associé au langage à afficher (Python, C, Java, C/C++). Le code de la macro est affiché dans le langage choisi.

Exécution d’un programme

Pour exécuter un programme intégralement (y compris la partie From, la partie Until, la partie Loop et enfin la parte Terminate dans le cas d’une macro boucle), cliquez sur le menu Macro → Exécuter macro courante ou sur l’icône central de la macro choisie.

On peut aussi exécuter le programme avec visualisation de son déroulement en cliquant sur les icônes suivants :

  1. Execution pour lancer le contrôle de l’exécution du programme
  2. Next “Bloc suivant” : le programme exécute le bloc suivant et met à jour l’affichage.
  3. Animate “Animation” : le programme est exécuté automatiquement mais s’arrête un certain temps à la fin de chaque bloc. L’affichage est mis à jour.
  4. Pause “Suspendre” : arrête le programme en mode animation. Cliquez sur “Bloc suivant” ou “Animation” pour continuer.
  5. Quit “Stop exécution” : quitte le mode exécution. Le système retourne en mode construction.

Fichiers et exports

Opérations sur fichier

  • Fichier → Nouveau : création d’un nouveau programme. Il contient quelques constantes et une macro nommée Main (qui signifie principal en anglais).

    Attention: avant de créer le nouveau programme, vérifier que le programme en cours a été enregistré sinon il est perdu.

  • Fichier → Ouvrir : charge un programme existant (extension de fichier .json)
  • Fichier → Enregistrer : enregistrer le programme en cours ou demander un nom si le programme est nouveau.
  • Fichier → Enregistrer sous : enregistrer le programme sous un nouveau nom

Exportation de programmes

AlgoTouch permet de transformer les programmes réalisés dans différents langages de programmation. La procédure est la suivante :

  • Fichier → Exporter …
  • une fenêtre apparait proposant d’exporter l’ensemble du programme (variables et macros) dans un ou plusieurs langages avec le même nom
  • enregistrement des programmes de toutes les macros.  La macro courante est considérée comme le point d’entrée du programme principal.

Les programmes produisent des fichiers texte dans les langages suivants :

  • AlgoTouch (extension .prg),
  • Java (extension .java),
  • Python (extension .py),
  • langage C (extension .c), 
  • langage C++ (extension .cc).  

Les codes produits sont directement exécutables dans les environnements adaptés.

Génération d’URL

Il est intéressant de pouvoir lancer directement AlgoTouch avec un programme déjà fait. L’idée, empruntée au système PythonTutor, consiste à utiliser le mécanisme de passage de paramètres associé à une adresse de site. Cela consiste à ajouter à l’adresse du site AlgoTouch, appelée URL pour Uniform Ressource Locator, le code d’un programme dans un format adapté.

 

Exemple de lancement d’un programme contenant une macro Do vide :

https://algotouch.irisa.fr/agt/?json=[["macroDo",0,0,"Main","Ex",{}]]

Pour créer cette URL, l’utilisateur doit :

  • créer le programme qu’il souhaite;
  • lancer
    Fichier -> Générer l'URL

    une adresse est copiée dans le presse-papier;

  • copier l’adresse obtenue, en fonction des besoins, dans le sujet d’un exercice, sur une page web ou dans un courriel par exemples.

Annexes

Règles de nommage

Les objets manipulés (variables, tableaux, macros) portent un nom qui doit respecter les règles suivantes :

  • il est constitué de lettres minuscules ou majuscules, de chiffres ou du caractère “_”
  • il doit commencer par une lettre
  • il ne doit pas être l’un des mots clé du langage AlgoTouch

Mots clés du langage AlgoTouch

Les mots clé suivants sont réservés au logiciel AlgoTouch. Ils ne doivent pas être utilisés pour nommer des éléments du programme.

  • int
  • char
  • const
  • index
  • if
  • else
  • Read
  • Write
  • Define
  • Do
  • From
  • Until
  • Loop
  • Terminate
  • End

Navigation

Retour sur l’Interface graphique

Retour sur la Manipulation de données