diff --git a/b9f0369a-2823-4af4-819c-3a1fc0cf2b8c/draft_overlay.json b/b9f0369a-2823-4af4-819c-3a1fc0cf2b8c/draft_overlay.json
deleted file mode 100644
index f567292..0000000
--- a/b9f0369a-2823-4af4-819c-3a1fc0cf2b8c/draft_overlay.json
+++ /dev/null
@@ -1,15 +0,0 @@
-{
-    "title": "Variable `$$` — récupérer le PID du shell",
-    "_updated_at": "2026-05-16 16:01:10",
-    "slug": "symbole-double-et-commercial-2",
-    "published": true,
-    "published_at": "2023-01-09 22:35",
-    "category": "Informatique",
-    "tags": {
-        "tags": [
-            "Bash"
-        ]
-    },
-    "seo_title": "",
-    "seo_description": ""
-}
diff --git a/b9f0369a-2823-4af4-819c-3a1fc0cf2b8c/draft_overlay.md b/b9f0369a-2823-4af4-819c-3a1fc0cf2b8c/draft_overlay.md
deleted file mode 100644
index c1619da..0000000
--- a/b9f0369a-2823-4af4-819c-3a1fc0cf2b8c/draft_overlay.md
+++ /dev/null
@@ -1,122 +0,0 @@
-# Variable `$$` — récupérer le PID du shell
-
-La variable spéciale `$$` renvoie le **PID** (*Process IDentifier*) du shell courant, c'est-à-dire le numéro unique qu'attribue le système d'exploitation à chaque processus en cours d'exécution. Cette variable est particulièrement utile dans plusieurs situations courantes que nous allons détailler ci-dessous.
-
-## À quoi sert concrètement `$$` ?
-
-### 1. Générer des noms de fichiers temporaires uniques
-
-Quand un script crée un fichier temporaire, il faut éviter les collisions si plusieurs instances du script tournent en même temps. Utiliser `$$` dans le nom garantit l'unicité :
-
-```bash
-#!/bin/bash
-# Création d'un fichier temporaire propre à cette exécution
-TMPFILE="/tmp/monscript.$$.tmp"
-echo "Données de travail" > "$TMPFILE"
-echo "Fichier temporaire créé : $TMPFILE"
-# Affichera par exemple : /tmp/monscript.17601.tmp
-```
-
-Si deux utilisateurs lancent le script simultanément, l'un aura `/tmp/monscript.17601.tmp` et l'autre `/tmp/monscript.18422.tmp` — pas de conflit possible.
-
-### 2. Tracer un script dans les logs
-
-Lorsqu'un script écrit dans un journal commun, préfixer chaque ligne par le PID permet de distinguer les exécutions parallèles :
-
-```bash
-#!/bin/bash
-echo "[$$] Démarrage du script à $(date)" >> /var/log/monscript.log
-echo "[$$] Traitement en cours..."        >> /var/log/monscript.log
-echo "[$$] Fin du script"                 >> /var/log/monscript.log
-```
-
-Résultat dans le log :
-```
-[17601] Démarrage du script à Sat May 16 14:23:01 CEST 2026
-[17601] Traitement en cours...
-[17601] Fin du script
-```
-
-On peut ensuite filtrer une exécution particulière avec `grep "\[17601\]" /var/log/monscript.log`.
-
-### 3. Créer un fichier de verrou (*lock file*)
-
-Pour empêcher deux instances d'un script de tourner en même temps, on écrit son PID dans un fichier de verrou :
-
-```bash
-#!/bin/bash
-LOCKFILE="/tmp/monscript.lock"
-
-if [ -e "$LOCKFILE" ]; then
-    echo "Script déjà en cours (PID $(cat $LOCKFILE)). Abandon."
-    exit 1
-fi
-
-echo $$ > "$LOCKFILE"          # On enregistre notre PID
-trap "rm -f $LOCKFILE" EXIT    # On nettoie à la sortie
-
-echo "Travail en cours sous le PID $$..."
-sleep 30
-```
-
-## Particularité dans les sous-shells
-
-`$$` conserve **toujours** la valeur du shell **parent**, même lorsqu'elle est évaluée dans un sous-shell `( … )`. C'est un piège classique : on pourrait croire que le sous-shell, étant un nouveau processus, aurait son propre PID via `$$` — ce n'est pas le cas.
-
-Pour obtenir le PID réel du processus Bash en cours d'exécution, Bash propose la variable `$BASHPID`.
-
-### Exemple comparatif
-
-```bash
-~ $ echo $$
-17601
-~ $ ( echo $$; echo $BASHPID )
-17601
-17634
-```
-
-Dans l'exemple ci-dessus :
-- `$$` affiche `17601` dans les deux cas : c'est le PID du shell interactif d'origine, conservé même à l'intérieur des parenthèses.
-- `$BASHPID` affiche `17634` : c'est le PID du sous-shell réellement créé par les parenthèses.
-
-### Exemple plus parlant avec plusieurs niveaux de sous-shells
-
-```bash
-~ $ echo "Shell principal : \$\$=$$  \$BASHPID=$BASHPID"
-Shell principal : $$=17601  $BASHPID=17601
-
-~ $ ( echo "Sous-shell 1 : \$\$=$$  \$BASHPID=$BASHPID"
-      ( echo "Sous-shell 2 (imbriqué) : \$\$=$$  \$BASHPID=$BASHPID" )
-    )
-Sous-shell 1 : $$=17601  $BASHPID=17634
-Sous-shell 2 (imbriqué) : $$=17601  $BASHPID=17699
-```
-
-On voit clairement que :
-- `$$` reste figé à `17601` (le shell de départ) dans tous les contextes.
-- `$BASHPID` change à chaque niveau d'imbrication : `17634` pour le premier sous-shell, `17699` pour le second.
-
-### Cas pratique : pourquoi cette distinction est importante
-
-Imaginons qu'on veuille créer un fichier temporaire propre à un sous-shell :
-
-```bash
-~ $ ( TMP="/tmp/sub.$$.txt"
-      echo "fichier = $TMP"
-      TMP_REAL="/tmp/sub.$BASHPID.txt"
-      echo "fichier réel = $TMP_REAL"
-    )
-fichier = /tmp/sub.17601.txt        # ⚠️ même nom que le shell parent !
-fichier réel = /tmp/sub.17634.txt   # ✅ vraiment unique au sous-shell
-```
-
-Si plusieurs sous-shells utilisent `$$`, ils écrivent tous dans le même fichier — ce qui peut provoquer des écrasements de données. Avec `$BASHPID`, chaque sous-shell a son propre fichier.
-
-## À retenir
-
-| Variable    | Valeur retournée                                    |
-|-------------|-----------------------------------------------------|
-| `$$`        | PID du shell **de référence** (le shell d'origine)  |
-| `$BASHPID`  | PID du processus Bash **réellement en cours**       |
-
-Dans un shell standard sans sous-shell, les deux valeurs sont identiques. La différence n'apparaît qu'à l'intérieur de `( … )`, et c'est précisément là qu'il faut savoir laquelle utiliser selon l'effet recherché.
\ No newline at end of file
diff --git a/b9f0369a-2823-4af4-819c-3a1fc0cf2b8c/index.md b/b9f0369a-2823-4af4-819c-3a1fc0cf2b8c/index.md
index da13542..c1619da 100644
--- a/b9f0369a-2823-4af4-819c-3a1fc0cf2b8c/index.md
+++ b/b9f0369a-2823-4af4-819c-3a1fc0cf2b8c/index.md
@@ -1,12 +1,73 @@
 # Variable `$$` — récupérer le PID du shell
 
-La variable spéciale `$$` renvoie le **PID** (*Process IDentifier*) du shell courant. Elle est utile pour générer des noms de fichiers temporaires uniques, tracer un script dans les logs ou créer un fichier de verrou.
+La variable spéciale `$$` renvoie le **PID** (*Process IDentifier*) du shell courant, c'est-à-dire le numéro unique qu'attribue le système d'exploitation à chaque processus en cours d'exécution. Cette variable est particulièrement utile dans plusieurs situations courantes que nous allons détailler ci-dessous.
+
+## À quoi sert concrètement `$$` ?
+
+### 1. Générer des noms de fichiers temporaires uniques
+
+Quand un script crée un fichier temporaire, il faut éviter les collisions si plusieurs instances du script tournent en même temps. Utiliser `$$` dans le nom garantit l'unicité :
+
+```bash
+#!/bin/bash
+# Création d'un fichier temporaire propre à cette exécution
+TMPFILE="/tmp/monscript.$$.tmp"
+echo "Données de travail" > "$TMPFILE"
+echo "Fichier temporaire créé : $TMPFILE"
+# Affichera par exemple : /tmp/monscript.17601.tmp
+```
+
+Si deux utilisateurs lancent le script simultanément, l'un aura `/tmp/monscript.17601.tmp` et l'autre `/tmp/monscript.18422.tmp` — pas de conflit possible.
+
+### 2. Tracer un script dans les logs
+
+Lorsqu'un script écrit dans un journal commun, préfixer chaque ligne par le PID permet de distinguer les exécutions parallèles :
+
+```bash
+#!/bin/bash
+echo "[$$] Démarrage du script à $(date)" >> /var/log/monscript.log
+echo "[$$] Traitement en cours..."        >> /var/log/monscript.log
+echo "[$$] Fin du script"                 >> /var/log/monscript.log
+```
+
+Résultat dans le log :
+```
+[17601] Démarrage du script à Sat May 16 14:23:01 CEST 2026
+[17601] Traitement en cours...
+[17601] Fin du script
+```
+
+On peut ensuite filtrer une exécution particulière avec `grep "\[17601\]" /var/log/monscript.log`.
+
+### 3. Créer un fichier de verrou (*lock file*)
+
+Pour empêcher deux instances d'un script de tourner en même temps, on écrit son PID dans un fichier de verrou :
+
+```bash
+#!/bin/bash
+LOCKFILE="/tmp/monscript.lock"
+
+if [ -e "$LOCKFILE" ]; then
+    echo "Script déjà en cours (PID $(cat $LOCKFILE)). Abandon."
+    exit 1
+fi
+
+echo $$ > "$LOCKFILE"          # On enregistre notre PID
+trap "rm -f $LOCKFILE" EXIT    # On nettoie à la sortie
+
+echo "Travail en cours sous le PID $$..."
+sleep 30
+```
 
 ## Particularité dans les sous-shells
 
-`$$` conserve toujours la valeur du shell **parent**, même lorsqu'elle est évaluée dans un sous-shell `( … )`. Pour obtenir le PID réel du processus en cours d'exécution, Bash propose la variable `$BASHPID`.
+`$$` conserve **toujours** la valeur du shell **parent**, même lorsqu'elle est évaluée dans un sous-shell `( … )`. C'est un piège classique : on pourrait croire que le sous-shell, étant un nouveau processus, aurait son propre PID via `$$` — ce n'est pas le cas.
 
-```
+Pour obtenir le PID réel du processus Bash en cours d'exécution, Bash propose la variable `$BASHPID`.
+
+### Exemple comparatif
+
+```bash
 ~ $ echo $$
 17601
 ~ $ ( echo $$; echo $BASHPID )
@@ -15,8 +76,47 @@ La variable spéciale `$$` renvoie le **PID** (*Process IDentifier*) du shell co
 ```
 
 Dans l'exemple ci-dessus :
+- `$$` affiche `17601` dans les deux cas : c'est le PID du shell interactif d'origine, conservé même à l'intérieur des parenthèses.
+- `$BASHPID` affiche `17634` : c'est le PID du sous-shell réellement créé par les parenthèses.
 
-- `$$` affiche `17601` dans les deux cas : c'est le PID du shell interactif d'origine.
-- `$BASHPID` affiche `17634` : c'est le PID du sous-shell créé par les parenthèses.
+### Exemple plus parlant avec plusieurs niveaux de sous-shells
 
-Retenir la différence : **`$$` = PID du shell de référence**, **`$BASHPID` = PID du processus Bash réellement en cours**.
\ No newline at end of file
+```bash
+~ $ echo "Shell principal : \$\$=$$  \$BASHPID=$BASHPID"
+Shell principal : $$=17601  $BASHPID=17601
+
+~ $ ( echo "Sous-shell 1 : \$\$=$$  \$BASHPID=$BASHPID"
+      ( echo "Sous-shell 2 (imbriqué) : \$\$=$$  \$BASHPID=$BASHPID" )
+    )
+Sous-shell 1 : $$=17601  $BASHPID=17634
+Sous-shell 2 (imbriqué) : $$=17601  $BASHPID=17699
+```
+
+On voit clairement que :
+- `$$` reste figé à `17601` (le shell de départ) dans tous les contextes.
+- `$BASHPID` change à chaque niveau d'imbrication : `17634` pour le premier sous-shell, `17699` pour le second.
+
+### Cas pratique : pourquoi cette distinction est importante
+
+Imaginons qu'on veuille créer un fichier temporaire propre à un sous-shell :
+
+```bash
+~ $ ( TMP="/tmp/sub.$$.txt"
+      echo "fichier = $TMP"
+      TMP_REAL="/tmp/sub.$BASHPID.txt"
+      echo "fichier réel = $TMP_REAL"
+    )
+fichier = /tmp/sub.17601.txt        # ⚠️ même nom que le shell parent !
+fichier réel = /tmp/sub.17634.txt   # ✅ vraiment unique au sous-shell
+```
+
+Si plusieurs sous-shells utilisent `$$`, ils écrivent tous dans le même fichier — ce qui peut provoquer des écrasements de données. Avec `$BASHPID`, chaque sous-shell a son propre fichier.
+
+## À retenir
+
+| Variable    | Valeur retournée                                    |
+|-------------|-----------------------------------------------------|
+| `$$`        | PID du shell **de référence** (le shell d'origine)  |
+| `$BASHPID`  | PID du processus Bash **réellement en cours**       |
+
+Dans un shell standard sans sous-shell, les deux valeurs sont identiques. La différence n'apparaît qu'à l'intérieur de `( … )`, et c'est précisément là qu'il faut savoir laquelle utiliser selon l'effet recherché.
\ No newline at end of file
diff --git a/b9f0369a-2823-4af4-819c-3a1fc0cf2b8c/meta.json b/b9f0369a-2823-4af4-819c-3a1fc0cf2b8c/meta.json
index 5a1ccd9..c24e389 100644
--- a/b9f0369a-2823-4af4-819c-3a1fc0cf2b8c/meta.json
+++ b/b9f0369a-2823-4af4-819c-3a1fc0cf2b8c/meta.json
@@ -7,13 +7,19 @@
     "featured": false,
     "published_at": "2023-01-09 22:35",
     "created_at": "2023-01-09 22:35:09",
-    "updated_at": "2026-05-16 15:59:20",
+    "updated_at": "2026-05-16 16:01:11",
     "revisions": [
         {
             "n": 1,
             "date": "2026-05-16 15:59:20",
             "comment": "Titre modifié, tags modifiés, contenu modifié, image de couverture modifiée",
             "title": "Paramètre && - retour du PID"
+        },
+        {
+            "n": 2,
+            "date": "2026-05-16 16:01:11",
+            "comment": "Contenu modifié",
+            "title": "Variable `$$` — récupérer le PID du shell"
         }
     ],
     "cover": "cover.png",
diff --git a/b9f0369a-2823-4af4-819c-3a1fc0cf2b8c/revisions/0002.md b/b9f0369a-2823-4af4-819c-3a1fc0cf2b8c/revisions/0002.md
new file mode 100644
index 0000000..da13542
--- /dev/null
+++ b/b9f0369a-2823-4af4-819c-3a1fc0cf2b8c/revisions/0002.md
@@ -0,0 +1,22 @@
+# Variable `$$` — récupérer le PID du shell
+
+La variable spéciale `$$` renvoie le **PID** (*Process IDentifier*) du shell courant. Elle est utile pour générer des noms de fichiers temporaires uniques, tracer un script dans les logs ou créer un fichier de verrou.
+
+## Particularité dans les sous-shells
+
+`$$` conserve toujours la valeur du shell **parent**, même lorsqu'elle est évaluée dans un sous-shell `( … )`. Pour obtenir le PID réel du processus en cours d'exécution, Bash propose la variable `$BASHPID`.
+
+```
+~ $ echo $$
+17601
+~ $ ( echo $$; echo $BASHPID )
+17601
+17634
+```
+
+Dans l'exemple ci-dessus :
+
+- `$$` affiche `17601` dans les deux cas : c'est le PID du shell interactif d'origine.
+- `$BASHPID` affiche `17634` : c'est le PID du sous-shell créé par les parenthèses.
+
+Retenir la différence : **`$$` = PID du shell de référence**, **`$BASHPID` = PID du processus Bash réellement en cours**.
\ No newline at end of file