Un premier programme
Ce que ce chapitre apporte
- Distinguer un algorithme d'un programme, et expliquer pourquoi l'ordre des instructions décide du résultat.
- Reconnaître chaque forme de Flowgorithm et dire son rôle.
- Construire un programme linéaire qui déclare ses variables, lit des saisies, calcule et affiche.
- Exécuter un programme pas à pas et suivre ses variables dans la fenêtre des variables.
- Repérer une variable non déclarée, une variable sans valeur et deux formes placées dans le mauvais ordre.
Écrire un programme demande deux efforts à la fois : trouver le raisonnement, et le taper sans faute. Pour un débutant, le second masque le premier. Flowgorithm retire la syntaxe : on assemble des formes, le logiciel les exécute une par une, et chaque variable reste visible pendant le déroulé. Ce chapitre installe l'outil, présente ses formes et construit un premier programme complet : déclarer, lire, calculer, afficher.
Un algorithme, puis un programme
Un algorithme est une suite finie d'instructions précises qui mène d'une situation de départ au résultat voulu. Il décrit le raisonnement, sans dépendre d'un langage.
Un programme est la traduction de cet algorithme dans un langage que la machine sait exécuter : ici les formes de Flowgorithm, plus tard Python.
L'algorithme est la recette, le programme est la cuisine. Une recette juste reste juste qu'on la suive dans une cuisine ou dans une autre ; une recette fausse donne un plat raté, quel que soit le matériel.
La différence avec un cuisinier tient en un mot : la machine exécute aveuglément. Elle ne devine rien, ne corrige rien, ne saute aucune étape. « Remplir la cuve » ne lui dit rien ; « lire le volume demandé, ouvrir la vanne, ajouter ce volume au volume actuel » lui convient, à condition que chaque étape soit à sa place. Dans un organigramme, elle suit les flèches : une forme après l'autre, de haut en bas.
Un programme ne fait que ce qui est écrit, dans l'ordre où c'est écrit. Quand le résultat est faux, la cause est dans une forme précise, et la trouver consiste à suivre l'exécution forme par forme.
Pourquoi passer par un outil visuel
Le parcours d'algorithmique a posé le raisonnement en pseudo-code, sur le papier. Flowgorithm le rend exécutable sans rien exiger d'autre. Un langage comme Python impose, dès la première ligne, des parenthèses, des guillemets, une indentation exacte. Une faute de frappe arrête tout, et l'attention part vers la syntaxe au lieu du raisonnement. Flowgorithm supprime cet obstacle : chaque instruction est une forme, et les flèches donnent l'ordre.
Flowgorithm n'invente pas l'algorithme. Décider quelles valeurs lire, quel calcul faire et dans quel ordre reste le travail de la personne qui programme. L'outil sert à apprendre ce raisonnement ; il ne sert pas à écrire des logiciels. Il prolonge le pseudo-code du parcours d'algorithmique et prépare Python, qui vient ensuite : le menu Tools > Source Code Viewer montre dès maintenant chaque organigramme traduit en Python.
Installer Flowgorithm
Flowgorithm est un logiciel gratuit, prévu pour Windows, à télécharger sur son site officiel, flowgorithm.org. Il s'installe comme tout programme Windows. À l'ouverture, un programme vide contient deux formes reliées par une flèche : Main, qui marque le début, et End, qui marque la fin. Tout le programme se construit entre les deux.
Les formes de Flowgorithm
Chaque instruction a sa forme, et la forme annonce la nature de l'instruction avant même qu'on lise son contenu. Les figures de ce cours reprennent l'apparence du logiciel.
| Forme | Sur les figures du cours | Rôle |
|---|---|---|
| Main et End | pilule mauve | ouvrir et fermer le programme |
| Declare | rectangle jaune pâle, barré d'un filet en haut et à gauche | créer des variables et fixer leur type |
| Input | parallélogramme bleu clair | lire une valeur au clavier et la ranger dans une variable |
| Assign | rectangle jaune pâle | ranger le résultat d'un calcul dans une variable |
| Output | parallélogramme vert clair | évaluer une expression et l'afficher |
| If | losange rose | choisir entre deux chemins |
| While | hexagone orangé | répéter tant qu'une condition est vraie, en testant avant |
| For | hexagone orangé | répéter en faisant varier un compteur |
| Do | hexagone orangé, sous le corps de la boucle | répéter en testant après le corps |
| Call | rectangle mauve à deux barres verticales | transférer le contrôle à une fonction |
| Comment | cadre en pointillés | écrire un commentaire dans l'organigramme |
| Breakpoint | absente des figures | suspendre l'exécution pour observer les variables |
Ce chapitre n'emploie que les quatre formes d'un programme linéaire : Declare, Input, Assign et Output. If revient au chapitre 3, While, For et Do au chapitre 4, Call au chapitre 5.
Le plus petit programme utile : une déclaration, une affectation, une sortie. Exécuter la figure et regarder le texte apparaître dans la console.
Le premier programme
Un entrepôt prépare des palettes qui portent toutes le même nombre de colis. Le responsable saisit le nombre de palettes et le nombre de colis par palette ; le programme affiche le nombre total de colis à expédier.
Avant d'ouvrir le logiciel, écrire en français ce qui entre, ce qui sort et le calcul qui relie les deux :
- entrées : le nombre de palettes, le nombre de colis par palette ;
- sortie : le nombre total de colis ;
- calcul : total = palettes × colis par palette.
Dans Flowgorithm, la construction suit toujours le même geste :
- Ajouter une forme : cliquer sur la flèche à l'endroit voulu, puis choisir la forme.
- La remplir : double-cliquer sur la forme et saisir son contenu.
- Recommencer sur la flèche suivante, dans l'ordre où les instructions doivent s'exécuter.
Déclarer, lire, calculer, afficher. Une seule forme Declare crée les trois variables ; le symbole & colle le texte et la valeur dans la sortie.
Chaque forme a une seule tâche. La forme Declare vient en premier et crée les trois variables, de type Integer (entier) : les types font l'objet du chapitre suivant. Les deux formes Input rangent les saisies dans l'ordre où elles arrivent. L'affectation, écrite totalColis = palettes * colisParPalette sur la figure, se lit de droite à gauche : calculer le produit, puis le ranger dans totalColis.
Un nom commence par une lettre, puis enchaîne lettres et chiffres, sans espace ni tiret bas. Flowgorithm ne distingue pas les majuscules des minuscules : totalColis et TOTALCOLIS désignent la même variable. Dans ce cours, les noms s'écrivent sans accent et disent ce qu'ils contiennent : colisParPalette plutôt que c.
Le même programme en Python, pour situer la suite du parcours :
Python n'a pas de forme Declare : une variable y naît à sa première affectation.
Exécuter et suivre
Flowgorithm exécute un programme de deux façons : en continu, du début à la fin, ou pas à pas, une forme à chaque action. En pas à pas, le logiciel surligne la forme en cours, affiche la console, où apparaissent les saisies et les sorties, et la fenêtre des variables, qui montre le contenu de chaque variable à cet instant.
Les organigrammes de ce cours s'exécutent de la même façon, directement sur la page : le bouton « Exécuter » déroule tout, le bouton « Pas à pas » avance d'une forme. Dérouler le programme des palettes pas à pas avec les saisies 12 et 40 donne :
| Forme exécutée | Console | Variables après la forme |
|---|---|---|
| Declare | palettes, colisParPalette, totalColis existent, sans valeur | |
| Input palettes | saisie 12 | palettes = 12 |
| Input colisParPalette | saisie 40 | colisParPalette = 40 |
| Assign | totalColis = 480 | |
| Output | Colis à expédier : 480 | inchangées |
Recommencer ensuite avec d'autres saisies, par exemple 7 palettes : la valeur de totalColis suit, sans qu'aucune forme ne change. C'est tout l'intérêt d'un programme : le raisonnement est écrit une fois, les données changent.
Chaque valeur y est colorée selon son type : les entiers (Integer) en bleu, les réels (Real) en violet, les textes (String) en rouge, les booléens (Boolean) en bleu-vert. Une couleur inattendue signale un type mal choisi avant même que le résultat soit faux.
Deux règles se voient dans cette fenêtre.
- Une variable déclarée existe, mais n'a pas de valeur tant qu'une forme Input ou Assign ne lui en a pas donné. Sur la page, elle s'affiche avec un point d'interrogation. S'en servir dans un calcul ou une sortie avant ce moment est une erreur qui arrête l'exécution.
- Une variable non déclarée n'existe pas du tout. L'utiliser est aussi une erreur qui arrête l'exécution.
La surface d'une zone de stockage. Exécuter pas à pas : juste après la forme Declare, les trois variables existent et aucune n'a encore de valeur.
Pour voir la seconde règle à l'œuvre, reconstruire ce programme dans Flowgorithm en retirant surface de la forme Declare, puis l'exécuter : le logiciel signale une erreur au lieu d'afficher une surface, parce que surface n'existe pas.
Déclarer les variables qu'on lit et oublier celle qu'on calcule. La correction tient en un mot : ajouter surface à la liste de la forme Declare. Le réflexe à prendre est de relire la forme Declare en se demandant, pour chaque nom écrit ailleurs, s'il y figure.
L'ordre compte
Un magasinier saisit le stock d'une référence en début de journée, puis le nombre d'articles sortis. Le programme doit afficher le stock restant. Avec les saisies 350 et 125, la bonne version (lire, lire, calculer, afficher) affiche Stock restant : 225. Voici deux versions où seules deux formes ont été échangées. La première est dessinée ci-dessous.
Afficher avant de calculer. Exécuter pas à pas : la console affiche le stock de départ, puis la fenêtre des variables montre le stock mis à jour, trop tard.
Cette version affiche Stock restant : 350, alors que stock vaut 225 à la fin. Aucune erreur ne s'affiche : le programme tourne, et le résultat est faux. C'est l'erreur la plus dangereuse, parce que rien ne la signale.
La seconde version échange la lecture des sorties et le calcul :
- Declare
stock, sorties; - Input
stock; - Assign
stock = stock - sorties; - Input
sorties; - Output
"Stock restant : " & stock.
Au moment du calcul, sorties existe mais n'a encore reçu aucune valeur : l'exécution s'arrête sur l'affectation, et rien n'est affiché. Cette erreur-là, au moins, se voit tout de suite.
Une valeur doit être lue ou calculée avant d'être utilisée, et un résultat calculé avant d'être affiché. L'ordre d'un programme linéaire suit presque toujours la même trame : déclarer, lire, calculer, afficher.
Fil rouge : la cuve de traitement
Une station de traitement d'eau exploite plusieurs cuves cylindriques. Ce fil rouge construit, chapitre après chapitre, le programme qui les surveille. Première étape : l'opérateur saisit le nom d'une cuve et son volume actuel en litres, et le programme affiche un relevé qui reprend les deux.
- Entrées : le nom de la cuve, un texte ; le volume actuel, un nombre entier de litres.
- Sortie : une ligne qui assemble les deux.
Étape 1 du fil rouge. Deux formes Declare, car les deux variables n'ont pas le même type. Exécuter pas à pas et comparer les couleurs de nomCuve et de volumeLitres dans la fenêtre des variables.
Avec les saisies Cuve A et 21000, le programme affiche Relevé : Cuve A contient 21000 litres. Les espaces font partie des textes entre guillemets : sans l'espace après « contient », le nombre serait collé au mot. Le chapitre suivant ajoute le rayon et la hauteur de la cuve, pour calculer sa capacité et son taux de remplissage.
Exercices type
Pour une pompe de relevage, donner la forme Flowgorithm de chaque instruction : créer les variables debit et minutes ; demander le débit à l'opérateur ; ranger debit * minutes dans volume ; montrer le volume à l'écran ; décider d'arrêter la pompe si le volume dépasse une limite.
- Créer les variables : Declare, qui fixe aussi leur type.
- Demander le débit : Input, puisque la valeur vient du clavier.
- Ranger le produit : Assign, un calcul dont le résultat va dans une variable.
- Montrer le volume : Output.
- Décider selon une limite : If, qui ouvre deux chemins.
La forme se choisit d'après ce que fait l'instruction, jamais d'après les mots qu'elle contient : « demander » et « montrer » parlent tous deux de l'écran, mais l'un fait entrer une valeur, l'autre la fait sortir.
L'opérateur saisit 35 puis 20. Qu'affiche la console, et que contient la fenêtre des variables à la fin ?
Une pompe de débit constant, en litres par minute, fonctionne pendant une durée saisie.
Les saisies se rangent dans l'ordre des formes Input : 35 dans debit, 20 dans minutes. L'affectation range leur produit dans volume. Les deux sorties s'exécutent ensuite, dans l'ordre :
- Durée : 20 min
- Volume pompé : 700 litres
À la fin, la fenêtre des variables montre debit = 35, minutes = 20 et volume = 700, tous trois en bleu, puisque ce sont des entiers. Une sortie n'efface ni ne modifie aucune variable : elle ne fait que lire.
Un bac reçoit un apport d'eau. Le programme doit afficher le niveau avant l'apport, puis le niveau après. Avec les saisies 1200 et 350, il affiche deux fois la même valeur. Quelle forme est mal placée ?
La version fautive.
L'affectation écrase l'ancienne valeur de niveau avant la première sortie. Les deux sorties lisent donc la même variable, qui vaut déjà 1550 : la console affiche Ancien niveau : 1550 puis Nouveau niveau : 1550.
La correction consiste à placer la sortie « Ancien niveau » au-dessus de l'affectation :
La version corrigée : elle affiche 1200, puis 1550. Exécuter pas à pas pour voir niveau changer entre les deux sorties.
Afficher avant de calculer était l'erreur du stock ; c'est ici la solution. La règle n'est donc pas « toujours afficher à la fin », mais : chaque forme doit trouver les variables dans l'état qu'elle attend.
Vérification
1.Qu'est-ce qui distingue un algorithme d'un programme ?
2.Quelle forme range dans une variable une valeur tapée au clavier ?
3.Un programme lit stock, affiche stock, puis calcule stock ← stock - sorties. Qu'affiche-t-il ?
4.Une variable est déclarée, mais aucune forme ne lui a donné de valeur. Que se passe-t-il si une affectation l'utilise ?
5.Une affectation range un résultat dans surface, mais surface n'apparaît dans aucune forme Declare. Que se passe-t-il ?
6.Dans la fenêtre des variables, une valeur apparaît en violet. De quel type est la variable ?
7.À quoi sert l'exécution pas à pas ?
8.Quelles formes suffisent à construire un programme linéaire qui lit deux mesures et affiche leur produit ?
La méthode
- Décrire le besoin en français : les entrées, la sortie et le calcul qui les relie, avant d'ouvrir le logiciel.
- Déclarer en premier chaque variable, avec son type, y compris celles qui reçoivent un calcul.
- Placer les formes dans l'ordre d'exécution : lire avant de calculer, calculer avant d'afficher.
- Exécuter avec des saisies dont on connaît le résultat, calculé à la main sur un cas simple.
- Passer en pas à pas dès que le résultat diffère, et chercher la première forme après laquelle une variable ou la console ne montre pas ce qui était prévu.
Synthèse
- Un algorithme est le raisonnement ; un programme le traduit dans un langage que la machine exécute aveuglément, une forme après l'autre.
- Chaque forme a un rôle : Main et End encadrent, Declare crée, Input lit, Assign calcule et range, Output affiche ; If, While, For, Do et Call viendront ensuite.
- Une variable non déclarée est une erreur ; une variable déclarée sans valeur ne peut pas encore servir.
- L'exécution pas à pas surligne la forme en cours et montre la console et la fenêtre des variables, colorée par type.
- L'ordre des formes décide du résultat : une sortie placée trop tôt affiche une valeur périmée, sans aucune erreur.
Mettre en pratique
Reconnaître les formes, lire un organigramme de haut en bas, suivre une exécution.
- Reconnaître les formesNiveau 1
- Suivre les flèchesNiveau 2
- Ce que l'ordre changeNiveau 2
- Prévoir la consoleNiveau 2
- Le coût d'une consommation d'énergieNiveau 3