Programmes, code et exécution par l’ordinateur

Matériel et logiciel

Un ordinateur est une machine qui suit des instructions très rapidement. Les parties physiques que vous pourriez toucher forment le matériel ; les instructions qui disent à ces parties quoi faire forment le logiciel. Un ordinateur portable, un téléphone, le serveur qui fait tourner le site web de votre banque et la puce d’un thermostat connecté sont tous des ordinateurs construits à partir des quatre mêmes types de composants.

Le CPU (unité centrale de traitement, ou processeur) exécute les instructions. Un processeur moderne possède plusieurs cœurs, chacun capable de traiter son propre flux d’instructions, et chaque cœur exécute des milliards d’étapes simples par seconde. La RAM (mémoire vive, généralement appelée simplement mémoire) contient les instructions et les données sur lesquelles le CPU travaille en ce moment. Elle est rapide, mais volatile : coupez le courant et son contenu disparaît. Le stockage (un disque SSD ou un disque dur à plateaux) conserve les fichiers quand l’appareil est éteint, mais il est beaucoup plus lent d’accès. Une carte réseau (filaire ou Wi-Fi) envoie des données vers d’autres ordinateurs et en reçoit.

Pensez à la cuisine d’un restaurant. Le chef est le CPU : le seul qui cuisine vraiment. Le plan de travail est la RAM : tout ce que le chef utilise à cet instant y est disposé, à portée de main, mais il est débarrassé en fin de soirée. Le garde-manger et le congélateur sont le stockage : vastes, permanents et à quelques pas. Le passe-plat vers la salle est la carte réseau, par lequel les commandes arrivent et les plats repartent. Les recettes sont le logiciel.

Ce qu’est un programme

Un programme est une liste d’instructions précises qu’un ordinateur suit pour accomplir une tâche : calculer une facture, afficher une page web, envoyer un paiement. Le mot qui compte est précises. Un cuisinier humain sait se débrouiller avec « saler à votre goût » ; un ordinateur, non. Il fait exactement ce qu’on lui dit, exactement dans l’ordre où on le lui dit, et rien de plus. Si une instruction demande de diviser par un nombre qui se révèle être zéro, l’ordinateur ne hausse pas les épaules pour continuer : le programme s’arrête sur une erreur, à moins que le programmeur n’ait écrit d’autres instructions indiquant quoi faire dans ce cas.

Au niveau le plus bas, le CPU répète un même cycle tant qu’il est allumé : aller chercher l’instruction suivante en mémoire, décoder ce qu’elle signifie, l’exécuter, puis passer à la suivante. Chaque instruction est minuscule : additionner deux nombres, comparer deux valeurs, copier une valeur d’un endroit de la mémoire à un autre, sauter à une autre instruction si une comparaison était vraie. Tout ce que fait un ordinateur, de la lecture d’un film à l’entraînement d’un modèle d’IA, est construit à partir de milliards de ces petites étapes.

Le logiciel est le terme le plus large : les programmes ainsi que les données, la configuration et la documentation dont ils ont besoin. Une application (ou app) est un logiciel qui fait quelque chose d’utile pour une personne, comme une application bancaire. Le logiciel système, comme le système d’exploitation décrit plus bas, existe surtout pour faire fonctionner d’autres logiciels.

Le code source et les langages de programmation

Les CPU ne comprennent que le code machine : des instructions codées sous forme de nombres, propres à une famille de processeurs. Les puces Intel et AMD de la plupart des ordinateurs portables et des serveurs utilisent une famille (x86-64) ; les puces des téléphones, des Mac récents et de nombreux serveurs cloud en utilisent une autre (Arm). Le code machine qui tourne sur l’une ne tourne pas sur l’autre. Écrire du code machine à la main est lent, source d’erreurs et ne se fait presque plus aujourd’hui.

À la place, on écrit du code source dans un langage de programmation : une notation définie avec précision, qui se lit en partie comme de l’anglais et en partie comme des mathématiques. Python, JavaScript, Java, C#, Go, Rust et C en sont des exemples très répandus. On les appelle des langages de haut niveau parce qu’ils permettent à un programmeur de dire « additionne les prix de ce panier » en une ou deux lignes au lieu de dizaines d’instructions machine, et parce qu’ils cachent les détails du CPU utilisé. Le code source est du texte brut, enregistré dans des fichiers, et c’est ce que les programmeurs lisent, écrivent, relisent et conservent dans un système de gestion de versions (un système qui garde l’historique de chaque modification, expliqué dans la dernière section de ce chapitre).

Les langages diffèrent par ce qu’ils rendent facile. Python est apprécié pour sa lisibilité et domine la science des données et l’IA ; JavaScript est le langage qu’exécute tout navigateur web ; Java et C# sont courants dans les grands systèmes de gestion ; Go est populaire pour les services réseau ; C et Rust sont utilisés là où chaque microseconde et chaque octet comptent, comme dans les systèmes d’exploitation et les bases de données. Aucun langage n’est le meilleur en tout, et en choisir un est à la fois une décision technique et une question de compétences disponibles dans l’équipe.

Du code source à un programme en cours d’exécution : compilateurs, interpréteurs et machines virtuelles

Le code source doit être transformé en quelque chose que le CPU peut exécuter. Il existe trois grandes approches, et les langages réels les combinent souvent.

Un compilateur est un programme qui traduit l’ensemble du code source d’un programme sous une autre forme avant son exécution. Des langages comme C, C++, Rust et Go sont généralement compilés à l’avance en code machine pour un CPU et un système d’exploitation donnés. Le résultat est un fichier exécutable qui démarre vite et s’exécute rapidement, mais il faut compiler une version distincte pour chaque type de machine que vous voulez prendre en charge, et le compilateur rejette le programme s’il y trouve certains types d’erreurs.

Un interpréteur est un programme qui lit le code source (ou quelque chose de très proche) et exécute ses instructions au fur et à mesure, une étape à la fois. L’interprétation permet d’essayer facilement des choses et d’exécuter le même programme sur toute machine dotée de l’interpréteur, au prix de la vitesse.

De nombreux langages populaires se situent entre les deux. Le code source Java est compilé par un outil appelé javac en bytecode : des instructions compactes destinées à un ordinateur imaginaire et idéalisé plutôt qu’à un vrai CPU. La machine virtuelle Java (JVM) exécute ensuite ce bytecode sur la machine réelle où elle est installée, ce qui permet à un même programme Java de tourner sans modification sous Windows, macOS et Linux. La JVM repère les parties du programme qui s’exécutent le plus souvent et les compile en code machine pendant l’exécution, une technique appelée compilation juste-à-temps (JIT). C# sur .NET fonctionne de façon similaire. L’implémentation standard de Python, CPython, compile elle aussi vos fichiers .py en bytecode (en mettant en cache le bytecode des modules importés dans des fichiers .pyc), puis exécute ce bytecode dans sa propre boucle d’interprétation.

Le rôle du système d’exploitation

Quand vous allumez un ordinateur, le premier programme important à démarrer est le système d’exploitation (OS) : Windows, macOS, Linux, Android ou iOS. La plupart des serveurs d’internet tournent sous Linux. Le système d’exploitation a quatre grandes missions.

Premièrement, il partage le CPU. Un ordinateur portable peut avoir quelques dizaines de programmes en cours d’exécution mais seulement une poignée de cœurs : l’OS fait donc passer chaque cœur d’un programme à l’autre de nombreuses fois par seconde, assez vite pour qu’ils semblent tous tourner en même temps. Deuxièmement, il gère la mémoire, en donnant à chaque programme sa propre zone et en empêchant un programme de lire ou d’écraser celle d’un autre. Troisièmement, il fournit les fichiers et les périphériques : les programmes demandent à l’OS d’ouvrir un fichier, de dessiner à l’écran ou d’envoyer des données sur le réseau, et l’OS, au moyen de petits programmes appelés pilotes, s’occupe du matériel particulier. Quatrièmement, il fait respecter la sécurité : les utilisateurs, les autorisations et la règle selon laquelle une app ne peut pas lire vos photos sans votre accord.

Les programmes font ces demandes au moyen d’appels système, un ensemble fixe de services proposés par l’OS. C’est le premier exemple, dans ce cours, d’une idée architecturale importante : une couche qui cache des détails compliqués derrière un ensemble stable de demandes. La personne qui écrit une app de livraison de repas n’a pas besoin de savoir de quelle marque est la puce réseau du téléphone.

Processus, threads, mémoire et disque

Un fichier de programme posé sur le disque n’est qu’un ensemble d’instructions stockées. Quand vous le lancez, l’OS crée un processus : une instance en cours d’exécution du programme, avec sa propre mémoire privée, sa propre identité et sa propre part de temps CPU. Ouvrez deux fenêtres de navigateur et vous aurez peut-être plusieurs processus ; démarrez un serveur web et il pourra tourner sous la forme d’un seul processus ou de plusieurs.

À l’intérieur d’un processus, il peut y avoir plusieurs threads. Un thread est une séquence d’instructions en cours d’exécution. Un processus à plusieurs threads peut faire plusieurs choses à la fois, par exemple traiter en même temps les requêtes de deux clients, et tous ses threads partagent la mémoire du processus. Ce partage est pratique mais risqué : si deux threads modifient la même donnée au même moment sans coordination, le résultat peut être faux d’une manière qui n’apparaît qu’occasionnellement. Ces bugs de concurrence comptent parmi les plus difficiles à trouver, ce qui explique en partie pourquoi beaucoup de systèmes préfèrent des processus séparés, ou des conceptions où chaque requête est traitée indépendamment.

La différence entre la mémoire et le disque explique une grande partie de la conception logicielle. Les données en RAM sont rapides d’accès, environ un dixième de microseconde, mais elles disparaissent quand le processus se termine, plante ou que la machine redémarre. Les données sur disque survivent, mais y accéder prend bien plus longtemps : des dizaines de microsecondes ou plus sur un SSD, et plusieurs millisecondes sur un disque à plateaux. Toute information qui ne doit pas être perdue, comme une commande ou un paiement, doit donc être écrite sur un stockage durable, généralement au moyen d’une base de données, avant que le système ne dise au client « c’est fait ».

PRICE_PER_ITEM = 12.50   # pounds
VAT_RATE = 0.20          # 20 per cent

def total_with_vat(quantity):
    subtotal = quantity * PRICE_PER_ITEM
    return subtotal * (1 + VAT_RATE)

quantity = int(input("How many items? "))
print("Total to pay:", round(total_with_vat(quantity), 2))

Les bugs : quand les instructions sont fausses

Un bug est une erreur dans un logiciel qui le fait se comporter autrement que prévu. Comme les ordinateurs suivent les instructions à la lettre, presque tout bug est un écart entre ce que le programmeur voulait dire et ce qu’il a réellement écrit, ou une situation à laquelle personne n’avait pensé.

Il est utile d’en distinguer trois sortes. Une erreur de syntaxe enfreint la grammaire du langage (une parenthèse manquante) : le compilateur ou l’interpréteur refuse alors purement et simplement d’exécuter le programme ; ces erreurs sont repérées immédiatement. Une erreur d’exécution survient pendant que le programme tourne, par exemple une division par zéro ou la lecture d’un fichier qui n’existe pas ; le programme s’arrête généralement avec un message d’erreur. Une erreur de logique est la plus dangereuse : le programme tourne sans problème et donne la mauvaise réponse, par exemple en facturant la TVA deux fois. Rien ne plante, si bien que seuls les tests, une relecture attentive ou un client mécontent la révéleront.

Les équipes professionnelles s’attendent aux bugs et mettent en place des défenses : tests automatisés, revue de code, mises en production progressives et supervision qui remarque quand les taux d’erreur augmentent. Beaucoup de ces défenses sont architecturales, et on les retrouve tout au long de ce cours.

Pourquoi c’est important pour l’architecture

L’architecture porte sur les grandes décisions coûteuses à changer, et plusieurs d’entre elles reposent sur les idées de cette section. Le choix du langage et de l’environnement d’exécution influe sur le temps de démarrage, la consommation de mémoire, les bibliothèques utilisables et les profils que vous pouvez recruter. La séparation entre mémoire et disque détermine ce qui doit être stocké durablement, et comment un système se rétablit après un plantage. Les processus et les threads sont les unités qui s’exécutent, tombent en panne et passent à l’échelle : un chapitre ultérieur se demande si un système doit être un seul processus ou plusieurs processus qui coopèrent. Enfin, la conception en couches du système d’exploitation, qui cache le matériel derrière un ensemble stable de demandes, est la première illustration d’un principe que vous retrouverez sous le nom de masquage de l’information.

La section suivante s’intéresse à ce sur quoi travaillent réellement les programmes : les données, ainsi que les structures et les algorithmes qui rendent ce travail rapide ou lent.