Le langage de programmation le plus simple permettant d'implémenter directement un algorithme impératif par simple traduction de celui-ci est le langage Pascal, qui a été développé dans cette optique. Ainsi, un travail pratique qui peut accompagner l'apprentissage peut être simplement d'expérimenter des programmes en les recopiant et en visionnant le résultat en situation, sur une machine.

Prérequis

Les limites de l'ordinateur

Un ordinateur est une machine finie (par curiosité, vous pouvez voir la notion d'automate fini). De ce fait on ne peut pas tout calculer en un temps fini. Votre algorithme peut être bon mais ne pas fonctionner sur ordinateur. La finitude se voit aussi dans les grandeurs. Vous ne pouvez pas manipuler des nombres aussi grand que vous voulez. Les technologies ont leur limite. Cependant, les ordinateurs d'aujourd'hui sont assez développés pour que vous ayez une assez grande marge de manœuvre.

1c:=30000+a 
2c:=c-b

1c:=30000-b
2c:=c+a

Comment programme-t-on ?

Vous avez donc votre algorithme, comme vous êtes doué(e) : vous êtes sûr(e) qu'il fonctionne, cependant vous voulez le vérifier in situ sur un ordinateur. Voici les étapes (toutes expliquées ci-après) à suivre pour obtenir votre programme informatique :

1. Traduire l'algorithme en Pascal : cette étape peut se faire sur papier, au brouillon. Comme c'est simple et rapide on peut traduire en même temps qu'on fait l'étape suivante.
2. Recopier la traduction (le code source) dans un éditeur de texte.
3. Compiler le code source pour le transformer en programme machine (ou binaire).

Le compilateur a engendré un programme, il ne vous reste qu'à l'exécuter pour vous en servir ou le tester.

Traduire l'algorithme en Pascal

Pascal ayant été prévu dans cette optique, il est très facile de convertir un algorithme (sur papier) en un programme exécutable (fichier texte sur un ordinateur). Voici un exemple de traduction afin de vous montrer que la ressemblance est réelle et que la traduction est facile. Cet exemple reprend l'algorithme donné dans le chapitre d'introduction.

Voici l'algorithme :

 1Algorithme cercle
 2Constantes
 3  pi = 3.1415
 4Lexique
 5  rayon     : réel (* le rayon donné par l'utilisateur *)
 6  périmètre : réel (* le périmètre du cercle *)
 7Début
 8  Afficher("Donner le rayon : ")
 9  Lire(rayon)
10  périmètre←2*pi*rayon
11  Afficher("Le périmètre est de : ", périmètre)
12  Afficher("L'aire du cercle est de ", pi*rayon²)
13  Afficher("Le volume de la sphère est de ",(4/3)*pi*rayon³)
14Fin

et le code source en langage Pascal

 1program cercle;
 2const
 3  pi = 3.1415;
 4var
 5  rayon     : real; (* le rayon donné par l'utilisateur *)
 6  perimetre : real; (* le périmètre du cercle *)
 7begin
 8  writeln('Donner le rayon : ');
 9  readln(rayon);
10  perimetre:=2*pi*rayon;
11  writeln('Le périmètre est de : ', perimetre);
12  writeln('L''aire du cercle est de ', pi*sqr(rayon));
13  writeln('Le volume de la sphère est de ',(4/3)*pi*power(rayon,3))
14end.

Pour traduire n'importe quel algorithme dans le langage Pascal, il suffit de respecter un certain nombre de règles de syntaxe simples. Tout ceci est développé dans le guide de traduction en Pascal.

Pour ce qui est de l'indentation : utiliser la caractère de tabulation prévu pour et surtout pas d'espaces. Il s'agit de la touche à gauche de la touche A (clavier AZERTY) ou de la touche Q (en clavier QWERTY). Il est possible que vous trouviez ce caractère trop large, un bon éditeur permet de régler cette largeur en donnant la taille souhaitée en largeurs de caractères, par exemple donner 4 comme valeur fera que les tabulations ont une largeur de 4 caractères si vous utiliser une police mono-espacée (ce qui doit être le cas dans un éditeur de code). Dans le cas contraire, c'est la taille du caractère d'espacement qui est considérée (dans notre exemple, la tabulation aura la même largeur que 4 espaces). Par défaut la taille des tabulations est de 8, nous vous recommandons 2,3 ou 4 à régler selon que me nombre des niveaux d'indentations est très élevé ou plus modéré. À noter qu'on peut essayer avec un réglage à 4 puis décrémenter a posteriori si besoin est.

Avant l'exécution, la compilation

Étape (que beaucoup trouvent la plus agréable, allez savoir pourquoi...) où il n'y a rien à faire puisque le compilateur se débrouille tout seul. Il vous suffit de lui demander de compiler votre code source. Nous n'allons pas décrire ici toutes les façons de faire car il y en a de multiples : cela dépend de vos choix logiciels. (si vous êtes étudiant, votre responsable de TP est censé vous expliquer tout ça).

Lancez la compilation, deux issues sont possibles :

Premier cas : la compilation échoue. Ne paniquez pas car rien n'est joué ! C'est très courant, même les informaticiens qui ont 20 ans de métier font encore parfois des erreurs. La plupart des compilateurs vous diront pourquoi ils refusent de compiler, ils vous indiqueront même où se situe l'erreur (ligne du code source) voire, dans certains cas, ils vous donnerons l'erreur et la correction à faire. Retournez éditer votre code source et corrigez l'erreur. Vous verrez que la plupart du temps il s'agit de fautes d'inattention (des '=' à la place des ':=', d'oublis de points-virgules en fin d'instructions, etc). Relancez la compilation. Parfois il faut recompiler vingt fois avant d'arriver à finir la compilation (c'est fou ce qu'il peut y avoir comme point-virgules...).

Second cas : la compilation fonctionne. Le compilateur vous indique qu'il a réussi. Vous devriez avoir maintenant à côté de votre fichier source un exécutable.

Exécuter le programme

Là encore, il existe tellement de possibilités de faire que nous ne les expliquerons pas ici. Assurez-vous de connaître un moyen d'arrêter un programme récalcitrant. (les étudiants se tourneront encore une fois vers leur enseignants de TP).

Pour tester votre programme, entrez des valeurs comme si vous l'utilisiez. Essayez de tester "toutes" les combinaisons en faisait des essais représentatifs. à expliciter...

 1...
 2writeln('Donnez a');
 3readln(a);
 4writeln('Donnez b');
 5readln(b);
 6c:=a+b;
 7if c >= 100 then
 8  b:=4*c+15;
 9else
10  b:=b*c+10;
11c:=b-a;
12writeln(c);
13repeat
14  readln(a);
15  c:=c+a
16until (a=0);
17writeln(c);
18...

 1...
 2writeln('Donnez a');
 3readln(a);
 4writeln('Donnez b');
 5readln(b);
 6writeln('on va faire c:=a+b avec a valant',a,' et b valant ', b);
 7c:=a+b;
 8writeln('on a maintenant c valant : ',c)
 9if c >= 100 then begin
10  writeln('on est passé dans le cas c >= 100');
11  b:=4*c+15;
12  writeln('b vaut maintenant ',b);
13  end;
14else begin
15  writeln('on est passé dans le cas c < 100');   
16  b:=b*c+10;
17  writeln('b vaut maintenant ',b);
18end;
19writeln('on est sorti du if c >= 100 ');
20writeln('on a a,b,c qui valent ',a,b,c);
21writeln('on fait c:=b-a');
22c:=b-a;
23writeln('c vaut maintenant ',c);
24writeln('on l affiche ');
25writeln(c);
26writeln('on est avant le repeat');
27repeat
28  writeln('on est dans la boucle');
29  readln(a);
30  writeln('on fait c:=c+a avec a et c qui valent',a,c);
31  c:=c+a
32  writeln('c vaut maintenant ',c);
33  writeln('fin de l interieur de boucle');
34until (a=0);
35writeln('on est sorti de la boucle');
36writeln('on affiche c');
37writeln(c);
38...

Exemple complet

Dans cette partie, nous allons voir un cycle de programmation complet.

gedit

Comme environnement de travail, on a choisi de travailler sur le système d'exploitation Ubuntu pour PC. On utilisera gedit comme éditeur de texte et le compilateur Free Pascal car tous deux sont disponibles sur Ubuntu.

Nous allons implémenter l'algorithme suivant :

 1Algorithme inversion_calcul
 2Variables
 3  a : entier
 4  b : entier
 5Début
 6  Afficher("Donnez a")
 7  Lire(a)
 8  Afficher("Donnez b")
 9  Lire(b)
10  a := a+b
11  b := a-b
12  a := a-b
13  Afficher("a vaut ",a)
14  Afficher("b vaut ",b)
15Fin

Il s'agit de l'algorithme demandant deux nombres et les inversant avant de les afficher (inutile mais c'est un exemple). Traduisons-le :

 1program inversion_calcul;
 2Var
 3  a : integer;
 4  b : integer;
 5begin
 6  writeln('Donnez a');
 7  readln(a);
 8  writeln('Donnez b');
 9  readln(b);
10  a := a+b;
11  b := a-b;
12  a := a-b;
13  writeln('a vaut ',a);
14  writeln('b vaut ',b);
15end.

On recopie la traduction dans gedit, puis on enregistre dans un fichier inversion.pas :

notre code source dans gedit

Remarquez que gedit colorie le code de façon à le rendre plus lisible (on parle de coloration syntaxique).

Passons à la compilation : on a ouvert un terminal et taper la commande

fpc inversion.pas

capture d'écran d'un terminal dans lequel on a entré la commande fpc inversion.pas pour compiler notre code source inversion.pas

Le terminal affiche alors :

1Free Pascal Compiler version 2.0.4 [2006/08/22] for i386
2Copyright (c) 1993-2006 by Florian Klaempfl
3Target OS: Linux for i386
4Compiling inversion.pas
5Linking inversion
615 Lines compiled, 0.0 sec

Les 15 lignes ont bien été compilées (ligne 6), le compilateur à créé un binaire inversion. Testons-le : dans le terminal, on donne la commande ./inversion pour lancer le programme.

Le programme se lance. Voici un test :

le programme nous demande, comme prévu, d'entrer a et b. Testons avec 21 et 39

On a entré nos deux nombres : notre programme va nous donner le résultat.

affichage du résultat : 39 et 21

Notre programme semble fonctionner. Les deux nombres ont bien été inversés. L'expérience est concluante, cependant, voyons ce qu'il se passe si on atteint les limites du codage des entiers.

Testons avec deux grands nombres :

le programme nous demande, comme prévu, d'entrer a et b. Testons avec 34567 et 5123

Le programme nous indique les résultats 5123 et -30969. Notre programme, comme tous les programmes a donc ses limites même si notre algorithme est bon.