Manuel utilisateur

AlgoTouch est un logiciel très visuel qui permet la construction progressive d’un programme par manipulation directe des données (variables, tableaux). Il permet de réaliser un algorithme soit manuellement soit automatiquement après enregistrement des actions à effectuer. L’originalité du système réside dans le fait que l’utilisateur n’a pas besoin de connaître un langage de programmation pour réaliser ses premiers programmes. L’apprentissage du langage se fait naturellement puisque les actions de l’utilisateur sont transformées automatiquement en instructions du langage de programmation défini dans AlgoTouch.

AlgoTouch est basé sur des idées très simples :

  • la manipulation directe sur l’écran des objets de la programmation (variables, index, tableaux),
  • l’enregistrement d’une séquence d’actions,
  • l’exécution d’une séquence enregistrée,
  • la construction méthodique d’un programme
  • l’exécution du programme et sa visualisation

Le logiciel peut être utilisé de deux manières : en mode direct ou en mode programmation. Le mode direct permet à l’utilisateur de manipuler les éléments de base utilisés par un programme pour exécuter les opérations requises par ce programme : affectation des variables simples ou des variables d’index, opérations arithmétiques, instructions conditionnelles. Le mode de programmation permet à l’utilisateur d’enregistrer chaque partie de la boucle principale d’un programme, puis d’exécuter le programme généré.

 

Ce manuel est divisé en trois parties. La première partie décrit l’interface utilisateur. La seconde partie est dédiée au mode direct. Enfin, la troisième partie décrit comment créer des programmes (mode programmation).

Index

L’interface graphique

Les différentes zones du logiciel

 

La fenêtre principale d’AlgoTouch est divisée en 5 zones :

  1. la zone de conception où la manipulation des éléments se produit. Cette zone contient par défaut les constantes usuelles (0, 1, etc.). Elle affiche les éléments en cours d’utilisation comme les variables, les tableaux et les index associés et les macros. Les manipulations sur ces éléments s’effectuent principalement avec la souris.
  2. la zone de la console utilisée par le système pour afficher des informations à l’utilisateur. Il s’agit de la traduction des actions de l’utilisateur en instructions du langage AlgoTouch.
  3. la zone de la boîte à outils avec des boutons qui permettent d’effectuer les actions courantes.
  4. la zone de menus pour détailler toutes les opérations possibles.
  5. la zone pour afficher le programme de la macro en cours. Cette zone n’est pas éditable puisque le programme est produit automatiquement.

A noter : les zones 2 et 5 (console et programme) peuvent être réduites, augmentées ou cachées suivant le case en utilisant les petites flèches en haut à gauche de ces zones .

Mode direct

Eléments manipulés

Les éléments qui peuvent être manipulés avec AlgoTouch sont : les variables, les constantes, les tableaux, les variables index, les index, les opérateurs arithmétiques, les comparateurs, les macros.

Les variables
Les variables sont représentées par une boîte avec un nom et un contenu. Le type de la variable est entier ou caractère.
Les constantes
Les constantes sont similaires aux variables mais le système ne permet pas leur modification. Pour les différencier des variables, elles ont une couleur différente (rouge par défaut).
Les tableaux
Les tableaux sont représentés par une zone rectangulaire avec un nom et contenant les éléments du tableau de type entier ou caractère. Des tableaux de taille et de contenu différents peuvent être créés. Lors de la création d’un tableau, une constante représentant la longueur du tableau est créée automatiquement. Elle porte le même nom que le tableau avec l’extension .length.
Les variables index
Les variables index sont des variables dédiées. Une variable d’index est une variable entière attachée à un tableau spécifique. AlgoTouch montre graphiquement quel élément du tableau est effectivement pointé par chaque variable d’index.
Les index
Un index désigne la variable a[i] si a est un tableau et i est une variable d’index attachée au tableau a. Il est représenté par un fond de forme circulaire et peut être manipulé comme une variable standard.
Les opérateurs arithmétiques
Des opérateurs arithmétiques simples peuvent être utilisés, à savoir addition, soustraction, multiplication, division et reste (modulo).
Le comparateur
Un comparateur ressemble à une balance, avec les valeurs à comparer placées sur ses plateaux. Lorsque la balance est activée, les plateaux se déplacent comme une véritable balance (si les valeurs sont différentes).
Les macros
Une macro est une suite d’instruction (macro simple) ou une boucle unique (macro boucle) avec un nom et un rôle.

Création d’un élément

Les éléments que l’on peut créer sont des variables, des constantes, des tableaux, des variables index, des macros. Tous ces éléments portent un nom différent. Ce nom, donné par l’utilisateur, est composé de lettres (minuscules ou majuscules) et/ou de chiffres et/ou du caractère “_” mais il doit commencer par une lettre. Le nom ne doit pas être un mot clé du langage AlgoTouch. Utilisez le menu Élément ou la barre d’outils
  • Variable Variable : création avec un bouton d’icône ou par le menu Élément → Variable : une variable est créée avec un nom et un rôle fourni par l’utilisateur. Elle est de type entier ou caractère. La variable est initialisée avec 0 ou le caractère espace en fonction de son type.
  • Constante : création par le menu Elément → Constante : une constante est créée avec un nom, un rôle, un type et une valeur fournie par l’utilisateur.
  • Array Tableau : création rapide d’un tableau standard ou création d’un tableau personnalisé. Dans le premier cas, création avec un bouton d’icône ou le menu Elément → Tableau. Le nom, le rôle et le type sont fournis par l’utilisateur. Un tableau de 10 éléments est créé avec des valeurs aléatoires entre 0 et 100 ou entre ‘a’ et ‘z’ suivant le type. Dans le second cas, création avec le menu Elément → Tableau général : une fenêtre de dialogue permet à l’utilisateur de créer un tableau personnalisé. Dans les deux cas, une constante contenant la taille du tableau est créée automatiquement.
  • Index Variable index : un tableau doit d’abord être sélectionné car une variable index est une variable associée à un tableau. Créer avec l’icône ou par le menu Elément → Index. Trois éléments sont créés : une variable utilisée comme une variable index, l’index avec une icône qui désigne a[index] et une flèche (verte par défaut) dessinée en face de la variable du tableau associée a[index]; lorsque la valeur de la variable index est modifiée, la position de la flèche est mise à jour. Si la valeur de la variable index est hors des limites du tableau, la flèche change de couleur (rouge par défaut).

Sélection d’un élément et dé-sélection

Certains éléments peuvent être sélectionnés pour engager une action les concernant. Clic gauche pour sélectionner : l’élément est surligné (entouré de rouge par défaut). En fonction de l’élément certains éléments des menus ou de la barre d’outils sont actifs. Clic gauche sur un autre élément ou sur l’arrière-plan pour désélectionner.

Déplacement d’un élément

Pressez avec le bouton gauche de la souris, sur l’élément à déplacer, puis faites-le glisser vers un emplacement vide et enfin relâchez la souris. L’élément est déplacé à l’endroit final. Dans le cas de déplacement de tous types de variables, si l’emplacement final est aussi une variable, l’opération est transformée en affectation. Noter : le système interdit le déplacement des éléments en dehors de la zone de conception (coordonnées x ou y négatives). Dans le cas du déplacement d’un tableau, la constante de longueur du tableau et les index attachés se déplacent également.

Renommage d’un élément

Les variables, les constantes, les variables index, les tableaux et les macros peuvent être renommés pour définir des identificateurs plus explicites. Le rôle de l’élément peut également être redéfini.
  • Sélectionnez l’élément
  • Menu Élément → Renommer
  • Tapez un nouveau nom et modifiez le rôle si nécessaire.

Suppression d’un élément

Tout élément peut être supprimé sauf les constantes prédéfinies. Cependant, il ne doit être utilisé dans aucune macro. Si c’est le cas, un message d’erreur est affiché. A noter : on ne peut supprimer une macro si c’est la dernière. En effet, un programme AlgoTouch doit toujours contenir au moins une macro (simple ou boucle).
  • Sélectionnez l’élément
  • Menu Élément → Supprimer
  • Si l’élément est utilisé ou s’il s’agit de la dernière macro, un message d’erreur est affiché.

Actions sur les variables

Affectation

Une affectation est une opération qui consiste à déposer une valeur dans tout type de variable. La valeur d’origine est soit une variable, soit une constante, soit une variable index (exemple i), soit une variable de tableau (exemple a[3]) ou soit un index (exemple a[i]).
  • Appuyez avec le bouton gauche sur l’élément d’origine, une boite contenant la valeur de l’objet est affichée.
  • Faites glisser la valeur sur l’élément de destination qui est alors surligné : variable, variable index, variable d’un tableau ou index d’un tableau.
  • Déposez la valeur en relâchant le bouton de la souris. L’instruction associée apparaît sur la zone de la console.
A noter :
  • une constante ne peut être modifiée (elle n’est pas surlignée si la valeur passe au dessus!).
  • si la destination est vide, l’opération effectuée est un déplacement de l’élément d’origine

Modification du contenu d’une variable

  1. Sélectionnez une variable
  2. Menu Opération → Saisir valeur
  3. Une boîte de dialogue apparaît demandant une nouvelle valeur.
  4. Une autre zone de saisie attend la question qui doit être posée à l’utilisateur dans le cas d’une opération de saisie lors de l’exécution d’un programme. Ceci est utile seulement pendant l’enregistrement d’une instruction d’entrée, voir opération de lecture.
Raccourci : effectuez un clic droit sur la variable

Affichage du contenu d’une variable

  1. Sélectionnez une variable
  2. Menu Opération → Afficher valeur
  3. Une boîte de dialogue apparaît affichant la valeur de la variable sélectionnée.
  4. Une zone de saisie attend le message qui sera affiché avec la valeur dans le cas d’une opération d’affichage de valeur dans un programme. Ceci est seulement utile pendant l’enregistrement d’une instruction d’affichage, voir opération d’écriture.

Opérations arithmétiques

Il est possible d’exécuter une opération telle que :
   z = x op y ;
  1. Sélectionnez la variable de destination (z)
  2. Menu Opération → choisissez l’opération (+, -, *, /, %). Un opérateur apparaît avec 2 places pour les opérandes et une pour le résultat. Une icône représentant une “porte de sortie” est affichée : elle permet d’annuler l’opération.
  3. Déplacez la valeur x sur l’opérande de gauche. A ce stade, il est encore possible d’annuler l’opération.
  4. Déplacez la valeur y sur l’opérande de droite. Le résultat apparaît et l’icône de l’opérateur (+ par exemple) apparaît (prête pour validation)
  5. Effectuez un clic gauche sur l’opérateur. Le résultat est affecté à la variable de destination et l’opérateur disparaît.

Incrément ou décrément d’une variable

Ces opérations étant très souvent utilisées, pour augmenter ou pour diminuer une variable dans une boucle par exemple, des raccourcis ont été introduits :
  • pour incrémenter une variable simple ou d’index,
    1. effectuez un appui sur le bouton gauche de la souris à gauche de la variable
    2. déplacez la à l’intérieur de la variable
    3. relâchez.
  • pour décrémenter une variable simple ou d’index,
    1. effectuez un appui sur le bouton gauche de la souris à droite de la variable
    2. déplacez la à l’intérieur de la variable
    3. relâchez.

Actions sur les tableaux

Modification du contenu de tableau

Effectuez un clic droit sur le tableau. Une fenêtre de dialogue proposera différentes configurations :
  • Modifier la taille du tableau.
  • Mettre toutes les variables à la même valeur.
  • Placer des valeurs croissantes à partir d’une certaine valeur.
  • Placer des valeurs décroissantes à partir d’une certaine valeur.
  • Définir une étendue de valeur et choisir de remplir le tableau soit avec des valeurs aléatoires, soit avec des valeurs aléatoires croissantes, soit avec des valeurs aléatoires décroissantes.
  • Définir la liste des valeurs du tableau. Dans le cas des entiers, les valeurs sont séparées par des espaces ou des virgules. Dans le cas des caractères, les caractères sont listés à la suite car l’espace est un caractère. Si le nombre de valeurs est inférieur à la taille, le tableau est complété par des 0 ou des espaces suivant le cas.
  • Mélanger les valeurs actuelles.

Comparaison

L’objectif est de comparer le contenu de deux variables x et y (variable, constante, variable index, index)
  1. Scale pour faire apparaître une balance avec deux plateaux apparaît. L’icône est affichée : elle permet d’annuler la comparaison.
  2. glisser la valeur x sur le plateau de gauche. A ce stade, il est encore possible d’annuler la comparaison avec
  3. glisser la valeur y 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
  4. Activate 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).
  5. L’utilisateur est invité à modifier (étendre) éventuellement la condition.
    • Par exemple, x>y peut être changé par x>=y ou par x!=y.
    • Autre exemple, x==y peut être changé par x>=y ou par x<=y.
    • Après validation, l’instruction de la condition associée, par exemple
          if (x>y){ 
      
      est affichée sur la console.
    • En mode enregistrement, l’utilisateur doit enregistrer les opérations associées à cette condition (tous types d’instructions y compris des tests). L’icône, “porte de sortie” est affichée sur la balance.
  6. Close  pour terminer la séquence d’opérations. La console affiche le bloc else associé au test. Ce bloc ne contient pas de code effectif puisque ce cas n’a pas encore été traité. Par exemple :
        } else { // TODO 
                 // x >= y
        }
    
    La balance disparaît.

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 :
Macro_1
Do
  instructions
// ...
End
Dans ce programme, Macro_1 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. choisissez le bloc à enregistrer avec la liste de choix ou en cliquant dans la zone du programme correspondant.
  2. Clear pour effacer le bloc si nécessaire
  3. Record pour commencer l’enregistrement. Si le bloc n’est pas vide, le système demande à l’utilisateur soit d’effacer le bloc soit d’ajouter des instructions.
  4. exécutez 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. Stop pour terminer l’enregistrement.

Ré-exécution de bloc

  1. choisissez le bloc à exécuter (Do, From, Loop, Terminate)
  2. 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. 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. Configurez le programme en cours de création dans un état où la boucle doit s’arrêter
  2. Erase pour effacer les conditions de sortie si nécessaire.
  3. Exit condition pour faire apparaître un comparateur apparaît sous la forme d’une balance avec l’icône pour annuler éventuellement l’opération.
  4. Placez 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), placez 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 :

Il est possible d’enregistrer plusieurs conditions de sortie. La nouvelle condition sera placée soit à la première soit à la dernière place. Les conditions sont évaluées séquentiellement, comme l’opérateur || (ou logique) en langage C. Si la première condition est vraie, la boucle s’arrête, sinon, la seconde condition est évaluée, etc. Les nouvelles conditions peuvent être ajoutées en premier. En effet, dans le cas d’algorithmes sur les tableaux, ces algorithmes itèrent sur le tableau et s’arrêtent soit au milieu du tableau, et de toute manière, quand la fin du tableau est atteinte. Lors de l’enregistrement d’un tel algorithme, l’utilisateur examine d’abord, en général, les conditions de sortie au milieu du tableau (condition sur a[i]), l’utilisateur examinera, ensuite, le cas où le tableau a été entièrement examiné (condition i==a.length). Lors de l’évaluation de la condition de sortie, il est important que la condition sur i soit examinée en premier afin d’éviter une erreur de débordement de tableau sur le test de a[i]!

Opérations de saisie et d’affichage

Opération de saisie de valeur (lecture)

  1. sélectionnez 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.
Raccourci : effectuez un clic droit 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électionnez 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.
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.

Exécuter une macro

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

  1. sélectionnez la macro sur l’écran
  2. choisissez 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 250.000, 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é. En effet, par exemple, un programme de tri simple de 10.000 valeurs dépasse la limite proposée. 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 boucle pas. Dans ce cas, n’enregistrez 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

Pour voir le code machine virtuelle de la macro en cours, choisissez le menu Macro → Afficher le code Une nouvelle fenêtre apparaît avec la liste des instructions produites par le logiciel correspondant à la macro en cours. Ce code est donné à titre indicatif, il ne peut être modifié.

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

Opérations sur fichier

  • Fichier → Nouveau : créer un nouveau programme. Il contient quelques constantes et une macro nommée Macro_1. Avant de créer le nouveau programme, le système vérifie que le programme en cours a été enregistré. L’utilisateur peut annuler la création.
  • Fichier → Ouvrir : charge un programme existant (extension de fichier .alg)
  • 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. Les codes produits sont directement exécutables dans les environnements adaptés.

  • Fichier → Exporter : enregistrer les programmes de toutes les macros utilisées dans la macro courante en tant que fichier texte dans le langage AlgoTouch (extension .prg )
  • Fichier → Exporter en Java… : transforme la macro courante en programme Java (extension .java ), en substituant chaque appel de macro par le code Java correspondant.
  • Fichier → Exporter en Python… : transforme la macro courante en programme Python (extension .py ), en substituant chaque appel de macro par le code Python correspondant.
  • Fichier → Exporter en C/C++… : transforme la macro courante en programme C++ (extension .cc ), en substituant chaque appel de macro par le code C++ correspondant. En fait, le programme est un programme en C dans lequel les opérations de saisie et d’affichage utilisent les instruction C++ cin et cout.
  • Fichier → Exporter en C… : transforme la macro courante en programme C (extension .c ), en substituant chaque appel de macro par le code C correspondant.

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

Mots clés du langage AlgoTouch

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