diff --git a/unix/shell/boucle.tml b/unix/shell/boucle.tml
index 8662644..a37c0df 100644
--- a/unix/shell/boucle.tml
+++ b/unix/shell/boucle.tml
@@ -19,7 +19,7 @@ href="script.html">initiation à la programmation en shell</a>).
 </p>
 
 <p>Toutefois, avoir posé les rails ne suffit pas toujours : il peut
-importer de disposer de mécanismes d'aiguillage. Les boucles vous
+importer de disposer de mécanismes d'aiguillage. Les structures de contrôle vous
 permettront de réaliser ces mécanismes d'aiguillage, qui donneront à vos
 scripts souplesse et efficacité. </p>
 
@@ -27,7 +27,7 @@ scripts souplesse et efficacité. </p>
 
 <h2>Examiner une condition : <code>if</code> et <code>case</code></h2> 
 
-<h3>La boucle <code>if</code></h3>
+<h3>La structure <code>if</code></h3>
 
 <h4>Description</h4>
 
@@ -61,7 +61,7 @@ condition alternative ;</li>
 <li> <code>else</code> (sinon), qui est <em>facultatif</em> et marque le
 comportement à adopter si la condition n'est pas remplie ; </li>
 <li> <code>fi</code> (<code>if</code> à l'envers), qui marque la fin de
-la boucle.</li>
+la structure de branchement.</li>
 </ol>
 
 <p>On peut donc taper :</p>
@@ -137,7 +137,7 @@ fi
 <li> <strong>Le nombre de <code>elif</code> successifs est
 illimité</strong>, alors qu'il ne peut (et c'est logique) y avoir qu'une
 seule condition <code>if</code>, une seule instruction <code>else</code>
-et une seule instruction <code>fi</code> dans une boucle. </li>
+et une seule instruction <code>fi</code> correspondant au <code>if</code> initial. </li>
 
 <li> Remarquez les dernières lignes du script : <code>$HOME</code>
 est cité dans des guillemets simples, alors que <code>$PWD</code> est
@@ -149,11 +149,11 @@ interprété (le mot « $HOME » apparaîtra tel quel), tandis que
 
 
 
-<h3>La boucle <code>case</code></h3>
+<h3>La structure <code>case</code></h3>
 
 <h4>Quand préférer <code>case</code> à <code>if</code> ?</h4>
 
-<p>La boucle <code>if</code> est très pratique, mais devient rapidement
+<p>La structure de contrôle <code>if</code> est très pratique, mais devient rapidement
 illisible lorsqu'un aiguillage offre plusieurs sorties, et que l'on doit
 répéter une condition pusieurs fois sous des formes à peine
 différentes. Typiquement, un programme comme celui-ci est pénible à
@@ -186,14 +186,14 @@ $PWD =</code> » ; et qui dit redondance dit possibilité de
 faute de frappe &ndash; erreur particulièrement difficile à repérer
 à l'&oelig;il nu ;</li>
 
-<li> parce que les différentes conditions ne sont pas mises sur le même
-plan (<code>if</code> n'est pas, dans la boucle, sur le même plan que
-<code>elif</code>, alors que logiquement les deux instructions le
-sont), ce qui nuit à la lisibilité.</li> 
+<li> parce que les différentes conditions ne sont pas mises sur le même plan
+(au <code>if</code> correspond un <code>fi</code> mais les <code>elif</code>
+n'ont pas besoin d'être ainsi « refermés », alors que logiquement les deux
+instructions le sont), ce qui nuit à la lisibilité.</li> 
 
 </ol>
 
-<p>La boucle <code>case</code> entend remédier à ces inconvénients. Il
+<p>La structure de contrôle <code>case</code> entend remédier à ces inconvénients. Il
 s'agit tout simplement de la simplification d'un usage fréquent de la
 structure <code>if</code>. On peut récrire le programme suivant avec
 <code>case</code> :</p> 
@@ -213,8 +213,7 @@ esac
 assure) :</p> 
 
 <ol>
-<li> la structure de la boucle et son enjeu sont
-transparents ;</li> 
+<li> la structure et l'enjeu sont transparents ;</li> 
 
 <li> la variable que l'on teste n'est citée qu'une seule fois, au lieu
 d'être répétée à chaque instruction <code>elif</code> ;</li>
@@ -225,7 +224,7 @@ plan.</li>
 
 <h4>Syntaxe de <code>case</code></h4>
 
-<p>La boucle <code>case</code> adopte la syntaxe suivante :</p> 
+<p>La structure <code>case</code> adopte la syntaxe suivante :</p> 
 
 <pre>
 case <em>chaîne</em> in
@@ -235,7 +234,7 @@ esac
 </pre>
 
 <p>
-La boucle <code>case</code> commence par évaluer la
+La structure <code>case</code> commence par évaluer la
 <em>chaîne</em>. Ensuite, elle va lire chaque <em>motif</em>.  Enfin, et
 dès qu'une <em>chaîne</em> correspond au <em>motif</em>, elle exécute
 les <em>commandes</em> appropriées. En anglais, <em>case</em> signifie
@@ -254,9 +253,9 @@ fermante (qui n'est ouverte nulle part !) ;</li>
 <li> la série des <em>commandes</em> est close par deux points et
 virgules successifs (« ;; ») ; </li>
 
-<li> la boucle <code>case</code> est close par l'instruction
+<li> la structure <code>case</code> est close par l'instruction
 <code>esac</code>, qui n'est autre que le mot <code>case</code> à
-l'envers (de même que la boucle <code>if</code> est terminée par
+l'envers (de même que la structure <code>if</code> est terminée par
 l'instruction <code>fi</code>).</li> 
 </ul>
 
@@ -322,11 +321,11 @@ fautes d'inattention, qui sont particulièrement coriaces à débuguer.
 </p>
 
 <div class="attention">
-<p>La boucle <code>case</code> exécute les commandes correspondant au
+<p>La structure <code>case</code> exécute les commandes correspondant au
 <strong>premier</strong> motif correct, et ne parcourt pas les motifs
 suivants si elle en a trouvé un. Par conséquent, <strong>si le dernier
 motif est « * », cela revient à l'instruction
-<code>else</code> dans la boucle <code>if</code></strong>.</p>
+<code>else</code> dans la structure <code>if</code></strong>.</p>
 </div>
 
 
@@ -336,7 +335,7 @@ et <code>for</code></h2>
 
 <p>Les structures <code>if</code> et <code>case</code> sont des
 structures d'aiguillage ; les structures <code>while</code>,
-<code>until</code> et <code>for</code> sont proprement des
+<code>until</code> et <code>for</code> sont des
 boucles. C'est-à-dire qu'elles soumettent à une condition déterminée la
 répétition (ou non) d'une suite de commandes.</p>