Le principe de la programmation

La programmation informatique consiste à donner à un ordinateur une suite d'instructions afin qu'il réalise une tâche. Ces instructions forment un programme.

L'ordinateur exécute les instructions qui lui sont fournies, mais il ne détermine pas lui-même la méthode à employer pour résoudre un problème. Le programmeur doit donc définir précisément les opérations à effectuer et leur ordre.

Analyser le problème

La création d'un programme commence par l'analyse du problème. Le résultat attendu est défini, ainsi que les informations nécessaires pour l'obtenir et les traitements à effectuer.

Un programme qui calcule une moyenne doit par exemple recevoir plusieurs notes, additionner leurs valeurs, déterminer leur nombre puis diviser la somme obtenue par ce nombre. Cette réflexion permet de définir la solution avant d'écrire le code.

Construire l'algorithme

La solution est ensuite organisée sous la forme d'un algorithme. Il décrit les différentes étapes nécessaires pour résoudre le problème dans un ordre logique, sans dépendre d'un langage de programmation particulier.

L'algorithme permet de vérifier le fonctionnement de la solution avant de la traduire en code. Il peut être décrit avec des phrases simples, un pseudo-code ou un schéma.

Les éléments communs aux programmes

Les langages de programmation possèdent des syntaxes différentes, mais ils utilisent généralement les mêmes principes fondamentaux pour construire les algorithmes et les programmes.

• Variable : mémorise une information qui peut être utilisée ou modifiée pendant l'exécution du programme. Une variable age peut par exemple contenir la valeur 15.
• Condition : permet de choisir une action selon qu'une situation est vraie ou fausse. Une condition peut par exemple vérifier si age >= 18.
• Boucle : permet de répéter des instructions. Une boucle peut par exemple parcourir successivement tous les éléments d'une liste.
• Fonction : regroupe des instructions réalisant une tâche précise afin de pouvoir les réutiliser. Une fonction peut par exemple calculer l'aire d'un rectangle à partir de sa longueur et de sa largeur.
• Objet : regroupe des données et des actions associées lorsque le langage et la méthode de programmation utilisent la programmation orientée objet.

Écrire le programme

L'algorithme est ensuite traduit dans un langage de programmation. Le choix du langage dépend notamment du type de programme à réaliser.

Le programmeur écrit alors le code source en respectant la syntaxe du langage. Par exemple, l'algorithme qui vérifie si une personne est majeure peut être traduit en instructions permettant de demander son âge, de conserver cette valeur dans une variable, de la comparer à 18 et d'afficher le résultat.

Le code source doit ensuite être transformé en instructions exécutables par le processeur. Selon le langage utilisé, cette transformation est notamment réalisée par un compilateur ou un interpréteur.

Tester le programme

Une fois le programme écrit, il doit être testé. Plusieurs valeurs et situations sont utilisées afin de vérifier que le résultat correspond à ce qui était prévu.

Pour un programme qui détermine si une personne est majeure, il faut par exemple tester un âge inférieur à 18, un âge égal à 18 et un âge supérieur à 18. Des valeurs inattendues peuvent également être testées afin de vérifier que le programme les traite correctement.

Corriger les erreurs

Les tests peuvent révéler des erreurs appelées bugs. Le débogage consiste à rechercher leur origine, à modifier le programme puis à effectuer de nouveaux tests.

Une erreur peut provenir d'une instruction incorrecte, d'un mauvais calcul, d'une condition mal définie ou d'une situation qui n'avait pas été prévue. Les corrections sont donc suivies de nouveaux tests afin de vérifier le fonctionnement du programme.

Améliorer le programme

Lorsque le programme fonctionne correctement, il peut encore être amélioré. Le code peut être réorganisé, les traitements peuvent être optimisés et de nouvelles fonctionnalités peuvent être ajoutées.

Cette démarche se répète pendant toute la durée de vie d'un logiciel. Une nouvelle fonctionnalité peut nécessiter une modification de l'algorithme, du code et des tests.

La programmation repose ainsi sur une démarche progressive : comprendre le problème, construire une solution, écrire le code, tester, corriger et améliorer. Les langages changent, mais cette méthode et les principaux éléments utilisés pour programmer restent largement communs.

Répéter des instructions

Un programme doit souvent effectuer plusieurs fois les mêmes instructions. Il peut par exemple afficher les nombres de 1 à 100, parcourir les éléments d'une liste ou examiner chaque pixel d'une image. Les boucles permettent de répéter automatiquement ces instructions sans devoir les écrire plusieurs fois.

Une boucle exécute une série d'instructions puis recommence selon une règle définie par le programme. Cette répétition rend le code plus court, plus lisible et plus facile à modifier.

La boucle POUR

La boucle POUR, appelée for dans de nombreux langages, est utilisée lorsque le nombre de répétitions est connu ou peut être déterminé avant le début de la boucle.

Pour afficher les nombres de 1 à 10, une boucle for peut ainsi répéter la même instruction dix fois en faisant varier une variable de 1 à 10.

Cette boucle est également adaptée au parcours d'une collection de données. Un programme peut par exemple utiliser une boucle for pour traiter successivement les 52 cartes d'un jeu ou les différents éléments d'une liste.

La boucle TANT QUE

La boucle TANT QUE, appelée while dans de nombreux langages, répète les instructions aussi longtemps qu'une condition reste vraie.

Un programme peut par exemple continuer à demander un mot de passe tant que celui qui est saisi est incorrect. Dans un jeu, une boucle peut également maintenir certaines opérations tant que le joueur possède encore des vies.

La condition est généralement vérifiée avant chaque répétition. Dès qu'elle devient fausse, la boucle s'arrête et le programme poursuit son exécution après la boucle.

La variable compteur

Les boucles utilisent fréquemment une variable compteur. Cette variable permet de suivre le nombre de répétitions ou de désigner l'élément actuellement traité.

Pour afficher les nombres de 1 à 100, le compteur peut commencer à 1. Après chaque répétition, sa valeur augmente de 1 jusqu'à atteindre 100.

Dans une boucle parcourant une liste, la variable peut également servir à repérer successivement le premier élément, le deuxième, le troisième et ainsi de suite.

Les boucles imbriquées

Une boucle peut contenir une autre boucle. Cette organisation est appelée boucles imbriquées.

Elle est notamment utile lorsque le programme doit parcourir des données organisées en plusieurs dimensions. Pour parcourir les pixels d'une image, une première boucle peut parcourir les lignes et une seconde les pixels de chaque ligne.

Le nombre total de répétitions peut alors devenir très important. Deux boucles de 100 répétitions chacune peuvent par exemple provoquer jusqu'à 10 000 exécutions de l'instruction située dans la boucle intérieure.

La boucle infinie

Une boucle doit normalement disposer d'une condition permettant d'atteindre sa fin. Si cette condition ne devient jamais fausse, le programme reste dans la boucle : il s'agit d'une boucle infinie.

Une boucle infinie peut être provoquée par une erreur de programmation. Un compteur qui n'est jamais augmenté peut par exemple empêcher une boucle prévue pour compter jusqu'à 100 d'atteindre sa condition d'arrêt.

Certaines boucles infinies sont cependant volontaires. Un serveur ou un système embarqué peut rester en fonctionnement permanent et répéter continuellement une série d'instructions pour surveiller des demandes ou des capteurs.

Les boucles dans les programmes

Les boucles sont utilisées dans de très nombreux programmes. Elles permettent de parcourir des fichiers, rechercher une information, effectuer des calculs répétitifs, traiter des images, analyser des données ou gérer les éléments d'un jeu vidéo.

Un ordinateur peut exécuter des milliers ou des millions de répétitions très rapidement. Une boucle permet ainsi de traiter automatiquement une grande quantité de données sans écrire une instruction différente pour chaque élément.

Les boucles constituent donc, avec les séquences, les variables et les conditions, l'une des structures fondamentales de la programmation.