# Comment fonctionne un ordinateur : composants, exécution d'un programme et langages de programmation<no value>

## Dans cette leçon

Cette leçon se compose de quelques chapitres courts, dans le même ordre que les diapositives :

1. **Chapitre 1** — les composants de l'ordinateur : CPU, RAM, stockage et registres
2. **Chapitre 2** — ce qui se passe entre le lancement d'un programme et son exécution
3. **Chapitre 3** — les types de langages de programmation : du code machine à Python

## Chapitre 1 : Les composants de l'ordinateur : CPU, RAM, stockage et registres

### Qu'allons-nous apprendre ?

Nous allons ouvrir le « capot » de l'ordinateur et découvrir quatre composants que tout programmeur doit comprendre :

| Composant | En une ligne |
|---|---|
| **CPU** | Le cerveau — exécute les instructions. |
| **Registres** | De minuscules cellules de mémoire extrêmement rapides, **à l'intérieur** du CPU. |
| **RAM** | Le plan de travail — une mémoire rapide et temporaire pour les programmes en cours d'exécution. |
| **Stockage** | Les archives — un stockage permanent pour les fichiers, même quand l'ordinateur est éteint. |

### Pourquoi en avons-nous besoin ?

Chaque ligne de code que vous écrirez dans le cours passe par ces composants. Une fois que vous les comprendrez, vous comprendrez aussi des choses qui ressemblent pour l'instant à de la « magie » :

- Pourquoi une variable disparaît-elle à la fin du programme, alors qu'un fichier reste ?
- Pourquoi un programme qui lit sur le disque est-il plus lent qu'un programme qui ne travaille qu'en mémoire ?
- Pourquoi l'ordinateur « gèle »-t-il quand on ouvre trop de programmes ?
- Dans les thèmes backend et bases de données, pourquoi stockons-nous l'information dans une **base de données** (sur le stockage) et pas simplement dans une variable ?

Les entretiens d'embauche demandent souvent « quelle est la différence entre la RAM et le stockage » — c'est une question qui vérifie que vous comprenez les bases.

### Explication à partir des bases

#### CPU — Central Processing Unit

Le **CPU** (aussi appelé « processeur ») est le composant qui **exécute** les instructions. Il ne sait faire que des opérations très simples : additionner deux nombres, comparer, copier une valeur d'un endroit à un autre, sauter à une autre instruction. Sa force est la **vitesse** : des milliards d'instructions par seconde.

- **Fréquence d'horloge**, mesurée en GHz : 3 GHz ≈ trois milliards de « tics » par seconde.
- **Cœur** : un processeur moderne possède plusieurs cœurs, et chaque cœur est comme un petit processeur séparé. 8 cœurs = 8 choses en parallèle.

**Le lien avec l'exécution d'un programme :** chaque ligne de Python que vous écrivez est finalement traduite en de nombreuses petites instructions, et le CPU les exécute l'une après l'autre.

#### Les registres

Les **registres** sont de minuscules cellules de mémoire (chacune contient un nombre) **à l'intérieur même du CPU**. C'est la mémoire la plus rapide de l'ordinateur. Pour additionner deux nombres, le CPU les amène d'abord de la RAM dans des registres, calcule, et stocke le résultat dans un registre.

Un processeur a très peu de registres (quelques dizaines), ils ne contiennent donc que ce sur quoi le CPU travaille **à cet instant précis**. En Python, vous n'accédez jamais directement aux registres — l'interpréteur et le système d'exploitation s'en chargent — mais il est important de savoir qu'ils existent.

#### RAM — Random Access Memory

La **RAM** est la mémoire qui contient **les programmes en cours d'exécution et leurs données**. Quand vous écrivez `name = "Dana"`, la valeur `"Dana"` est stockée dans la RAM.

Deux propriétés importantes :

1. **Rapide** — bien plus rapide que le stockage (des milliers de fois).
2. **Temporaire (volatile)** — quand le programme se termine ou que l'ordinateur s'éteint, le contenu est effacé.

#### Le stockage — stockage permanent

Le **stockage** est le disque : un **SSD** (rapide, sans pièces mobiles) ou un **HDD** (un disque qui tourne, plus ancien et plus lent). C'est là que sont conservés le système d'exploitation, les programmes installés et tous vos fichiers, y compris `hello.py`.

1. **Permanent (non volatile)** — l'information reste même quand l'ordinateur est éteint.
2. **Grand et bon marché** — de centaines de Go jusqu'à des To, contre 8 à 32 Go de RAM.
3. **Lent** par rapport à la RAM.

{{< box "analogy" "L'analogie de la cuisine" >}}
- **Le stockage** = le garde-manger : il contient beaucoup, tout y est gardé longtemps, mais il faut s'y rendre pour chercher les choses.
- **La RAM** = le plan de travail : on n'y pose que ce que l'on cuisine en ce moment. Pratique et rapide, mais à la fin de la journée on le débarrasse.
- **Les registres** = les mains du cuisinier : elles ne tiennent que ce sur quoi il travaille à cet instant.
- **Le CPU** = le cuisinier : il exécute les actions (couper, remuer, calculer).
{{< /box >}}

#### Pourquoi ne pas se contenter d'un seul composant ?

| | Registres | RAM | Stockage |
|---|---|---|---|
| Vitesse | La plus rapide | Rapide | Relativement lente |
| Taille | Minuscule (octets) | Moyenne (Go) | Énorme (centaines de Go–To) |
| Conservé après extinction ? | Non | Non | **Oui** |
| Prix par Go | Très cher | Cher | Bon marché |

Aucun composant n'est à la fois très rapide, énorme, bon marché et permanent. L'ordinateur les combine donc tous : ce qui est nécessaire **maintenant** est gardé près du CPU, et ce qui est nécessaire **dans la durée** — sur le disque.

### Lire la fiche technique d'un ordinateur

Tout ce que nous avons appris apparaît dans la fiche technique de chaque ordinateur — en magasin, sur le site du fabricant ou dans le Gestionnaire des tâches. Une fiche typique d'ordinateur portable :

```text
CPU       8 cores, 3.2 GHz
RAM       16 GB       (temporary)
Storage   512 GB SSD  (permanent)
OS        Windows 11, 64-bit (x64)
```

| Ligne | Ce qu'elle indique |
|---|---|
| `8 cores` | Huit cœurs — jusqu'à huit choses que le CPU fait réellement en parallèle. |
| `3.2 GHz` | La fréquence d'horloge — environ 3,2 milliards de tics par seconde. |
| `16 GB` RAM | La place disponible pour les programmes en cours d'exécution **maintenant** et leurs données. |
| `512 GB SSD` | Combien de fichiers et de programmes peuvent être conservés **dans la durée**. |
| `64-bit (x64)` | L'architecture — le « langage d'instructions » que comprend le processeur. |

Vous pouvez voir les mêmes données sur l'ordinateur lui-même : sous Windows dans le **Gestionnaire des tâches** (`Ctrl + Shift + Esc`) → **Performances**, et sur Mac dans le **Moniteur d'activité**. Vous pouvez aussi y voir en temps réel combien de RAM est utilisée, et comment elle augmente à mesure que vous ouvrez des programmes.

### RAM et stockage en pratique

| | RAM | Stockage |
|---|---|---|
| Ce qui s'y trouve | Les programmes en cours d'exécution et leurs données | Les fichiers, les programmes installés, le système d'exploitation |
| Vitesse | Très rapide | Plus lente |
| Taille typique | 8–32 Go | Des centaines de Go jusqu'à des To |
| Quand le programme se termine ou que l'ordinateur s'éteint | **Effacée** | **Conservé** |

**Le lien avec la programmation :** chaque **variable** que vous écrivez dans un programme vit dans la **RAM**. À chaque exécution, le programme reçoit une mémoire neuve et vide, et quand il se termine — la mémoire est libérée et les valeurs disparaissent. C'est pourquoi un compteur dans un programme « repart de zéro » à chaque nouvelle exécution.

Ce qui doit **rester** — une liste d'étudiants, des commandes, des notes — doit être écrit sur le **stockage** : dans un fichier, ou dans une base de données. Nous apprendrons les deux méthodes plus tard dans le cours.

### Erreur courante

**L'erreur — « J'ai ajouté de la RAM, donc l'ordinateur stockera plus de fichiers »**, ou l'inverse : « J'ai un disque de 1 To, donc je ne manque pas de mémoire ».

Ce sont deux ressources différentes :

- **Trop peu de RAM** → l'ordinateur est lent quand beaucoup de programmes sont ouverts. Le système d'exploitation commence à déplacer des parties de la RAM vers le disque (ce qu'on appelle **swap** / fichier d'échange), et le disque est lent.
- **Trop peu de stockage** → pas de place pour enregistrer des fichiers et installer des programmes.

**Deuxième erreur — « J'ai enregistré », mais seulement dans la RAM.** Un programme affiche le message « Enregistré ! », mais en réalité l'information n'est que dans une variable, c'est-à-dire dans la RAM. Tant que le programme tourne — tout semble aller bien. Quand il se ferme ou que l'ordinateur s'éteint — les données disparaissent. Un vrai enregistrement signifie toujours **écrire sur le stockage**.

### Résumé

- Le **CPU** exécute les instructions. Les **cœurs** permettent l'exécution en parallèle, et les **GHz** mesurent la fréquence des tics.
- Les **registres** sont la mémoire la plus petite et la plus rapide, **à l'intérieur** du CPU, et contiennent ce qui est calculé en ce moment.
- La **RAM** est rapide et temporaire : les variables y vivent et disparaissent à la fin du programme.
- Le **stockage** (SSD/HDD) est plus lent mais permanent : les fichiers restent même après extinction.
- Pour qu'un enregistrement survive, il faut écrire sur le **stockage** (un fichier / une base de données).

<!-- docs:start — generated by scripts/intro6/site_docs.py; edit the links there -->

### Documentation officielle

- [Windows — Memory Management](https://learn.microsoft.com/en-us/windows/win32/memory/memory-management)
- [Windows — About Memory Management](https://learn.microsoft.com/en-us/windows/win32/memory/about-memory-management)

<!-- docs:end -->

## Chapitre 2 : Ce qui se passe entre le lancement d'un programme et son exécution

### Qu'allons-nous apprendre ?

Dans le chapitre précédent, nous avons découvert les composants séparément. Maintenant, nous allons les relier en une seule histoire : **ce qui se passe entre le lancement d'un programme et son exécution.** Nous verrons le parcours général de tout programme, puis le parcours particulier d'un fichier Python.

### Pourquoi en avons-nous besoin ?

- Quand un programme « ne démarre pas », vous saurez demander **à quelle étape** il a échoué : le fichier est introuvable ? Pas de permission ? Pas assez de mémoire ?
- Quand le thème Python parlera d'une **erreur d'exécution** par opposition à une **erreur de syntaxe**, la différence viendra exactement des étapes que nous apprenons ici.
- Dans les thèmes backend et bases de données, nous lancerons un **serveur** — un programme qui ne se termine pas mais continue de tourner en attendant des requêtes. Pour le comprendre, il faut d'abord comprendre ce qu'est un programme en cours d'exécution.

### Explication à partir des bases

#### Un programme enregistré face à un programme en cours d'exécution

Un **programme** qui ne tourne pas n'est qu'un **fichier sur le disque** — une suite d'octets sur le stockage. Pour qu'il « fasse » quelque chose, il doit être chargé dans la RAM et le CPU doit exécuter ses instructions. Un programme pendant son exécution s'appelle un **processus**. Cette distinction est très importante, et nous l'approfondirons dans la leçon suivante.

#### Le parcours général — 6 étapes

1. **Demande** — l'utilisateur double-clique sur une icône, ou tape une commande dans le terminal.
2. **Localisation** — le **système d'exploitation** cherche le fichier du programme sur le stockage.
3. **Vérification des permissions** — le système d'exploitation vérifie que cet utilisateur a le droit d'exécuter le fichier.
4. **Création d'un processus** — le système d'exploitation enregistre un nouveau processus, lui donne un numéro d'identification (**PID** — process ID) et lui attribue sa propre zone de mémoire dans la RAM.
5. **Chargement dans la RAM** — le système d'exploitation copie les instructions du programme du disque vers la zone de mémoire du processus, et le place dans la file d'attente du CPU.
6. **Exécution** — le CPU commence à exécuter les instructions, l'une après l'autre, dans un cycle appelé **Fetch → Decode → Execute**.

#### Le cycle Fetch → Decode → Execute

C'est le « battement de cœur » de tout ordinateur. Le CPU le répète des milliards de fois par seconde :

| Étape | Ce qui se passe | Quel composant |
|---|---|---|
| **Fetch** | Le CPU va chercher l'instruction suivante dans la RAM. Un registre spécial (le compteur de programme) retient où il en est. | RAM → registres |
| **Decode** | Le CPU détermine de quelle instruction il s'agit : additionner ? comparer ? copier ? | CPU |
| **Execute** | Le CPU l'exécute. Le résultat est stocké dans un registre et, si nécessaire, retourne dans la RAM. | CPU, registres, RAM |

{{< box "analogy" "Analogie" >}}
Un cuisinier avec une recette : **Fetch** — il lit la ligne suivante de la recette. **Decode** — il comprend qu'elle dit « couper un oignon ». **Execute** — il coupe. Puis il passe à la ligne suivante. La recette (le programme) est posée sur le plan de travail (la RAM), et le cuisinier (le CPU) ne tient dans ses mains (les registres) que ce sur quoi il travaille en ce moment.
{{< /box >}}

#### Et que se passe-t-il avec Python ?

Le CPU ne comprend pas Python. Il ne comprend que le **code machine** de sa propre architecture. Alors que se passe-t-il quand vous tapez `python hello.py` ?

1. Le système d'exploitation trouve le programme `python` (le fichier `python.exe` sous Windows), crée un **processus** et y charge le programme. Ce qui tourne sur le CPU, c'est **l'interpréteur**, qui est lui-même un programme en code machine.
2. L'interpréteur lit `hello.py` depuis le disque.
3. Il **vérifie la syntaxe** et **traduit** (compile) tout le fichier dans un langage intermédiaire simple appelé **bytecode**. S'il y a une erreur de syntaxe, le processus s'arrête ici, **avant qu'une seule ligne ne s'exécute**.
4. La **PVM** (Python Virtual Machine), la partie de l'interpréteur qui exécute le bytecode, parcourt les instructions l'une après l'autre et les exécute. Si une ligne échoue (par exemple une division par zéro), une erreur se produit **à l'exécution**, et les lignes déjà exécutées — l'ont été.
5. Quand le code se termine, le processus se termine et le système d'exploitation libère sa RAM.

```text
hello.py (Storage)
   │  python reads the file
   ▼
Syntax check + compile  ──►  Bytecode  (in RAM)
   │
   ▼
PVM executes bytecode instruction by instruction
   │  each instruction = many machine instructions
   ▼
CPU: Fetch → Decode → Execute (billions per second)
```

### Chaque exécution est un nouveau processus

Quand vous exécutez le même fichier trois fois, le système d'exploitation crée **trois processus différents** — chacun avec son propre **PID** (process ID) et une nouvelle zone de mémoire :

```text
python hello.py   ->  new Process, PID 14872
python hello.py   ->  new Process, PID 9316
python hello.py   ->  new Process, PID 20480
```

Le **programme** (le fichier `hello.py`) n'a pas changé. Chaque **processus** en est une exécution séparée, qui naît, tourne et disparaît. Vous pouvez le voir de vos propres yeux dans le Gestionnaire des tâches : un processus nommé `python` apparaît pendant que le programme tourne, et disparaît quand il se termine.

### Erreur courante

**L'erreur : croire que toutes les erreurs se produisent au même moment.** Il y a deux moments complètement différents :

```text
print("Line 1 runs?")
print("Line 3"
→ SyntaxError: '(' was never closed
  (nothing runs at all)

print("Line 1 runs")
print(10 / 0)
→ Line 1 runs
→ ZeroDivisionError: division by zero
```

- Une **SyntaxError** est détectée à l'étape de **vérification de la syntaxe**, avant la création du bytecode — donc **aucune ligne ne s'exécute**, pas même la première.
- Une **ZeroDivisionError** est une erreur **d'exécution** — la PVM a déjà exécuté les lignes qui la précèdent, et ne s'arrête qu'en atteignant la ligne problématique.

C'est ainsi qu'on identifie **à quelle étape du parcours** se trouve le problème : si rien n'a été affiché — c'est probablement la syntaxe. Si une partie a été affichée — le problème est à la ligne où le programme s'est arrêté.

### Résumé

- Un programme sur le disque n'est qu'un fichier. Quand il s'exécute, c'est un **processus** avec son propre **PID** et une zone dans la RAM.
- Le système d'exploitation trouve le fichier, vérifie les permissions, crée un processus et charge le programme dans sa mémoire en RAM.
- Le CPU exécute les instructions dans le cycle **Fetch → Decode → Execute**, avec l'aide des registres.
- En Python : le code est vérifié et traduit en **bytecode**, puis la **PVM** l'exécute.
- Une **erreur de syntaxe** arrête tout avant la première ligne. Une **erreur d'exécution** arrête au milieu, après que des lignes précédentes ont déjà été exécutées.

<!-- docs:start — generated by scripts/intro6/site_docs.py; edit the links there -->

### Documentation officielle

- [Windows — About Processes and Threads](https://learn.microsoft.com/en-us/windows/win32/procthread/about-processes-and-threads)
- [Python Glossary — bytecode](https://docs.python.org/3/glossary.html#term-bytecode)

<!-- docs:end -->

## Chapitre 3 : Les types de langages de programmation : du code machine à Python

### Qu'allons-nous apprendre ?

Dans le chapitre précédent, nous avons vu que le CPU exécute les instructions dans le cycle Fetch → Decode → Execute. Maintenant, nous nous demandons : **d'où viennent ces instructions ?** Nous apprendrons :

- Ce qu'est le **code machine**, et pourquoi personne n'écrit avec.
- La différence entre les langages de **bas niveau** et de **haut niveau**.
- Les deux façons de traduire du code en instructions : un **compilateur** et un **interpréteur**.
- Où se situe **Python**, et pourquoi nous l'avons choisi pour le cours.

### Pourquoi en avons-nous besoin ?

Quand on commence à programmer, on entend sans cesse des phrases comme « C est rapide », « Python est lent », « JavaScript tourne dans le navigateur » ou « il faut le compiler ». Sans comprendre **comment** le code devient des instructions que le CPU exécute, ces phrases ressemblent à de la magie.

Cette compréhension aide aussi en pratique :

- Comprendre **pourquoi** Python trouve une erreur de syntaxe avant même que le code ne s'exécute, mais d'autres erreurs seulement au milieu de l'exécution.
- Choisir le bon outil pour la tâche — et comprendre pourquoi les entreprises utilisent plusieurs langages côte à côte.
- Répondre à une question classique d'entretien d'embauche : « Quelle est la différence entre compilé et interprété ? »

### Explication à partir des bases

#### Ce que le CPU comprend vraiment

Le processeur ne comprend que des **instructions binaires** — des suites de zéros et de uns. Chaque instruction est une très petite action : « copier un nombre dans cette cellule », « additionner deux nombres », « sauter à une autre adresse ». C'est ce qu'on appelle le **code machine**.

Écrire tout un programme en zéros et en uns est presque impossible pour des humains : c'est difficile à lire, difficile d'y trouver les erreurs, et chaque type de processeur a un code machine différent.

Un **langage de programmation** est un pont : nous écrivons dans un langage qui nous convient, et un programme spécial le traduit en instructions que le CPU comprend.

#### Bas niveau face à haut niveau

La même action — stocker la lettre `a` — à plusieurs niveaux :

```text
Machine Code   10110000 01100001
Assembly       MOV AL, 61h
C              char c = 'a';
Python         c = "a"
```

- **Bas niveau** — proche de la machine. On contrôle chaque détail : la mémoire, les registres, chaque instruction. Très rapide, mais difficile à écrire et facile de se tromper. Exemples : l'assembleur, et dans une large mesure le C aussi.
- **Haut niveau** — proche du langage humain. Le langage s'occupe des détails pour nous : la gestion de la mémoire, les types de données, des listes et des dictionnaires prêts à l'emploi. Facile à écrire et à lire, et généralement plus lent à l'exécution. Exemples : Python, JavaScript, Java.

#### Compilé — tout traduire à l'avance

Dans un **langage compilé**, un programme appelé **compilateur** lit tout le code **avant** de l'exécuter, le vérifie et le traduit en un fichier exécutable en code machine. Ensuite, on exécute ce fichier — autant de fois qu'on veut, sans traduire à nouveau.

```text
Compiled (C, Go, Rust):
  source code -> compiler -> program.exe -> run
  translate once, run many times
```

- **Avantage :** exécution très rapide — la traduction est déjà faite.
- **Inconvénient :** après chaque modification, il faut recompiler, et l'exécutable est adapté à un système d'exploitation et un processeur précis.

#### Interprété — traduire pendant l'exécution

Dans un **langage interprété**, un programme appelé **interpréteur** lit le code **pendant son exécution**, et l'exécute au fur et à mesure qu'il le traduit.

```text
Interpreted (Python, JavaScript):
  source code -> interpreter -> run, line by line
  translate every time you run
```

- **Avantage :** très pratique pour le développement — on modifie une ligne et on exécute immédiatement. Le même code tourne sur n'importe quel ordinateur où l'interpréteur est installé.
- **Inconvénient :** plus lent à l'exécution, car la traduction se refait à chaque fois.

{{< box "analogy" "Analogie : un livre traduit face à un interprète" >}}
Un **compilateur** est comme un traducteur qui traduit tout un livre avant qu'il n'arrive en librairie. Cela prend du temps, mais ensuite chaque lecteur lit simplement — vite.

Un **interpréteur** est comme un interprète simultané lors d'une conférence : il traduit phrase après phrase, en temps réel. Pas d'attente préalable, mais chaque conférence a de nouveau besoin d'un interprète.
{{< /box >}}

#### Des langages connus et leurs usages

| Langage | Niveau | Principalement utilisé pour... |
|---|---|---|
| **Python** | Haut niveau, interprété | Données, intelligence artificielle, serveurs, automatisation |
| **JavaScript** | Haut niveau, interprété | Sites web — dans le navigateur et sur le serveur |
| **Java / C#** | Haut niveau, compilé vers une étape intermédiaire | Grands systèmes d'entreprise, applications |
| **C / C++** | Relativement bas niveau, compilé | Systèmes d'exploitation, jeux, matériel |

#### Et où se situe Python ?

Python est un langage de **haut niveau**, **interprété**. Mais en coulisses, il y a une étape intermédiaire, comme nous l'avons vu au chapitre précédent :

1. Python lit tout le fichier et vérifie la syntaxe — c'est pourquoi une **SyntaxError** arrête tout avant la première ligne.
2. Il traduit le code en **bytecode** — des instructions intermédiaires simples.
3. La **PVM** (Python Virtual Machine) exécute le bytecode instruction par instruction — et des erreurs comme **ZeroDivisionError** ne sont découvertes qu'en atteignant la ligne concernée.

Une autre propriété importante : Python est un langage **dynamique** — on ne déclare pas à l'avance le type d'une variable. La même variable peut contenir un nombre puis du texte.

### Erreur courante

**« Quel est le meilleur langage ? »** — une question sans réponse.

- **Il n'y a pas de meilleur langage — il y a un langage adapté à la tâche.** Un jeu en 3D a besoin de la vitesse du C++ ; l'analyse de données a besoin des bibliothèques de Python ; un site web a besoin de JavaScript.
- Un langage rapide à l'exécution est généralement plus lent à écrire, et inversement.
- **Les idées se transfèrent d'un langage à l'autre :** variables, conditions, boucles, fonctions et objets existent dans presque tous les langages. Celui qui a bien appris un langage apprend le suivant beaucoup plus vite.

Une autre erreur : croire qu'« interprété » signifie « ne vérifie rien à l'avance ». Python vérifie bien la syntaxe de tout le fichier avant de l'exécuter — il ne produit simplement pas de fichier exécutable séparé.

### Résumé

- Le CPU ne comprend que le **code machine** — des zéros et des uns. Un langage de programmation est le pont entre nous et lui.
- **Bas niveau** — proche de la machine, rapide et difficile. **Haut niveau** — proche des humains, lisible et pratique.
- Un **compilateur** traduit tout à l'avance en un exécutable — exécution rapide. Un **interpréteur** traduit pendant l'exécution — développement pratique.
- **Python** est de haut niveau, interprété et dynamique, avec une étape de **bytecode** que la **PVM** exécute.
- Il n'y a pas de meilleur langage — il y a un langage adapté à la tâche, et les idées se transfèrent entre les langages.

<!-- docs:start — generated by scripts/intro6/site_docs.py; edit the links there -->

### Documentation officielle

- [Python FAQ — What is Python?](https://docs.python.org/3/faq/general.html#what-is-python)
- [Python Glossary — interpreted](https://docs.python.org/3/glossary.html#term-interpreted)

<!-- docs:end -->

<!-- exercises:start — generated by scripts/intro6/sync_site_exercises.py; edit scripts/intro6/exercises/ -->
## Exercices

Questions de compréhension sur le contenu de la leçon — sans code.

### Exercice 1: Quel composant ?

Pour chaque description — quel composant correspond : CPU, registres, RAM ou stockage ?

1. S'efface quand l'ordinateur s'éteint, et contient les variables d'un programme en cours d'exécution.
2. Exécute des milliards d'instructions par seconde.
3. Conserve les fichiers même sans alimentation.
4. De minuscules cellules de mémoire extrêmement rapides, à l'intérieur du processeur.

{{< solution >}}
1. **RAM** — une mémoire rapide et temporaire (volatile).
2. **CPU** — le processeur, qui exécute les instructions.
3. **Stockage** (SSD/HDD) — un stockage permanent (non volatile).
4. **Registres** — contiennent ce sur quoi le CPU travaille à cet instant.
{{< /solution >}}

### Exercice 2: Lire une fiche technique

Voici la fiche technique d'un ordinateur portable :

```text
CPU       8 cores, 3.2 GHz
RAM       16 GB
Storage   512 GB SSD
```

1. Que signifie `8 cores` ?
2. Danny dit : « J'ai 512 Go, donc je peux ouvrir autant de programmes que je veux sans que l'ordinateur ralentisse ». Quelle est l'erreur ?

{{< solution >}}
1. **Huit cœurs** — jusqu'à huit choses que le CPU fait réellement en parallèle.
2. Les 512 Go sont du **stockage** — de la place pour enregistrer des fichiers. Les programmes en cours d'exécution sont dans la **RAM**, qui n'a que 16 Go. Quand la RAM est pleine, le système d'exploitation en déplace des parties vers le disque (swap), et l'ordinateur ralentit.
{{< /solution >}}

### Exercice 3: D'un fichier à un processus

Dana double-clique sur l'icône d'un programme installé sur l'ordinateur. Remettez les quatre étapes dans l'ordre où elles se produisent — du moment où le programme est enregistré sur le disque jusqu'à son exécution. Écrivez l'ordre des lettres.

- (a) Le système d'exploitation crée un nouveau processus, avec un PID et sa propre zone de mémoire
- (b) Le système d'exploitation trouve le fichier du programme sur le disque (stockage)
- (c) Le CPU exécute les instructions du programme, l'une après l'autre (fetch, decode, execute)
- (d) Le système d'exploitation charge les instructions du programme du disque vers la zone de mémoire du processus en RAM

{{< solution >}}
L'ordre : **(b), (a), (d), (c)**

1. **(b)** Le système d'exploitation trouve le fichier du programme sur le stockage.
2. **(a)** Il crée un nouveau processus — lui donne un PID et lui attribue sa propre zone de mémoire en RAM.
3. **(d)** Il copie les instructions du programme du disque vers la zone de mémoire du processus.
4. **(c)** Le CPU exécute les instructions l'une après l'autre — il va les chercher, les décode et les exécute.

Pourquoi (a) avant (d) ? Il faut d'abord une « maison » en mémoire — le processus avec sa zone de mémoire — et seulement ensuite on peut y copier les instructions.
{{< /solution >}}

### Exercice 4: Une erreur — à quelle étape ?

Dans chacun des cas suivants : s'agit-il d'une erreur de syntaxe (SyntaxError) ou d'une erreur d'exécution ? Et la première ligne a-t-elle été affichée ?

```text
# Program A
print("Start")
print("End"

# Program B
print("Start")
print(10 / 0)
```

{{< solution >}}
- **Programme A — SyntaxError** (une parenthèse n'a pas été fermée). Python vérifie la syntaxe de tout le fichier **avant** d'exécuter la moindre ligne, donc **rien n'a été affiché**, pas même `Start`.
- **Programme B — une erreur d'exécution** (`ZeroDivisionError`). La syntaxe est correcte, donc le programme a commencé à s'exécuter : `Start` **a été affiché**, et l'erreur ne s'est produite qu'en atteignant la deuxième ligne.
{{< /solution >}}

### Exercice 5: Compilé face à interprété

1. Quelle est la différence entre un compilateur et un interpréteur ?
2. Donnez un avantage de chaque approche.
3. Où se situe Python, et quel est le rôle du bytecode et de la PVM ?

{{< solution >}}
1. Un **compilateur** traduit tout le code **à l'avance** en un fichier exécutable en code machine. Un **interpréteur** traduit et exécute le code **pendant son exécution**.
2. Avantages :
   - **Compilé** — exécution rapide, car la traduction est déjà faite.
   - **Interprété** — pratique pour le développement : on modifie une ligne et on exécute immédiatement, et le même code tourne sur n'importe quel ordinateur qui a l'interpréteur.
3. **Python est un langage de haut niveau, interprété.** En coulisses, il vérifie la syntaxe et traduit le code en **bytecode** (des instructions intermédiaires), puis la **PVM** (Python Virtual Machine) exécute le bytecode instruction par instruction.
{{< /solution >}}

<!-- exercises:end -->