Fiche de révision : Programmation par blocs et textuelle

1. 📌 L'essentiel

• La programmation graphique par blocs permet de créer des programmes via une interface visuelle intuitive.
• La programmation textuelle (pseudo-code) traduit ces blocs en instructions structurées et compréhensibles dans un langage proche du naturel.
• Les boucles (TANT QUE, RÉPÉTER JUSQU’À) servent à répéter des actions, souvent contrôlées par un événement.
• Les instructions conditionnelles (SI, ALORS, SINON) gèrent la prise de décision selon des conditions.
• Les variables stockent des données modifiables, comme la vie d’un joueur ou un score.
• Les listes regroupent plusieurs données dans un tableau, facilitant le stockage et la manipulation.
• La traduction entre graphique et texte permet de comprendre et d’optimiser le code.
• La détection d’événements (ex.: présence, touche) déclenche des actions spécifiques.
• La maîtrise des mots-clés structurant (DÉBUT, FIN, SI, TANT QUE) est essentielle pour organiser un algorithme.
• La compréhension des relations entre composants est cruciale pour la programmation fonctionnelle.

2. 🧩 Structures & Composants clés

• Bloc de programme — ensemble d’instructions regroupées pour une tâche spécifique.
• Boucle (TANT QUE, RÉPÉTER JUSQU’À) — répète indéfiniment ou jusqu’à événement.
• Instruction conditionnelle (SI...ALORS...SINON) — décisionnelle, modifie le flux selon la condition.
• Variables — stockent des valeurs modifiables durant l’exécution.
• Liste — tableau d’éléments pour le stockage groupé.
• Événements — déclenchent l’action (ex. pression touche, détection présence).
• Mots-clés — structuration claire du pseudo-code : DÉBUT, FIN, SI, ALORS, SINON, TANT QUE.
• Traduction graphique → texte — facilite la compréhension et débogage.
• Exemple classique — contrôle de porte selon détection de présence.
• Boucle avec événement — répéter tant qu’un événement n’est pas déclenché.

3. 🔬 Fonctions, Mécanismes & Relations

• Les boucles itèrent des instructions pour créer des programmes réactifs.
• La condition (SI) vérifie une donnée ou état pour faire déclencher une action.
• Une variable (ex : « vie ») est mise à jour suite à un événement, modifiant le comportement.
• La liste permet de stocker et traiter plusieurs données, comme des scores.
• La traduction entre programmation graphique et textuelle facilite l’apprentissage et la transition vers la programmation textuelle.
• L’organisation hiérarchique : début → conditions → actions → fin.
• Les événements (détection, réponse) modulent la logique dynamique.
• La relation cause-effet : événement → condition → action.
• La modularité via les blocs simplifie la compréhension de la logique globale.

4. Tableau comparatif : Structures de contrôle

5. 🗂️ Diagramme Hiérarchique

Programme
 ├─ Début
 ├─ Boucle (TANT QUE ou RÉPÉTER JUSQU’À)
 │    ├─ Vérification événement
 │    └─ Exécution instructions
 ├─ Condition (SI...ALORS)
 │    ├─ Action si vrai
 │    └─ Sinon, autre action
 └─ Fin

6. ⚠️ Pièges & Confusions fréquentes

• Confondre TANT QUE et RÉPÉTER JUSQU’À.
• Oublier de mettre un FIN à la fin du bloc.
• Confondre SI simple et SI avec SINON.
• Oublier de mettre à jour la variable dans la boucle.
• Croire que la liste est un seul élément, alors que c’est un tableau.
• Confusion entre programmation graphique et texte sans traduction.
• Confondre l’événement déclencheur et la condition dans le SI.
• Sous-estimer l’importance des mots-clés structurants.

7. ✅ Checklist Examen Final

• Maîtriser la structure d’un algorithme : DÉBUT, FIN, instructions.
• Savoir utiliser et interpréter boucles (TANT QUE, RÉPÉTER JUSQU’À).
• Comprendre et rédiger une instruction conditionnelle (SI...ALORS...SINON).
• Savoir créer et manipuler variables et listes.
• Savoir traduire un programme graphique en pseudo-code.
• Identifier les événements : détection de présence, touches clavier.
• Utiliser correctement les mots-clés structurants.
• Expliquer le rôle des composants (boucles, conditions, variables).
• Anticiper les erreurs fréquentes (boucles infinies, mauvaise condition).
• Expliquer le flux général d’un programme réactif.
• Comprendre comment l’action dépend des événements et des conditions.
• Savoir décomposer un algorithme en hiérarchie logique.
• Être capable d’écrire un pseudo-code simplifié répondant à un problème donné.
• Connaître les différences principales entre programmation graphique et textuelle.
• Reconnaître un énoncé et déterminer la meilleure structure de contrôle à utiliser.