Les langages de programmation ont été introduits pour éviter l'écriture directe
de programmes en langage machine (tâche extrèmement fastidieuse, pour ne pas dire impossible !).
Mais tout d'abord, qu'est-ce qu'un programme ?
Un programme écrit dans un langage de programmation se présente sous la forme d'un texte
dans lequel figurent les instructions à exécuter. Dans ce texte, les plages mémoire contenant
des données portent un nom. Ce sont les variables du programme.
Voici par exemple une instruction écrite en pascal:
somme := x + y;
Cette instruction signifie : additionner
les nombres contenus dans les variables x et y et stocker le résultat
dans la variable somme.
Dans les cours de programmation, un programme est souvent défini comme une suite d'instructions.
Cette définition n'est pas tout à fait exacte car les programmes contiennent également des
déclarations.
Une déclaration permet (entre autre) de définir
la nature des variables sur lesquelles le programme doit travailler.
Voici par exemple une déclaration de variable écrite en pascal:
var x, y , somme : integer;
Ici le programmeur a déclaré que les variables x, y et
somme doivent contenir des nombres entiers.
Un langage de programmation est un ensemble de conventions définissant la manière
d'écrire un programme sous la forme d'un texte.
Ces conventions comprennent des conventions syntaxiques
(comparables à la grammaire d'une langue naturelle)
et lexicales (comparables à l'orthographe d'une langue naturelle).
Elles sont évidemment différentes d'un langage à l'autre.
Voici par exemple l'instruction d'addition vue plus haut traduite dans différents langages de programmation:
On constate que dans certains langages (comme Php et LISP) les déclarations de variables ne sont pas
obligatoires.
Ces langages sont dits non typés.
Tous les langages de programmation possédent des mots spéciaux, que l'on appelle
des mots clés (dans l'exemple ci-dessus, ces mots figurent en gras).
Les mots clés ont une signification particulière prédéfinie dans le langage de
programmation. Ils ne peuvent donc pas être utilisé par le programmeur pour signifier autre chose.
En Pascal par exemple, le mot clé Integer signifie nombre entier. Ce mot ne pourra donc pas
être utilisé par le programmeur pour représenter autre chose, comme un nom de variable par exemple.
Les séparateurs sont des caractères qui jouent en gros le même rôle que les caractères de
ponctuation en francais: la virgule, le point-virgule et le point. En programmation, le point-virgule
sert par exemple très souvent à séparer les
instructions (langages C, Java et Pascal). La virgule est également très souvent utilisée comme séparateur
(par exemple pour séparer les noms de variables dans une déclaration).
Notez que certains langages (comme Visual Basic) utilise le passage à la ligne comme séparateur d'instruction,
ce qui interdit d'écrire plusieurs instructions dans la même ligne.
Mais dans la plupart des langages actuels, le passage à la ligne n'a aucune importance.
Pour en revenir aux conventions lexicales, elles définissent en particulier les règles d'écriture des noms
de variables (exemple en Php, un nom de variable commence par $), ou simplement l'orthographe des mots clé.
Quand aux conventions syntaxiques, elles concernent plutot l'ordre des mots ou leur
présence obligatoire ou optionnelle.
Exemple, en Java:
x , y int;
est incorrect du point de vu syntaxique, car int doit figurer en premier.
Autre exemple, en Pascal:
Var x y : integer ;
est incorrect du point de vu syntaxique, car il manque une virgule entre x et y.
Un programme écrit dans un langage de programmation se présente sous la forme d'un
ou plusieurs fichiers appelés fichier sources (par opposition aux fichier exécutables).
Ces fichiers contiennent les programmes tels qu'ils ont été initialement
écrits par les développeurs. Ce sont des textes écrits en un langage de programmation
particulier, que l'on peut visualiser à l'aide d'un éditeur de texte (WordPad par
exemple).
Mais, comme nous l'avons déjà dit plus haut, le seul langage de programmation directement
exécutable par un ordinateur est le langage machine adapté à son processeur.
Les fichiers sources doivent donc être traduits en langage machine
avant de pouvoir être exécutés. On appelle cela la compilation.
Mais nous verrons plus loin que la compilation n'est pas la seule approche
possible: il en existe une autre appelée interpretation.
Certains langages, comme le C par exemple, ne peuvent être que compilés.
Les langages de ce type sont appelés langages compilés.
Pour pouvoir les utiliser, vous devez avoir installé sur votre ordinateur
un compilateur
(schéma) spécifique à ce langage.
Le compilateur est un programme exécutable qui permet de traduire
un programme écrit dans un langage de programmation en langage machine.
Par exemple, pour pouvoir programmer en C, vous devez nécessairement avoir
installé un compilateur C sur votre machine.
Après avoir été compilé, le programme peut être exécuté en chargeant sa version
exécutable en mémoire
(schéma).
Pour fixer un peu les idées, reprenons le programme d'addition en Pascal et voyons comment il pourrait
être traduit en langage machine.
Les variables déclarées sont tout d'abord associées à des plages mémoire:
Les instructions sont ensuite traduites en instructions machine portant sur les registres et
les plages mémoire associées aux variables:
Dans cet exemple, nous n'avons pas donné le code binaire des instructions machine car il serait sans intérêt.
On voit qu'une simple instruction écrite en langage de programmation peut correspondre à de nombreuses
instructions machine.
Les programmes écrits en langages interpretés (Java,
Visual Basic, Php,....)
peuvent être exécutés sans avoir été
auparavant entièrement traduits en langage machine.
Ils font appel à un interpréteur.
Tout comme un compilateur, un interprèteur est spécifique à un langage donné.
Il existe par exemple, un interpréteur Java, un interpréteur Visual Basic,
un interpréteur Php, ...
Contrairement aux programmes compilés, les programmes interprètés ne sont
pas directement exécutés par l'ordinateur, mais pas l'interpréteur (qui lui
est exécuté par la machine !).
Pour exécuter un programme interprèté, il faut tout d'abord lancer l'interpréteur,
puis charger le code source du programme en mémoire. Ce code source peut ensuite
être exécuté par l'interpréteur
(schéma).
L'interpréteur s'exécute donc toujours "en même temps" que le programme
interprété.
Notez que certains interpréteurs (comme Visual Basic par exemple), peuvent également
fonctionner en tant que compilateur. Cela permet d'obtenir une version plus
rapide et commercialisable du programme, lorsque la mise au point est terminée.
En effet:
- l'exécution d'un programme compilé est beaucoup plus rapide que son interprétation.
- sous sa forme exécutable, un programme peut être vendu sans divulguer
les fichiers sources, ainsi qu'à des utilisateurs ne possédant pas l'interpréteur
sur leur machine.
Dans tout langage de programmation, il est possible d'insérer du texte dans le code source
de telle manière que ce texte soit totalement ignoré du compilateur (ou de l'interpréteur): ce texte
constitue un commentaire. L'utilité d'un commentaire est, comme son nom l'indique de
commenter le code, de manière à le rendre plus lisible.
Les conventions d'écriture des commentaires diffèrent selon les langages, mais on a généralement deux
manières d'écrire des commentaires: la première n'autorise que des commentaire sur une seule ligne, alors que
la second permet des commentaires sur plusieurs lignes.
En langage C, Java et Pascal, les commentaires sur une ligne commencent par //.
Exemple (en C ou Java):
// Calcul de la somme de x et y
somme = x + y;
Ils peuvent figurer sur la même ligne qu'une instruction du langage. Exemple:
somme = x + y; // Calcul de la somme de x et y
En fait, toute la partie de la ligne qui suit les // est ignorée par le compilateur.
Pour les commentaires multi-lignes, il faut définir le début et la fin du commentaire.
Dans les langages tels que C et Java, le début d'un commentaire multi-lignes se note /*
et la fin se note */. Exemple en C ou Java:
/* L'instruction suivante additionne x et y
et stocke le résultat dans somme */
somme = x + y;
Un programme ne marche quasiment jamais du premier coup. Surtout s'il est long et complexe.
Lorsque vous vous lancez dans la programmation, vous devez donc vous faire à l'idée que vous allez faire
des erreurs. Et ne croyez pas que vous cesserez d'en faire lorsque vous aurez des années de programmation
derrière vous ! Les erreurs seront bien sur moins nombreuses qu'au début, mais vous continuerez à en faire.
Certaines erreurs sont détectables par le compilateur (ou l'interpréteur).
Ce sont par exemple les erreurs de syntaxe : le code que vous écrivez
ne respecte pas la syntaxe du langage. Ce type d'erreur est le plus facile à corriger.
Le compilateur (ou l'intéprèteur) vous affiche un message d'erreur. En général, ce message est suffisament
clair et précis pour pouvoir immédiatement corriger l'erreur.
Un programme compilable (ou interprétable), n'est malheureusement pas forcément juste.
Il peut contenir des erreurs de logique. Ce type d'erreur se traduit par le fait que les
résultats produits par votre programme ne sont pas les résultats attendus.
Lorsque vous vous trouverez dans cette situation, ne croyez jamais que l'ordinateur se trompe.
Un ordinateur fait toujours exactement ce que vous lui demandez de faire ! Si votre programme ne fonctionne
pas correctement, c'est donc que les instructions qu'il contient ne sont pas les bonnes.
Un programme compilable ou interprétable peut également brutalement cesser de fonctionner, avant de produire un
quelconque résultat. En général cela produit l'affichage d'un message d'erreur.
On parle alors d'erreur d'exécution ou en langage courant de 'plantage'.
Une erreur d'exécution peut être due à une erreur de logique, mais également à une mauvaise utilisation
du programme: l'utilisateur entre des données ingérables. Mais en principe, un bon programme devrait être
protégé contre toutes les erreurs de mauvaise utilisation. C'est à dire que la conception même du programme
doit interdire toute manipulation erronée.
Ceci est bien entendu théorique, car il est très difficile de prévoir toutes les erreurs
d'utilisation possibles d'un programme !
Pour s'en convaincre, il suffit de voir le nombre d'erreurs d'exécution dans les logiciels commercialisés.
Le terme bogue (ou bug en anglais) est souvent utilisé
en informatique pour désigner une erreur de programmation de type erreur logique.
Dans le meilleur des cas, une simple relecture du code permettra de localiser le bug.
Sinon, il faudra utiliser des techniques de débogage
(ou debugging en anglais).
Cela consiste en général à afficher les valeurs des variables (celles qui sont à priori en rapport
avec le bogue) à différents endroits critiques du programme de manière à localiser la partie du programme
où se trouve le bogue.
La développement d'application (ou si vous préférez la programmation) se fait aujourd'hui grâce à des logiciels
appelés E.D.I (pour Environnement de Développement Intégré)
ou I.D.E en anglais.
Un E.D.I peut être adapté à un langage de programmation particulier (Delphi, Lazarus pour le langage Pascal,
Visual C++ pour le langage C++) ou à plusieurs langages (Eclipse ou NetBeans pour Java, Php, Javascript).
Un E.D.I comprend en général un éditeur de texte spécialement adapté au langage,
un compilateur et/ou un interpréteur, des outils de débogage
et surtout un outil de développement d'interface graphique.
Avant l'existence des E.D.Is, la conception de l'interface graphique d'un programme
était extrèmement fastidieuse
car le développeur devait lui même préciser dans le programme les positions et dimensions de tous les composants
de l'interface.
Avec un E.D.I. cela se fait simplement en "dessinant" en quelque sorte l'interface graphique à l'aide de la
souris. Evidemment les instructions permettant d'afficher l'interface existent toujours, mais au lieu d'être
données par le programmeur, elles sont générées automatiquement par l'E.D.I.
Avec l'apparition des interfaces graphiques dans les années 80, la programmation est devenue plus complexe.
Les programmes devaient d'une part produire tout le design de l'interface et d'autre part
pouvoir réagir aux évènements, c'est à dire aux actions de l'utilisateur sur les différents composant de cette
interface.
Il est alors apparu une nouvelle manière de programmer, appelé
programmation évènementielle qui consiste à associer des gestionnaires d'évènement aux
composants de l'interface.
Un des premiers langages permettant la programmation évènementielle a été le langage Visual Basic de Alan Cooper
(première version en 1991) et son environnement de développement intégré (un des premiers également).
Le concept a ensuite été repris par Boreland avec Delphi.
|
| Alan Cooper - inventeur du Visual Basic |
Un des points les plus intéressants des E.D.Is est qu'ils facilitent la programmation évènementielle.
Rappelons qu'avec un E.D.I, l'interface graphique peut être "dessiné" par le programmmeur. Il peut ensuite
associer un gestionnaire d'évènement (initialement vide) à un composant de l'interface en
cliquant sur celui-ci.