Introduction à la programmation

Imagine que tu dois expliquer à un robot comment faire un sandwich. Tu ne peux pas juste dire "fais un sandwich", il faut lui donner chaque étape précisément : "prends deux tranches de pain", "ouvre le pot de confiture", "étale la confiture sur une tranche"... C'est exactement ça un algorithme !

Un algorithme est une série d'instructions claires et précises, organisées dans un ordre logique, pour résoudre un problème ou accomplir une tâche. C'est comme une recette de cuisine ou un mode d'emploi.

Exemples d'algorithmes du quotidien :

• La recette de ton plat préféré.
• Le chemin que tu prends pour aller de chez toi à l'école.
• Les étapes pour te brosser les dents.

Chaque étape doit être simple et sans ambiguïté. L'ordre des étapes est crucial : tu ne peux pas étaler la confiture avant d'avoir ouvert le pot ! Un algorithme est une séquence d'instructions pour atteindre un but précis.

Nous, les humains, nous communiquons avec des langues comme le français. C'est ce qu'on appelle le langage naturel. Mais les ordinateurs ne comprennent pas le français. Ils ont leur propre langage, très simple, fait de 0 et de 1, appelé langage machine.

Le rôle du programmeur est de traduire les instructions que nous comprenons (en langage naturel ou dans un langage de programmation plus "humain") en instructions que la machine peut exécuter. C'est un peu comme si tu parlais à un ami qui ne comprend que l'anglais : tu dois traduire tes pensées pour qu'il te comprenne.

Les langages de programmation (comme Scratch, Python, Java) sont des intermédiaires. Ils sont plus faciles à écrire et à comprendre pour nous que le langage machine, mais ils peuvent être traduits en langage machine par l'ordinateur. Le programmeur est l'intermédiaire entre l'idée et la machine.

Apprendre à programmer, ce n'est pas seulement pour devenir un expert en informatique. C'est surtout pour :

• Développer la logique : La programmation t'apprend à penser de manière structurée, à décomposer un gros problème en petites étapes gérables.
• Résoudre des problèmes : Chaque programme est une solution à un problème. Tu apprends à analyser, à tester et à trouver des solutions créatives.
• Créer et innover : Avec la programmation, tu peux donner vie à tes idées : créer tes propres jeux, histoires interactives, animations. C'est un super pouvoir pour transformer tes pensées en réalité numérique !

La programmation est une façon de penser et de créer.

Scratch est un environnement de programmation visuelle développé par le MIT. C'est génial pour débuter car tu n'as pas besoin d'écrire des lignes de code complexes. Tu as juste à glisser-déposer des blocs !

L'interface utilisateur de Scratch est divisée en plusieurs zones :

• La scène : C'est là que ton projet prend vie. Tu y vois tes personnages (les lutins) et l'arrière-plan.
• Les lutins : Ce sont les personnages ou objets de ton projet. Tu peux en choisir dans la bibliothèque ou les dessiner.
• La zone des blocs : C'est ici que tu trouves tous les blocs de code, organisés par catégories (Mouvement, Apparence, Son, Événements...).
• La zone de script : C'est là que tu assembles tes blocs pour créer tes programmes.

Pour commencer, prenons le lutin par défaut : le chat Scratch. Pour le faire bouger, tu utilises les blocs de mouvement.

1. Changer la position : Le bloc aller à x: [0] y: [0] permet de placer le lutin à un endroit précis sur la scène. La scène est comme un grand quadrillage avec des coordonnées (x, y). Le centre est (0,0).
   • x gère le déplacement horizontal (gauche/droite).
   • y gère le déplacement vertical (haut/bas).
2. Faire avancer : Le bloc avancer de [10] pas déplace le lutin dans la direction où il est orienté.
3. Tourner : Les blocs tourner de [15] degrés (dans le sens horaire) et tourner de [15] degrés (dans le sens anti-horaire) changent l'orientation du lutin.
4. Pointer dans une direction : Le bloc s'orienter à [90] permet de définir une direction précise (90 c'est vers la droite, 0 vers le haut, -90 vers la gauche, 180 vers le bas).

Assemble ces blocs pour faire danser ton lutin !

Un lutin peut faire bien plus que bouger ! Il peut parler, faire du bruit ou changer d'apparence.

• Parler ou penser : Les blocs d'apparence comme dire [Bonjour !] pendant [2] secondes ou penser [Hmm...] pendant [2] secondes permettent à ton lutin de s'exprimer avec des bulles de dialogue.
• Jouer des sons : Les blocs de son te permettent de jouer des sons enregistrés ou d'importer les tiens. Par exemple, jouer le son [Miaou] ou démarrer le son [Miaou].
• Changer de costume : Chaque lutin peut avoir plusieurs costumes (différentes apparences). Le bloc costume suivant ou basculer sur le costume [costume1] permet de changer l'apparence du lutin, ce qui est parfait pour créer des animations fluides.

Comment faire pour que ton programme se lance ? C'est le rôle des événements ! Ce sont des blocs qui déclenchent l'exécution d'un script.

• quand [drapeau vert] est cliqué : C'est le plus courant, il démarre le programme quand tu cliques sur le drapeau vert au-dessus de la scène.
• quand la touche [espace] est pressée : Permet de déclencher une action quand tu appuies sur une touche du clavier.
• quand ce lutin est cliqué : Déclenche une action quand tu cliques sur le lutin.

Ces blocs sont les "boutons de démarrage" de tes actions.

La séquence d'instructions est la forme la plus simple de contrôle. C'est juste une suite de blocs qui s'exécutent les uns après les autres, de haut en bas.

Exemple :

1. avancer de 10 pas
2. dire "Bonjour"
3. tourner de 90 degrés

L'ordre d'exécution est crucial. Si tu inverses les blocs, le résultat sera différent. Scratch exécute les blocs pas à pas, dans l'ordre où tu les as empilés.

Imagine que tu veuilles faire avancer ton lutin 100 fois. Tu n'allais pas empiler 100 fois le bloc avancer de 10 pas ! C'est là que les boucles sont utiles. Elles permettent de répéter une ou plusieurs actions.

• répéter [10] fois : Répète les blocs à l'intérieur un nombre de fois précis. Très pratique pour des mouvements répétitifs ou des animations.
• répéter indéfiniment : Répète les blocs à l'intérieur sans jamais s'arrêter, jusqu'à ce que tu arrêtes le programme. Utile pour un mouvement continu ou une musique de fond.

Les boucles permettent d'écrire moins de code pour faire plus de choses. C'est une optimisation du code.

Parfois, tu veux que ton programme fasse quelque chose SEULEMENT si une certaine condition est vraie. C'est le rôle des conditions.

• si [condition] alors : Si la condition est vraie, les blocs à l'intérieur s'exécutent. Sinon, ils sont ignorés.
• si [condition] alors sinon : Si la condition est vraie, les blocs du "alors" s'exécutent. Si elle est fausse, ce sont les blocs du "sinon" qui s'exécutent.

Les opérateurs logiques simples (que tu trouves dans la catégorie "Opérateurs") te permettent de créer ces conditions : [nombre] = [nombre], [nombre] > [nombre], [nombre] < [nombre].

Exemple : si [score] = [10] alors dire "Bravo, tu as gagné !".

Imagine une boîte dans laquelle tu peux stocker une information. Cette information peut changer au cours du programme. C'est ça, une variable !

Une variable est un espace de stockage nommé dans la mémoire de l'ordinateur où l'on peut garder une valeur (un nombre, du texte...). Cette valeur peut être modifiée pendant l'exécution du programme.

• Ton score dans un jeu.
• Le nombre de vies restantes.
• Le nom du joueur.

Dans Scratch, pour créer une variable, tu vas dans la catégorie "Variables" et tu cliques sur "Créer une variable". Tu lui donnes un nom (par exemple, "score", "vies", "temps").

Une fois que tu as créé une variable, tu peux :

• mettre [ma variable] à [0] : Pour lui donner une valeur de départ ou la réinitialiser.
• ajouter [1] à [ma variable] : Pour augmenter ou diminuer sa valeur (si tu mets un nombre négatif).
• afficher la variable [ma variable] / cacher la variable [ma variable] : Pour la voir ou non sur la scène.

Les variables sont essentielles pour que tes projets soient interactifs et dynamiques.

Les opérateurs mathématiques te permettent de faire des calculs avec des nombres ou des variables. Tu les trouves dans la catégorie "Opérateurs".

• [nombre] + [nombre] : Addition
• [nombre] - [nombre] : Soustraction
• [nombre] * [nombre] : Multiplication
• [nombre] / [nombre] : Division

Tu peux les utiliser pour :

• Calculer un score (ajouter [5] à [score]).
• Déplacer un lutin de manière dynamique (avancer de [vitesse] pas, où "vitesse" est une variable).
• Vérifier des conditions (si [réponse] = [bonne_réponse] alors ...).

Crée une petite histoire où ton lutin se déplace et parle.

1. Mouvement et apparence combinés : Utilise avancer de [10] pas et costume suivant dans une boucle répéter indéfiniment pour donner l'impression qu'il marche.
2. Utilisation des boucles : Fais-le aller d'un bout à l'autre de l'écran, puis revenir, en utilisant des boucles et des blocs d'orientation.
3. Création d'une petite histoire : Ajoute des blocs dire ou penser pour qu'il raconte une aventure.

N'oublie pas le bloc "quand drapeau vert est cliqué" pour démarrer ton animation !

Crée un quiz simple avec une question et une réponse.

1. Utilisation des questions/réponses : Utilise le bloc demander [Quelle est la capitale de la France ?] et attendre (catégorie "Capteurs"). La réponse de l'utilisateur est stockée dans le bloc réponse.
2. Conditions pour vérifier les réponses : Utilise un bloc si alors sinon avec un opérateur [réponse] = [Paris] pour vérifier si la réponse est correcte.
3. Variables pour le score : Crée une variable score. Si la réponse est bonne, ajouter [1] à [score]. Si elle est fausse, tu peux dire "Faux !".

Scratch peut aussi dessiner ! Il faut ajouter l'extension "Stylo". Clique sur la petite icône en bas à gauche de la zone des blocs.

1. Lever/baisser le stylo : Le bloc stylo en position d'écriture fait en sorte que le lutin dessine quand il bouge. relever le stylo l'empêche de dessiner.
2. Changer la couleur et la taille du stylo : Les blocs mettre la couleur du stylo à et mettre la taille du stylo à permettent de personnaliser tes tracés.
3. Effacer : Le bloc effacer tout est utile pour recommencer un dessin.

Essaie de faire dessiner un carré ou un triangle à ton lutin en utilisant des boucles !

Même les meilleurs programmeurs font des erreurs ! C'est normal. Déboguer, c'est trouver et corriger ces erreurs.

• Comprendre les erreurs : Si ton programme ne fait pas ce que tu attends, c'est qu'il y a une erreur, un "bug".
• Tester son programme : Lance ton programme souvent. Clique sur le drapeau vert. Vois ce qui se passe.
• Méthodes de correction :
  • Vérifie l'ordre des blocs (séquence).
  • Vérifie les valeurs de tes variables (elles s'affichent sur la scène).
  • Vérifie les conditions (sont-elles bien formulées ?).
  • Exécute ton programme pas à pas dans ta tête.

Le débogage est une compétence essentielle : il faut être patient et méthodique.

Une fois que ton projet fonctionne, tu peux toujours le rendre meilleur !

• Ajouter des fonctionnalités : "Et si mon lutin pouvait aussi sauter ?"
• Rendre le code plus clair : Renomme tes variables, organise tes scripts. Un code clair est plus facile à comprendre et à modifier.
• Partager son projet : Sur le site de Scratch, tu peux partager tes créations et voir celles des autres. C'est une excellente façon d'apprendre et de s'inspirer.

La programmation, c'est un processus :

1. Planification du projet : Qu'est-ce que je veux que mon programme fasse ? Quelles sont les étapes ?
2. Itérations et améliorations : Je construis une petite partie, je la teste, je la corrige, puis j'ajoute une autre partie. C'est un cycle !
3. Collaboration : Discuter de tes idées avec d'autres peut t'aider à trouver de nouvelles solutions ou à résoudre des problèmes.

La programmation est un voyage créatif, pas seulement une destination.