1.2 Pourquoi programmer ?

Dans ce premier chapitre, nous allons discuter de l'intêret de la programmation, puis présenter rapidement le langage R et son utilité. Ce chapitre n'est pas parfaitement indispensable; si vous voulez plonger directement dans le code car vous avez déjà une expérience des langage de programmation, vous pouvez le passer. Si à l'inverse vous êtes un programmeur débutant, nous vous conseillons de rester avec nous !

Pourquoi des langages de programmation ?

Il existe de nombreux langages de programmation, qui ont tous le même but : communiquer avec un ordinateur pour lui donner des instructions. Un langage de programmation est, contrairement à ce que l'on pourrait croire, conçu pour l'être humain qui va écrire le programme, plutôt que pour l'ordinateur qui va l'exécuter. En effet, un ordinateur ne comprends que le langage binaire, c'est à dire une suite de 0 et de 1. Voici par exemple un petit programme, écrit en binaire, qui calcul la somme des nombres entre 1 et 10 :

00110001 00000000 00000000
00110001 00000001 00000001
00110011 00000001 00000010
01010001 00001011 00000010
00100010 00000010 00001000
01000011 00000001 00000000
01000001 00000001 00000001
00010000 00000010 00000000
01100010 00000000 00000000

Un ordinateur est tout à fait à l'aise avec ce langage, et la plupart de nos machines (ou téléphones et autres objets connectés) sont parfaitement capables de lire ces instructions et de trouver le résultat attendu (qui est 55, dont l'écriture en binaire est 110111 ).

Mais pour nous êtres humains, cette façon d'écrire des instructions à l'ordinateur n'est pas très lisible. Pour une raison simple : nous ne parlons pas le binaire. Un programmeur entrainé et ayant appris à lire le binaire lirait ce premier code avec difficultés. Il serait au contraire bien plus à l'aise (et nous aussi ) avec une suite d'instructions qui ressemblerait à quelque chose comme ça :

#Instructions pour cacluler la somme des nombres entre 1 et 10 
Etape 1 : stocker en mémoire le nombre 0
Etape 2 : Ajouter à ce nombre le nombre 1
Etape 3 : Ajouter au nombre précédent le nombre 2
....
Etape 11 : Ajouter au nombre précédent le nombre 10
Etape 12 : Donner le résultat (qui vaut 55)

Il s'agit dans les deux cas d'exprimer la même chose (calculer la somme des nombres entre 1 et 10). Dans le premier cas, le cas binaire, les instructions sont pénibles à lire pour l'humain et facile pour l'ordinateur. Dans le second cas, les instructions sont clair pour nous, mais malheureusement incompréhensible pour notre machine (qui ne sait lire que le binaire). Comment dès l'or communiquer de façon efficace avec notre ordinateur ? Devons nous apprendre le binaire ? Ou au contraire essayer d'apprendre notre langage naturelle aux ordinateurs ?

Une interface entre la machine et le programmeur

Pour résoudre ce problème, nous utilisons des langages de programmation, qui sont une couche intérmédiaire entre nous et la machine. Plutôt que d'apprendre le binaire, nous apprennons un langage intermédiaire, qui est facile à manipuler et qui nous permet d'exprimer nos instructions. Puis ce langage est "traduit" en binaire, pour que le processeur de notre ordinateur puisse le comprendre.

Prennons un exemple pour illustrer ce processus. Supposons que nous voulions communiquer avec notre ami Sergeï qui ne parle que le russe. Nous ne parlons que le français et l'anglais. Nous pourions apprendre le russe, mais cela serait long, pénible, et probablement peu efficace. Une solution pratique serait de trouver un traducteur qui parlerait anglais et russe. Nous parlerions alors en anglais à l'interprête, qui lui transcrirait nos propos en russe à notre interlocuteur. L'anglais devient alors une langue intérmédiaire entre nous et notre ami étranger.

Un langage de programmation joue ce même rôle là d'interface entre le programmeur et l'ordinateur. C'est un langage intermédiaire, que l'ordinateur ne peut pas comprendre directement mais qui est facile à traduire dans une langue qu'il comprenne (des 0 et des 1) si l'on dispose d'un traducteur. En programmation, le rôle du traducteur (qui traduit les instructions du langage de programmation en langage binaire) est tennu par ce qu'on appelle un compilateur ou un interprêteur. Comme son nom l'indique, l'interprêteur est un logiciel qui interprête les instructions du langage de programmation pour les rendre compréhensible à notre ordinateur.

La façon dont nous avons écrit les instructions dans le code précédent ne correspondait pas à un véritable langage informatique. C'était une liste d'instructions qui ressemblait à du code, sans en être vraiment. Voici un exemple de véritable code en R qui reproduit les étapes précédentes pour calculer la somme des nombres entre 1 et 10 :

resultat = 0
resultat = resultat + 1
resultat = resultat + 2
resultat = resultat + 3
resultat = resultat + 4
resultat = resultat + 5
resultat = resultat + 6
resultat = resultat + 7
resultat = resultat + 8
resultat = resultat + 9
resultat = resultat + 10
# on affiche le résultat
print(resultat)

Ce code semble plutôt facile à comprendre non ? La première ligne nous dis que le resultat a pour valeur 0 au départ. La ligne suivante ajoute 1 au résultat. Le ligne d'après ajoute elle 2 au résultat de la ligne précédente. Et ainsi de suite, jusqu'à ce qu'on ajoute 10 à la somme des résultats précédents. Enfin la dernière ligne affiche le résultat final avec l'instruction print(result).

Un code un peu plus complexe

Ce premier code peut néanmoins sembler un peu répétitif : la plupart des instructions (une instruction occupe une ligne ici) sont presques identiques et se contentent d'ajouter un nombre qui augmente de 1 au résultat précédent. De plus si nous voulions calculer la somme des nombres jusqu'a 10 000, notre programme serait très long. Heureusement pour nous, la plupart des langages de programmation disposent de différents moyens de simplifier les instructions complexes pour éviter de se répéter. Voici une façon plus élégante de résoudre ce probléme, en utilisant une boucle :

total = 0
compteur = 1
while ( compteur <= 10) {
  total = total + compteur 
  compteur = compteur + 1
}
print(total)

Cette fois-ci les instructions semblent plus complexes, mais nous pouvons facilement les comprendre en réfléchissant un peu. Ce programme comporte une boucle, qui ajoute un nombre compteur à un nombre total , jusqu'à ce que le nombre compteur atteigne 10. Alors on a bien ajouté la somme des nombres de 1 à 10 si on pense à augmenter de 1 la valeur du compteur à chaque tour de la boucle.

Regardons ce code plus en détail. La première ligne de code intialise le total de la somme que l'on cherche à calculer à 0, avec l'instructiontotal = 0 . La seconde ligne définie elle le compteur de départ et lui donne la valeur de 1, ce qui s'écrit compteur = 1.

Ensuite nous rencontrons à la ligne 3 l'instruction while qui nous permet de construire notre boucle. La boucle demande de répéter les instructions entre les {} tant que la condition entre les parenthèses est vraie. Cette condition est que le compteur soit inférieur ou égal à 10.

Le code entre les accolades (ligne 4 à 7) indique lui ce qu'on fait à chaque tour de la boucle. On commence par ajouter au total la valeur du compteur, avec l'instruction total = total + compteur . Puis on ajoute 1 à la valeur actuelle du compteur avec compteur = compteur + 1. L'accolade fermante } de la ligne 8 indique la fin des instructions à suivre à chaque tour de boucle.

Cette boucle se répète alors jusqu'à ce que le compteur dépasse la valeur de 10 et alors la boucle s'arrête. La dernière ligne du programme permet alors d'afficher le résultat : print(total).

Si ce programme vous semble un peu compliqué, cela est normal. Le but de cet exemple est simplement de vous montrer comment un langage de programmation nous permet de donner des instructions plus complexes que le premier code, et comment le comprendre en tant qu'humain. Nous apprendrons les différentes façons de donner ces instructions, comme des boucles, plus tard dans ce livre.

Les différents langages de programmation et R

Il existe différents langages de programmations dans le monde, parmis lesquels les plus connus sont java, C, PHP, javascript ou encore python. Vous avez peut-être déjà entendu plusieurs de ces noms.

Pourquoi existe-il plusieurs langages différents ? On pourrait penser intruitivement qu'il serait plus pratique d'avoir un seul langage de programmation. Certains intellectuels pensent par exemple qu'une seule langue aiderait les hommes à mieux communiquer entre eux. Malheureusement, en informatique, les choses ne sont pas aussi simples. Chaque langage de programmation dispose d'avantages et d'inconvéniants. Un langage sera efficace pour tel usage, mais moins performant pour tel autre. Le choix du langage dépend ainsi de l'objectif que l'on souhaite poursuivre.

Prennons un des langage le plus connu, le langage C. C est un langage très performant, mais qui est plutôt difficile à apprendre en contrepartie. Il vous demande en effet de gérer correctement de nombreux détails du fonctionnement de l'ordinateur. Si vous n'y arrivez pas, votre programme rencontrera des bugs ou cessera simplement de fonctionner. Apprendre un langage comme C revient un peu à apprendre le fonctionnement exact d'un moteur d'automobile avant d'apprendre à conduire. Cela peut être très pratique si vous voulez devenir pilote automobile et vous débrouiller seul en cas de problème, mais pour la majorité des gens un tel niveau de détail ne semble pas utile.

Chaque langage à ainsi ses forces et faiblesses. Le langage qui nous intéresse ici, R, est lui conçu spécialement pour faire des statistiques et manipuler des données. R n'est pas fait pour être très rapide comme le C, ou pour créer des sites internet comme le langage PHP. Mais il permet de faire des calculs mathématiques et du traitement statistique très facilement, ce que ses concurents ne peuvent pas faire. On peut par exemple réaliser une multiplication de matrices en quelques lignes de code seulement avec R ! De plus, R est relativement facile à apprendre et à prendre en main, ce qui en fait un outil idéal pour les étudiants et scientifiques qui n'ont pas beaucoup de temps.