# Le système d'exploitation : le noyau, les processus, les fichiers et les permissions<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** — ce qu'est un système d'exploitation et ce qu'est le noyau
2. **Chapitre 2** — un programme face à un processus, et la gestion de la mémoire
3. **Chapitre 3** — le système de fichiers, les utilisateurs et les permissions

## Chapitre 1 : Ce qu'est un système d'exploitation et ce qu'est le noyau

### Qu'allons-nous apprendre ?

Dans la leçon précédente, nous avons vu que le système d'exploitation « trouve le fichier, crée un processus et y charge le programme ». Maintenant, nous allons vraiment faire sa connaissance :

- Ce qu'est un **système d'exploitation** (**OS**, de l'anglais Operating System).
- Ce qu'il gère, et pourquoi.
- Ce qu'est le **noyau** (kernel) — le cœur du système d'exploitation.
- Comment notre code lui « demande » des choses, par un **appel système** (system call).

### Pourquoi en avons-nous besoin ?

Chaque `print`, chaque fichier que vous ouvrez, chaque connexion Internet et, dans les thèmes backend et bases de données, chaque serveur — **tout passe par le système d'exploitation**. Quand vous obtenez une erreur comme `PermissionError` ou `Address already in use`, elle vient du système d'exploitation. Pour comprendre l'erreur, il faut comprendre qui l'a envoyée et pourquoi.

De plus, la plupart des serveurs du monde tournent sous **Linux**. Même si vous travaillez sous Windows, vous rencontrerez Linux au travail, il est donc important de comprendre les idées communes à tous les systèmes d'exploitation.

### Explication à partir des bases

#### Qu'est-ce qu'un système d'exploitation ?

Un **système d'exploitation** est le premier programme qui démarre quand on allume un ordinateur, et le dernier à s'arrêter. Son rôle : **gérer les ressources de l'ordinateur et permettre aux autres programmes de les utiliser de façon sûre et équitable.**

Exemples : **Windows**, **macOS**, **Linux** (Ubuntu, Debian...), **Android**, **iOS**.

{{< box "analogy" "Analogie : un gestionnaire d'immeuble" >}}
Imaginez un immeuble de bureaux avec de nombreuses entreprises (programmes). Il y a l'électricité, des ascenseurs, des salles de réunion et une réserve (les ressources : CPU, RAM, disque, réseau). Si chaque entreprise allait directement au tableau électrique et prenait autant qu'elle voulait — ce serait le chaos. Le **gestionnaire de l'immeuble** (le système d'exploitation) répartit les ressources, veille à ce qu'aucune entreprise n'entre dans le bureau d'une autre, et détient les clés de chaque porte.
{{< /box >}}

#### Les cinq rôles principaux

| Rôle | Ce que cela signifie | Exemple tiré de notre code |
|---|---|---|
| **Gestion des processus** | Crée les processus, répartit le temps CPU entre eux, les termine. | Chaque `python file.py` crée un nouveau processus. |
| **Gestion de la mémoire** | Donne à chaque processus sa propre zone de RAM et empêche un processus de toucher la mémoire d'un autre. | Nos variables vivent dans la zone que le système d'exploitation a attribuée. |
| **Gestion des fichiers** (système de fichiers) | Organise le disque en dossiers et en fichiers, et lit et écrit pour nous. | Ouvrir un fichier, enregistrer, supprimer. |
| **Utilisateurs et permissions** | Qui est connecté, et ce qu'il a le droit de faire. | `PermissionError` en essayant d'écrire dans un dossier système. |
| **Gestion des périphériques** | Communique avec le clavier, l'écran, la carte réseau et le disque via des **pilotes** (drivers). | `print` arrive à l'écran, et une requête HTTP sort par la carte réseau. |

#### Qu'est-ce que le noyau ?

Le **noyau** (kernel) est **la partie centrale et la plus protégée** du système d'exploitation. Il est chargé en RAM en premier et y reste tout le temps. C'est lui qui exécute réellement les cinq rôles ci-dessus.

Tout le reste, comme le bureau, l'explorateur de fichiers, le terminal et le navigateur, sont des **programmes ordinaires** qui tournent « au-dessus » du noyau.

#### Mode noyau face à mode utilisateur

Le processeur peut fonctionner selon deux modes :

- **Mode noyau** (Kernel Mode) — accès complet à tout le matériel et à toute la mémoire. Seul le noyau tourne ainsi.
- **Mode utilisateur** (User Mode) — accès limité. Tous nos programmes, y compris Python, tournent ainsi.

**Pourquoi ?** Si chaque programme pouvait accéder directement au matériel, un seul bug dans un seul programme pourrait faire tomber tout l'ordinateur, et un virus pourrait lire la mémoire de votre banque. La séparation protège le système.

#### L'appel système — demander au noyau

Alors comment un programme en mode utilisateur écrit-il dans un fichier ou envoie-t-il des données sur le réseau ? Il **demande** au noyau. Cette demande s'appelle un **appel système** (system call).

```text
Your Python code:       print("Hi")
        │
Python interpreter:     "I need to write 'Hi' to the screen"
        │   System Call (write)
        ▼
Kernel (Kernel Mode):   checks permissions → talks to the screen driver
        │
        ▼
Hardware:               the text appears
```

{{< box "term" "Glossaire" >}}
- **Système d'exploitation** (Operating System, OS) — le logiciel qui gère les ressources de l'ordinateur.
- **Noyau** (Kernel) — le cœur protégé de l'OS. Toujours en marche, il fait la gestion réelle.
- **Pilote** (Driver) — un petit programme qui apprend au noyau à communiquer avec un composant matériel précis.
- **Appel système** (System Call) — la demande d'un programme au noyau d'effectuer une action protégée.
- **Mode utilisateur / mode noyau** (User Mode / Kernel Mode) — le mode limité des programmes ordinaires / le mode complet du noyau.
{{< /box >}}

### Les systèmes d'exploitation courants

| Système d'exploitation | Où on le rencontre | Le shell du terminal |
|---|---|---|
| **Windows** | La plupart des ordinateurs personnels | PowerShell |
| **macOS** | Les ordinateurs Apple | zsh |
| **Linux** | La plupart des serveurs cloud, et les ordinateurs de développeurs | Bash |
| **Android / iOS** | Téléphones et tablettes | — |

Ils remplissent tous les cinq mêmes rôles — processus, mémoire, fichiers, utilisateurs et permissions, matériel — et ils ont tous un noyau. Les différences portent surtout sur l'interface, les commandes du terminal et la structure des dossiers (par exemple `C:\` sous Windows contre `/` sur Mac et Linux).

**Pourquoi est-ce important pour les développeurs ?** Le code que vous écrivez sous Windows finira souvent par tourner sur un serveur Linux dans le cloud. Il vaut donc la peine de connaître les différences — et d'écrire du code qui ne dépend pas d'un seul système d'exploitation.

### Erreur courante

**L'erreur : essayer de toucher aux fichiers système « juste pour voir ».**

Le programme d'un utilisateur ordinaire essaie, par exemple, de supprimer un fichier qui appartient au système d'exploitation (dans le dossier `C:\Windows\System32`). Ce qui se passe :

1. Le programme tourne en **mode utilisateur**, il n'accède donc pas lui-même au disque — il envoie un **appel système** au noyau.
2. Le noyau vérifie les permissions et voit que l'utilisateur ordinaire n'a pas la permission d'écrire sur ce fichier.
3. La demande est refusée, et le programme reçoit une **erreur de permission** (« Access is denied » / `PermissionError`).

Et c'est **une bonne chose** : les permissions protègent l'ordinateur des erreurs des utilisateurs et des logiciels malveillants. Une erreur de permission ne vient pas de votre programme — elle vient du système d'exploitation, qui a refusé.

### Résumé

- Un **système d'exploitation** gère les ressources de l'ordinateur : processus, mémoire, fichiers, utilisateurs et permissions, et matériel.
- Le **noyau** est son cœur protégé et tourne en **mode noyau**. Nos programmes tournent en **mode utilisateur**.
- Un programme demande un service au noyau par un **appel système** : écrire à l'écran, ouvrir un fichier, communiquer.
- Les erreurs de permission viennent du système d'exploitation — c'est lui qui vérifie et refuse.
- **Windows**, **macOS** et **Linux** sur les ordinateurs et les serveurs, **Android** et **iOS** sur les téléphones — tous avec les mêmes rôles de base.

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

### Documentation officielle

- [User mode and kernel mode](https://learn.microsoft.com/en-us/windows-hardware/drivers/gettingstarted/user-mode-and-kernel-mode)

<!-- docs:end -->

## Chapitre 2 : Un programme face à un processus, et la gestion de la mémoire

### Qu'allons-nous apprendre ?

- La différence entre un **programme** et un **processus**.
- Comment le système d'exploitation fait tourner des dizaines de processus « en même temps » — l'**ordonnancement** (scheduling).
- Comment il gère la RAM — la **gestion de la mémoire**.
- Comment voir et arrêter des processus depuis le terminal.

### Pourquoi en avons-nous besoin ?

- Dans les thèmes backend et bases de données, nous lancerons un **serveur**. Un serveur est un processus qui ne se termine pas. Si vous le lancez deux fois, le second échouera, parce que le premier tourne encore et occupe son adresse. Sans comprendre les processus, cela ressemble à de la magie.
- Quand un programme « gèle », il faut savoir trouver le processus et l'arrêter.
- Une **fuite de mémoire** (memory leak), c'est-à-dire un programme dont la mémoire ne fait que grandir, est un bug que l'on traque avec des outils de surveillance des processus.

### Explication à partir des bases

#### Programme — la recette. Processus — la cuisson.

- **Programme** = un fichier sur le stockage qui contient des instructions. Il est statique : il ne fait rien, il est simplement posé sur le disque. Exemples : `python.exe`, `chrome.exe`, `hello.py`.
- **Processus** = une **instance en cours d'exécution** d'un programme. Il est dynamique : il a de la mémoire en RAM, un PID et un état (en cours / en attente / en train de se terminer).

**Un point important :** un même programme peut faire tourner **plusieurs processus en parallèle**. Vous avez ouvert 3 fenêtres de VS Code ? Il y a un programme et 3 processus (en pratique plus, car les navigateurs et éditeurs modernes se découpent en plusieurs processus).

{{< box "analogy" "Analogie" >}}
**Programme** = une recette de gâteau écrite dans un livre. **Processus** = un gâteau qui cuit au four en ce moment. Avec la même recette, on peut faire cuire trois gâteaux en parallèle dans trois fours. Chacun a son propre état : l'un a déjà levé, l'autre commence à peine.
{{< /box >}}

#### Qu'a chaque processus ?

| Partie | Explication |
|---|---|
| **PID** | Un numéro d'identification unique. |
| **Espace mémoire** | Une zone privée de RAM : le code, les variables et les données. |
| **État** | Running (sur un CPU), Ready (attend son tour), Waiting (attend quelque chose d'externe, comme un fichier ou le réseau). |
| **Propriétaire** | Quel utilisateur l'a lancé, ce qui détermine ses permissions. |
| **Parent** | Quel processus l'a créé. Par exemple : le terminal est le parent de `python`. |

#### L'ordonnancement — comment tout le monde tourne-t-il « en même temps » ?

Vous avez peut-être 8 cœurs, mais 200 processus tournent sur l'ordinateur. Comment ?

L'**ordonnanceur** (scheduler), une partie du noyau, donne à chaque processus une très courte **tranche de temps** sur le CPU (des millisecondes), puis passe au processus suivant. Cela se fait si vite qu'on a l'impression que tous tournent en même temps.

```text
Time →   | P1 | P2 | P3 | P1 | P2 | P3 | P1 | ...
          each slice ≈ a few milliseconds
```

Un processus qui **attend** (par exemple sur `time.sleep` ou une réponse du réseau) ne reçoit aucun temps CPU tant que l'attente n'est pas terminée. C'est pourquoi un serveur qui attend des requêtes n'utilise presque pas de CPU.

#### La gestion de la mémoire

Le système d'exploitation fait trois choses principales avec la mémoire :

1. **Allocation** — quand un processus est créé, et chaque fois qu'il a besoin de plus de mémoire (par exemple une liste qui grandit), l'OS lui donne plus de RAM.
2. **Isolation** — chaque processus ne voit que sa propre mémoire. Un processus **ne peut pas** lire ni modifier les variables d'un autre processus. Cela empêche un bug dans une application de corrompre une autre application.
3. **Libération** — quand un processus se termine, toute sa RAM est rendue au système.

Et si la RAM vient à manquer ? Le système d'exploitation déplace des parties inutilisées vers le disque (**swap** sous Linux/Mac, **fichier d'échange** — page file — sous Windows). Cela évite un plantage, mais l'ordinateur devient très lent, car le disque est lent.

{{< box "tip" "Et Python dans tout ça ?" >}}
Python a aussi son propre mécanisme interne : le **ramasse-miettes** (garbage collector). Quand un objet n'est plus utilisé (aucune variable ne pointe vers lui), Python libère sa mémoire tout seul. C'est pourquoi en Python vous n'avez pas besoin de « libérer la mémoire » à la main, comme dans des langages tels que le C.
{{< /box >}}

### L'arbre des processus — qui a lancé qui

Chaque processus est créé par un autre processus — son **parent**. Quand vous lancez un programme depuis le terminal, le terminal est le parent :

```text
explorer.exe          PID 4120
└── pwsh.exe          PID 9920   (Terminal)
    └── python.exe    PID 18044  (our program)
```

Chaque processus a son propre **PID**, et chacun a aussi un **PPID** — le PID de son parent. Quand vous fermez le terminal, les processus qu'il a lancés se ferment généralement aussi.

### Commandes pour voir et arrêter des processus

On peut voir les processus dans le Gestionnaire des tâches, mais aussi depuis le terminal. Le formateur montrera les commandes à l'écran :

**Windows (PowerShell) :**

```powershell
Get-Process                    # list all processes
Get-Process python             # only processes named python
Stop-Process -Id 12345         # stop the process with PID 12345
```

**Mac / Linux (Bash / Zsh) :**

```bash
ps aux                  # list all processes
ps aux | grep python    # filter lines that contain "python"
kill 12345              # stop the process with PID 12345
```

### Erreur courante

**L'erreur : croire que `Ctrl + C` a provoqué une « erreur ».** Quand vous arrêtez un programme Python en cours avec `Ctrl + C`, quelque chose comme ceci apparaît :

```text
^C
Traceback (most recent call last):
  ...
KeyboardInterrupt
```

- `Ctrl + C` envoie au processus une **demande d'arrêt** — ce n'est pas un bug.
- `KeyboardInterrupt` dit : « tu m'as arrêté en plein milieu ».
- Toute valeur qui n'était que dans la RAM du processus — **est perdue**, car sa mémoire a été libérée.

### Résumé

- Un **programme** est un fichier statique sur le disque. Un **processus** en est une instance en cours d'exécution, avec un PID, de la mémoire et un état.
- Un programme peut faire tourner plusieurs processus, chacun avec sa propre mémoire **isolée**.
- L'**ordonnanceur** répartit le temps CPU en petites tranches, si bien que tout semble parallèle.
- **Gestion de la mémoire :** allocation, isolation et libération. Quand la RAM manque, on utilise le swap / le fichier d'échange, et c'est lent.
- Chaque processus a un **parent**. On arrête un programme avec `Ctrl + C`, et un processus bloqué avec `Stop-Process` / `kill` par son PID.

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

### Documentation officielle

- [About Processes and Threads](https://learn.microsoft.com/en-us/windows/win32/procthread/about-processes-and-threads)
- [Virtual Address Space](https://learn.microsoft.com/en-us/windows/win32/memory/virtual-address-space)

<!-- docs:end -->

## Chapitre 3 : Le système de fichiers, les utilisateurs et les permissions

### Qu'allons-nous apprendre ?

- Le **système de fichiers** — comment le système d'exploitation organise le disque.
- Les **chemins** — absolu face à relatif, et ce que sont `.` et `..`.
- Les **utilisateurs** — qui est connecté, et qui est l'utilisateur « tout-puissant ».
- Les **permissions** — qui a le droit de faire quoi avec chaque fichier.

### Pourquoi en avons-nous besoin ?

- Dans le thème Python, nous lirons et écrirons des **fichiers** depuis Python. L'erreur la plus fréquente y est `FileNotFoundError`, et la cause est presque toujours un mauvais chemin.
- Dans le thème des bases de données, nous lancerons un serveur de base de données et nous nous y connecterons — et beaucoup d'outils y sont configurés avec des chemins vers des fichiers et des dossiers.
- En installant des outils, on obtient parfois « Access denied » ou « Permission denied ». Il vaut la peine de comprendre pourquoi cela arrive, plutôt que de résoudre chaque problème par « exécuter en tant qu'administrateur ».

### Explication à partir des bases

#### Le système de fichiers

Le disque lui-même est une énorme suite d'octets. Le **système de fichiers** (file system) est la couche du système d'exploitation qui transforme cette suite en **fichiers et dossiers** avec des noms, et qui conserve des informations supplémentaires (**métadonnées**) pour chaque fichier : taille, date de modification, propriétaire et permissions.

La structure est un **arbre** : il y a une **racine** (root), des dossiers en partent, et chaque dossier contient d'autres dossiers et fichiers.

```text
Windows                         Mac / Linux
C:\                             /
├── Users\                      ├── home/            (Mac: /Users/)
│   └── dana\                   │   └── dana/
│       ├── Desktop\            │       ├── Desktop/
│       └── dev\                │       └── dev/
│           └── kodkod6\        │           └── kodkod6/
├── Program Files\              ├── usr/
└── Windows\                    └── etc/
```

Différences importantes :

| | Windows | Mac / Linux |
|---|---|---|
| Racine | Une lettre de lecteur : `C:\` (il peut y en avoir d'autres : `D:\`) | Une seule racine : `/` |
| Séparateur | `\` (barre oblique inverse) | `/` (barre oblique) |
| Dossier personnel | `C:\Users\dana` | `/home/dana` (Mac : `/Users/dana`) |
| Majuscules/minuscules | `File.txt` = `file.txt` | `File.txt` ≠ `file.txt` (sous Linux) |

Le **dossier personnel** (home directory) est le dossier privé de l'utilisateur. Dans ce dossier et ses sous-dossiers, vous avez toutes les permissions. C'est pourquoi `kodkod6` se place à l'intérieur.

#### Chemin absolu face à chemin relatif

- **Chemin absolu** — part de la racine. Fonctionne depuis n'importe où.
  `C:\Users\dana\dev\kodkod6\week-1\hello.py`
- **Chemin relatif** — part **du répertoire courant**. Court, mais dépend de l'endroit où l'on se trouve.
  `week-1\hello.py` (si vous êtes dans `kodkod6`)

Deux raccourcis spéciaux :

- `.` (point) = **le répertoire courant**.
- `..` (deux points) = **le dossier parent**, un dossier plus haut.

```text
Standing in: C:\Users\dana\dev\kodkod6\week-1

.              → C:\Users\dana\dev\kodkod6\week-1
..             → C:\Users\dana\dev\kodkod6
..\week-2      → C:\Users\dana\dev\kodkod6\week-2
..\..          → C:\Users\dana\dev
```

{{< box "analogy" "Analogie" >}}
Un **chemin absolu** est une adresse complète : « Israël, Haïfa, 10 rue Herzl, appartement 3 ». Envoyé de n'importe où dans le monde — il arrive. Un **chemin relatif** est une indication : « deux portes à droite d'ici ». Il ne fonctionne que si l'on sait d'où l'on part.
{{< /box >}}

#### Les utilisateurs

Un système d'exploitation prend en charge plusieurs **utilisateurs**. Chacun a un nom, un mot de passe, un dossier personnel et des permissions. Il existe aussi des utilisateurs « spéciaux » :

- **Administrator** (Windows) / **root** (Linux/Mac) — un super-utilisateur avec toutes les permissions sur l'ensemble du système.
- **Utilisateurs système** — des utilisateurs qui ne sont pas des personnes. Des services comme un serveur ou une base de données tournent sous ces utilisateurs, ainsi même s'ils sont piratés, les dégâts restent limités.

En travail normal, vous travaillez en tant qu'utilisateur **ordinaire**, et vous n'élevez les permissions que pour une action précise : **Exécuter en tant qu'administrateur** sous Windows, `sudo` sous Linux/Mac.

#### Les permissions

Chaque fichier et chaque dossier a des permissions qui déterminent **qui** a le droit de faire **quoi**. Les trois actions de base :

| Permission | Sur un fichier | Sur un dossier |
|---|---|---|
| **Lecture** (r) | Lire le contenu | Voir quels fichiers il contient |
| **Écriture** (w) | Modifier / supprimer | Créer et supprimer des fichiers à l'intérieur |
| **Exécution** (x) | L'exécuter comme un programme | Y entrer (`cd`) |

Sous Linux/Mac, les permissions s'affichent sous la forme d'une chaîne comme `-rwxr-xr--`, découpée en trois groupes : **propriétaire** (owner), **groupe** (group) et **autres** (others) :

```text
-  rwx  r-x  r--
│   │    │    └── others: read only
│   │    └─────── group:  read + execute
│   └──────────── owner:  read + write + execute
└──────────────── type: "-" = file, "d" = directory
```

Sous Windows, les permissions s'appellent une **ACL** et apparaissent dans clic droit → Propriétés → **Sécurité**. Le principe est le même.

**Pourquoi a-t-on besoin de permissions ?** Pour qu'un utilisateur ne puisse pas lire les fichiers privés d'un autre, pour qu'un programme défectueux ou un virus ne puisse pas modifier les fichiers système, et pour qu'un serveur piraté ne puisse pas toucher à tout l'ordinateur.

### Erreur courante

**Erreur 1 : « le fichier est introuvable » — alors qu'il existe.**

```text
Standing in:  C:\dev\kodkod6
Looking for:  data.txt
Searched:     C:\dev\kodkod6\data.txt
Real file:    C:\dev\kodkod6\week-1\data.txt
```

- Un chemin **relatif** est vérifié **depuis le répertoire courant** — depuis l'endroit où se trouve le terminal — et non depuis le dossier où se trouve le fichier.
- Lancé depuis un autre dossier ? Le programme cherche ailleurs, et ne trouve pas.
- **La correction :** d'abord aller dans le bon dossier (`cd`), ou utiliser un chemin **absolu**.

**Erreur 2 : travailler en tant qu'administrateur / root « pour ne pas avoir de problèmes ».** Cela contourne la protection qu'offrent les permissions : chaque erreur, ou programme malveillant, obtient l'accès à tout l'ordinateur. Travaillez en utilisateur ordinaire, et n'utilisez les permissions de super-utilisateur que lorsque vous en avez vraiment besoin.

**Erreur 3 : croire qu'une erreur de permission est un bug du programme.** Quand le système d'exploitation renvoie « Access is denied » / `PermissionError`, il **a vérifié et constaté** que l'utilisateur actuel n'a pas la permission pour cette action. La correction consiste à vérifier qui possède le fichier et quelles sont ses permissions — pas à modifier le programme.

### Résumé

- Le **système de fichiers** organise le disque en un **arbre** de dossiers et de fichiers, à partir de la racine (`C:\` ou `/`).
- Un **chemin absolu** part de la racine. Un **chemin relatif** part du répertoire courant. `.` = ici, `..` = en haut.
- Les chemins relatifs se mesurent **depuis l'endroit où vous avez lancé le programme**, pas depuis l'emplacement du fichier.
- Chaque utilisateur a un dossier personnel et des permissions. **Administrator / root** sont des super-utilisateurs, à n'utiliser qu'en cas de besoin.
- Permissions de base : **lecture / écriture / exécution**. Une erreur de permission = le système d'exploitation a refusé.

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

### Documentation officielle

- [Naming Files, Paths, and Namespaces](https://learn.microsoft.com/en-us/windows/win32/fileio/naming-a-file)
- [chmod — Linux manual page](https://man7.org/linux/man-pages/man1/chmod.1.html)

<!-- 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: Les cinq rôles

Énumérez les cinq rôles principaux du système d'exploitation, et donnez un exemple de chacun tiré de ce qui se passe sur votre ordinateur.

{{< solution >}}
| Rôle | Exemple |
|---|---|
| **Gestion des processus** | Décide qui reçoit le CPU et quand — un navigateur, un lecteur de musique et VS Code « tournent ensemble » |
| **Gestion de la mémoire** | Donne de la RAM à chaque programme, et empêche un programme de lire la mémoire d'un autre |
| **Gestion des fichiers** | Conserve les fichiers dans un arbre de dossiers sur le disque |
| **Utilisateurs et permissions** | Un utilisateur ordinaire ne peut pas supprimer les fichiers système |
| **Gestion du matériel** | Communique avec l'écran, le clavier et l'imprimante via des pilotes |
{{< /solution >}}

### Exercice 2: Que se passe-t-il quand print affiche ?

Un programme Python exécute `print("Hi")`. Décrivez le chemin depuis le programme jusqu'à l'apparition du texte à l'écran. Utilisez les termes mode utilisateur, appel système, noyau et pilote.

{{< solution >}}
1. Notre programme tourne en **mode utilisateur** — il n'a pas d'accès direct à l'écran.
2. Python demande au noyau d'écrire le texte — c'est un **appel système** (une demande en bonne et due forme).
3. Le **noyau**, qui tourne en **mode noyau** avec un accès complet au matériel, vérifie les permissions.
4. Le noyau transmet la demande au **pilote** de l'écran.
5. Le texte apparaît à l'écran.
{{< /solution >}}

### Exercice 3: Programme face à processus

1. Quelle est la différence entre un programme et un processus ?
2. Vous avez ouvert trois fenêtres de Chrome. Combien y a-t-il de programmes, et au moins combien de processus ?
3. L'ordinateur a 8 cœurs, mais 300 processus tournent. Comment est-ce possible ?

{{< solution >}}
1. Un **programme** est un fichier sur le disque — la recette. Un **processus** en est une exécution active en RAM, avec son propre PID et sa propre mémoire — la cuisson.
2. **Un seul programme** (Chrome) et **au moins trois processus** — en pratique beaucoup plus, car Chrome lance un processus séparé pour chaque onglet et chaque composant.
3. L'**ordonnanceur** du système d'exploitation découpe le temps CPU en petites tranches de quelques millisecondes, et fait passer les cœurs d'un processus à l'autre assez vite pour qu'ils semblent tous tourner en parallèle.
{{< /solution >}}

### Exercice 4: Les chemins

Le terminal se trouve dans `C:\Users\dana\dev\kodkod6\week-1`. En quel chemin absolu se traduit chacun des chemins relatifs ?

```text
.
..
..\week-2
..\..
```

{{< solution >}}
| Chemin relatif | Chemin absolu |
|---|---|
| `.` | `C:\Users\dana\dev\kodkod6\week-1` |
| `..` | `C:\Users\dana\dev\kodkod6` |
| `..\week-2` | `C:\Users\dana\dev\kodkod6\week-2` |
| `..\..` | `C:\Users\dana\dev` |

`.` = le répertoire courant, `..` = un dossier plus haut.
{{< /solution >}}

### Exercice 5: Lire des permissions

Voici une ligne de `ls -l` sur un ordinateur Linux :

```text
-rw-r-----   dana   grades.txt
```

1. Est-ce un fichier ou un dossier ?
2. Qu'a le droit de faire le propriétaire (dana), qu'a le droit de faire le groupe, et qu'ont le droit de faire tous les autres ?
3. Un autre utilisateur, qui n'est pas dans le groupe, essaie de lire le fichier. Que se passe-t-il, et qui décide ?

{{< solution >}}
1. **Un fichier** — le premier caractère est `-` (un dossier commencerait par `d`).
2. Les permissions sont découpées en trois groupes de trois caractères :
   - **Propriétaire** `rw-` — lecture et écriture.
   - **Groupe** `r--` — lecture seule.
   - **Tous les autres** `---` — aucune permission.
3. Il reçoit une **erreur de permission** (Permission denied). Celui qui décide est le **système d'exploitation** — le noyau vérifie les permissions à chaque tentative d'accès au fichier.
{{< /solution >}}

<!-- exercises:end -->