Construire des programmes

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.

Notion de macro simple

Le programme d’une macro simple possède un nom et la liste des instructions qui la composent, à raison d’une instruction par ligne sauf dans le cas d’une alternative (voir plus loin).

Il se présente de la façon suivante :

Define MyMacro
Do
  instruction
ou alternative
... // ... End

Détail d’une macro simple

  • MyMacro désigne le nom de la macro. 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);
  • l’instruction End permet d’indiquer la fin de la description de cette macro.

Concept de macro boucle

Une macro boucle doit permettre de répéter une suite d’instructions, encore faut-il:

  • définir ce qu’il faut faire en préambule à la répétition;
  • quand l’arrêter;
  • quelles instructions répéter;
  • et que faire pour finir.

La structure d’une telle macro est donc plus complexe qu’une macro simple.

Syntaxe de la boucle

Define MyMacro
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 ? Le terme couramment utilisé est “sémantique de la boucle”:

  • la macro possède un nom (pour pouvoir l’appeler dans une autre macro par exemple);
  • le bloc From est exécuté une fois;
  • ensuite, les conditions dans le bloc Until sont testées en séquence. Une condition vérifiée indique de quitter la boucle;
  • sinon, le bloc Loop est exécuté (toutes ses instructions);
  • le bloc Terminate contient des instructions qui doivent être exécutées lorsque la boucle a été effectuée;
  • comme dans le cas de la macro simple, l’instruction End permet d’indiquer la fin de la description de cette macro.

Cas particulier :

lorsque le bloc Until est vide, le bloc Loop est exécuté une seule fois.

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 un bouton  qui permet de l’exécuter directement;
    • 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 peut utiliser tous les éléments de l’algorithme courant (variables globales);
  • le nom et le rôle de la macro peuvent être modifiés.

Construction d’un programme

Avec AlgoTouch, le principe pour construire un programme est d’enregistrer la séquence d’opérations de l’algorithme, le logiciel se chargeant de créer le programme associé automatiquement. 

L’utilisateur crée d’abord une macro puis enregistre successivement le ou les blocs qui la composent, ou simplement des instructions à l’intérieur d’un bloc.

Ensuite, il peut exécuter la séquence ainsi enregistrée pour vérifier son fonctionnement.

Enregistrement et exécution

Enregistrement d’un bloc

L’utilisateur peut enregistrer les blocs Do, From, Loop, Terminate:

  1. choisir le bloc d’instructions à enregistrer en cliquant sur son nom 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;
  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.

Note:

si le bloc n’est pas vide, les nouvelles instructions seront ajoutées au début du bloc. Cependant, on peut enregistrer des instructions n’importe où dans un bloc  comme indiqué ci-dessous.

Enregistrement d’une séquence d’instructions

L’utilisateur peut enregistrer des instructions à l’intérieur des blocs. Le principe est sensiblement le même que dans le cas de l’enregistrement d’un bloc:

  1. cliquer sur la ligne à partir de laquelle les instructions vont être enregistrées;
  2. cliquer sur Record pour commencer l’enregistrement;
  3. exécuter les actions à enregistrer;
  4. cliquer sur Stop pour terminer l’enregistrement.

Enregistrement d’une alternative

L’objectif est de comparer le contenu de deux variables (variable, constante, variable index, index). Comparons par exemple avec y. La procédure est la suivante:

  • cliquer sur Scale  pour faire apparaître une balance avec deux plateaux;
  • glisser la valeur sur le plateau de gauche;
  • glisser la valeur sur le plateau de droite. L’icône de la balance est modifié Activate  indiquant que la comparaison peut être effectuée. A ce stade, il est encore possible de modifier l’une ou l’autre valeur sur l’un des plateaux;
  • cliquer surActivate  pour activer la balance. Les plateaux bougent si les deux valeurs sont différentes. La plus grande valeur est la plus lourde. Le résultat de la comparaison est affiché sur la fenêtre de la balance (par exemple x > y);
  • l’utilisateur est invité à modifier (étendre) éventuellement la condition:
    • x > y peut être changé par x >= y ou par x != y
    • x == y peut être changé par x >= y ou par x <= y
    • après validation, l’instruction de la condition associée est affichée dans le programme. Par exemple:
          if (x > y){ 
      
  • ensuite, l’utilisateur effectue la ou les instructions associées à ce cas. Toutes les instructions sont autorisées y compris les comparaisons;
  • lorsqu’il a terminé, il clique sur  Close .

Programme d’une alternative

Suite à l’enregistrement de l’alternative, plusieurs lignes de code sont produites dans le programme. Le programme contient le test, suivi des instructions associées si le test est valide, puis le bloc else associé au test. Ce bloc ne contient pas de code effectif puisque ce cas n’a pas été encore traité.

Exemple d’alternative

Comparons x avec y. Si x est strictement supérieur à y, incrémentons x et affectons y avec 2 fois la valeur de x. Le programme associé est le suivant:

    if (x > y){ 
       x = x + 1 ;
       y = x * 2 ;
    } else { 
        // TODO 
        // x >= y
    }

Exécution d’une instruction ou d’un bloc

    • choisir la ligne ou le bloc à exécuter (Do, From, Until, Loop, Terminate);
    • cliquer sur   pour exécuter le code du bloc ou de la ligne.  L’état du système est mis à jour.
    Plusieurs cas sont à envisager:
    • dans le cas d’une ligne, le curseur se positionne sur l’instruction suivante du programme à exécuter;
    • dans le cas d’un bloc, le curseur se positionne sur le bloc à exécuter en suivant la logique du programme.

Exécution avec code manquant

Une instruction conditionnelle ou 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.

Exécution avec macro vide

Si une séquence d’instructions appelle une macro vide  soit directement , soit indirectement depuis un appel de macro:

  1. le programme est interrompu et un message apparaît indiquant la raison (avec le nom de la macro) et demande à l’utilisateur d’exécuter les actions associées;
  2. l’utilisateur exécute la séquence d’actions (ce que devrait faire la macro);
  3. clique sur  pour terminer.

Le programme reprend son cours normal.

 

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 le bloc Until;
  3. cliquer sur  pour effacer les conditions de sortie si nécessaire;
  4. cliquer sur pour enregistrer une condition de sortie. Un comparateur apparait sous la forme d’une balance avec l’icône pour annuler éventuellement l’opération;
  5. 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), il faut placer i et a.length sur les plateaux. Lorsque deux valeurs sont placées, l’icône apparaît;
  6. 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)
  7. l’utilisateur est invité à changer (étendre) éventuellement la condition. Par exemples
    • x > y peut être changé par x >= y ou par x != y
    • 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;
  • ou 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

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).

Simplifier une macro boucle en macro simple

Lorsqu’on s’aperçoit qu’une macro boucle ne contient pas de condition de sortie, ce n’est donc pas une boucle. On peut alors la transformer en macro simple. Il suffit de choisir le menu Macro → Transformer en macro simple. 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, Terminate sont placées en séquence dans le bloc Do d’une macro simple.

Transformer une macro simple en boucle

Lorsqu’on s’aperçoit qu’une macro simple est en fait le corps d’une macro boucle, on peut alors la transformer en macro boucle. Il suffit de choisir le menu Macro → Transformer en macro boucle. Toutes les instructions du bloc Do sont placées en séquence dans le bloc Loop d’une macro boucle.

Affichage du code de la macro 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

Un programme est donc généralement constitué d’un ensemble de macros dont l’une, appelée macro principale, ou plus généralement programme principal sert à lancer le programme. AlgoTouch permet de lancer le programme de différentes façons et de contrôler son déroulement dans un mode appelé exécution.

Exécution intégrale d’un programme

Pour exécuter un programme intégralement (y compris les blocs From UntilLoop et enfin  Terminate dans le cas d’une macro boucle), soit:

  • cliquez sur le menu Macro → Exécuter macro courante;
  • ou sur l’icône central de la macro choisie:

Exécution contrôlée d’un programme

On peut contrôler l’exécution d’un programme et visualiser son déroulement en utilisant les icônes de la barre d’outils.

L’exécution peut s’effectuer soit en mode Ligne, soit en mode Bloc en choisissant ce mode à droite de l’étiquette Exécution:

  • dans le mode Ligne, l’utilisateur pourra contrôler l’exécution ligne par ligne. C’est le mode d’exécution le plus fin puisqu’il permet de suivre l’évolution du programme au niveau de chaque instruction du programme;
  • le mode Bloc signifie que l’exécution s’effectuera bloc par bloc. Par exemple, toutes les instructions d’un bloc From seront exécutées à la suite, puis l’affichage est mis à jour.

Exécution détaillée:

Si l’indicateur d’exécution détaillé est actif, toutes les modifications des données effectuées par les instructions sont affichées brièvement à l’écran.


Barre d’icônes du mode exécution:

Les icônes ont la signification suivante:

“Préparer l’exécution”: pour passer en mode exécution de programme. Dans ce mode, il n’est plus possible de modifier le programme: les icônes de la partie construction sont inactifs;

“Ligne ou bloc suivant”: le programme exécute la ligne ou le bloc suivant, met à jour l’affichage et positionne le curseur sur la ligne ou le bloc suivant à exécuter;

“Animation”: le programme est exécuté automatiquement mais effectue une pause à la fin de chaque ligne ou bloc. Le curseur, à droite des icônes, permet de ralentir (-) ou d’accélérer (+) le déroulement du programme en jouant sur la durée de la pause;

“Suspendre”: arrête le programme en mode animation. Cliquer sur “Bloc suivant” ou “Animation” pour continuer;

“Exécuter jusqu’à la fin”: le programme s’exécute entièrement sans pause et l’affichage est mis à jour. Si l’indicateur d’exécution détaillé est actif, les modifications de données sont affichées;

 “Stop exécution”: quitte le mode exécution. Le système retourne en mode construction.”

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. 

Affichage du programme dans différents langages

Pour voir le code du programme en cours dans différents langages, utiliser l’un des onglets de la zone d’information. Le code du programme dont la macro courante est le point d’entrée, est affiché dans le langage choisi.

En utilisant cet icône, on peut copier ce programme dans le presse papier afin de le coller dans un éditeur de texte par exemple.

 

Fichiers et exports

Opérations sur fichiers

  • Fichier → Nouveau: création d’un nouveau programme. Il contient quelques constantes et une macro nommée Macro_1 qui est la macro courante. Il est conseillé de renommer cette macro si elle contient un programme. 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.

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 a été empruntée au système PythonTutor. Elle 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 un programme;
  • puis exécuter la commande
    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 exemple.