Semi adv

src/cli/semi-adv.tex

-\subsection{Wildcards et globs}
+\subsection{Globbing patterns et wildcards}
 
 \begin{frame}[fragile]{Faire référence à plusieurs fichiers}
-	%% globs
-	%% Attention aux fichiers cachés
+	C'est fastidieux d'être obligé d'écrire le nom de tous les fichiers dans
+	les commandes. On peut se simplifier la vie grâce aux globbing patterns.
+	
+	\begin{block}{globbing pattern (\emph{motif d'englobement})}
+		Un motif de nom de fichier qui en englobe plusieurs.
+	\end{block}
+	
+	\begin{block}{wildcard (\emph{joker})}
+		Lettre spéciale qui représente un caractère ou une suite de caractères 
+		quelconques dans un \emph{globbing pattern}.
+	\end{block}
+\end{frame}
+
+\begin{frame}[fragile]{Le joker ``*''}
+
+	Joker le plus utilisé.
+	Remplace toute suite de caractères dans un motif. S'il est utilisé seul, remplace tout mot.
+
+	\begin{exampleblock}{Créons des fichiers}
+		\cmd{cd ; mkdir api ; cd api}
+		\cmd{touch here that there this}
+
+	\end{exampleblock}
+	
+	\begin{alertblock}{Le point-virgule}
+		Le point virgule sépare des commandes successives sur la ligne de commande.
+	\end{alertblock}
+	
+	\begin{alertblock}{\cmd{touch}}
+		Crée les fichiers passés en arguments. Si un fichier existe déjà,
+		met à jour sa date de dernière modification.
+	\end{alertblock}
+\end{frame}
+
+\begin{frame}[fragile]{Le joker ``*''}
+
+	\begin{exampleblock}{Supprimons des fichiers}
+		On pourrait écrire: \cmd{rm here that there this}
+		
+		\cmd{rm *} fait la même chose car le joker ``*'' correspond à tous les noms de fichiers.
+	\end{exampleblock}
+	
+	\begin{beamercolorbox}[rounded=true,shadow=true]{terminal}
+	\begin{Verbatim}
+$ ls
+here that there this
+$ \textcolor{yellow}{rm *}
+$ ls
+$ 
+	\end{Verbatim}  
+	\end{beamercolorbox}	
+\end{frame}
+
+\begin{frame}[fragile]{Le joker ``*''}
+
+	\begin{exampleblock}{Re-créeons des fichiers}
+		\cmd{touch here that there this}	
+	\end{exampleblock}
+	
+	On peut restreindre le motif en donnant une partie du nom.
+	\begin{beamercolorbox}[rounded=true,shadow=true]{terminal}
+	\begin{Verbatim}
+$ ls *
+here that there this
+$ ls t*
+that there this
+$ ls *h*
+here that there this
+$ ls th*e
+there
+$ ls that*
+that
+$ ls thi*s
+this
+	\end{Verbatim}  
+	\end{beamercolorbox}	
+		
+	\begin{alertblock}{Attention}
+		``*'' correspond aussi aux séquences vides!
+	\end{alertblock}
+\end{frame}
+
+\begin{frame}[fragile]{Le joker ``?''}
+
+	\begin{block}{}
+		Il représente un caractère unique quelconque dans un motif.
+	\end{block}
+
+	\begin{beamercolorbox}[rounded=true,shadow=true]{terminal}
+	\begin{Verbatim}
+$ ls th?t
+that
+$ ls th??
+that this
+$ ls th???
+there
+$ ls ?here
+there
+$ ls *here	\textcolor{red}{<---- Attention ici le joker correspond aussi à une séquence vide}
+here there
+	\end{Verbatim}  
+	\end{beamercolorbox}	
+\end{frame}
+
+\begin{frame}[fragile]{Le joker ``[]''}
+	\begin{block}{}
+		Permet de définir un ensemble de caractères pouvant apparaître dans le nom.
+	\end{block}
+	
+	\begin{exampleblock}{Créons plus de fichiers}
+		\cmd{touch file\_1 file\_2 file\_3 file\_4 file\_a file\_b file\_c file\_d}
+	\end{exampleblock}
+	
+	\begin{beamercolorbox}[rounded=true,shadow=true]{terminal}
+	\begin{Verbatim}
+$ ls file_[12ab]
+file_1 file_2 file_a file_b
+	\end{Verbatim}  
+	\end{beamercolorbox}	
+\end{frame}
+
+\begin{frame}[fragile]{Le joker ``[]''}
+
+	On peut spécifier des intervalles plutôt que de donner tous les caractères.
+	\begin{beamercolorbox}[rounded=true,shadow=true]{terminal}
+	\begin{Verbatim}
+$ ls file_[1-3b-d]
+file_1 file_2 file_3 file_b file_c file_d
+	\end{Verbatim}  
+	\end{beamercolorbox}
+	
+	\vspace{10pt}
+	On peut aussi prendre le complément de la liste en la préfixant par un ``\verb+^+''.
+	\begin{beamercolorbox}[rounded=true,shadow=true]{terminal}
+	\begin{Verbatim}
+$ ls file_[^1-3b-d]
+file_4 file_a
+	\end{Verbatim}  
+	\end{beamercolorbox}
+\end{frame}
+
+\begin{frame}[fragile]{Échappement de caractères}
+
+	Et si il y a un fichier dont le nom contient le caractère ``-''?
+
+	\begin{exampleblock}{Un fichier de plus}
+		\cmd{touch file\_-}
+	\end{exampleblock}	
+	
+	\begin{beamercolorbox}[rounded=true,shadow=true]{terminal}
+	\begin{Verbatim}
+$ ls file_[1-3b-d]
+file_1 file_2 file_3 file_b file_c file_d
+$ ls file_[1-3b-d\textcolor{yellow}{\textbackslash{}-}]
+file_- file_1 file_2 file_3 file_b file_c file_d
+	\end{Verbatim}  
+	\end{beamercolorbox}
+	
+	\vspace{10pt}
+	\begin{block}{Caractère d'échappement}
+		Le caractère ``\textbackslash'' supprime l'interprétation par le shell du caractère qui le suit.
+		On peut même échapper l'espace.
+	\end{block}
+	
+	\begin{beamercolorbox}[rounded=true,shadow=true]{terminal}
+	\begin{Verbatim}
+$ touch my\textbackslash file
+$ ls
+'my file'           \textcolor{cyan}{<----- Les simple quotes indiquent qu'il s'agit d'un seul fichier}
+	\end{Verbatim}  
+	\end{beamercolorbox}
+\end{frame}
+
+\begin{frame}[fragile]{Expansion d'accolades}
+	\begin{block}{Expansion d'accolades}
+		\cmd{bash} supporte l'expansion d'accolades: générer toutes les chaînes dans un intervalle ou à partir 
+		d'une liste.
+	\end{block}
+	\begin{beamercolorbox}[rounded=true,shadow=true]{terminal}
+	\begin{Verbatim}
+$ echo \{1..20\}
+1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
+$ echo a\{c,d,e\}f
+acf adf aef
+	\end{Verbatim}  
+	\end{beamercolorbox}	
+
+	\vspace{10pt}	
+	Cette expansion peut être utilisée dans des motifs.
+	\begin{beamercolorbox}[rounded=true,shadow=true]{terminal}
+	\begin{Verbatim}
+$ touch file_\{1..20\}
+$ ls
+file_1   file_12  file_15  file_18  file_20  file_5  file_8
+file_10  file_13  file_16  file_19  file_3   file_6  file_9
+file_11  file_14  file_17  file_2   file_4   file_7
+$ rm file_\{12..14\}
+$ ls
+file_1   file_15  file_18  file_20  file_5  file_8
+file_10  file_16  file_19  file_3   file_6  file_9
+file_11  file_17  file_2   file_4   file_7
+	\end{Verbatim}  
+	\end{beamercolorbox}
+\end{frame}
+
+\begin{frame}[fragile]{Expansion d'accolades}
+	\begin{block}{Extensions multiples}
+		L'expansion d'accolade est très utilisée pour sélectionner des fichiers avec des extensions multiples.
+		
+		\cmd ls *.\{jpg,png,bmp\}
+		
+		listera tous les fichiers correspondants à ces extensions.
+	\end{block}
+	
+	\begin{alertblock}{Extensions}
+		\begin{itemize}
+			\item Les extensions n'ont pas de sens particulier sous UNIX. 
+			\item Spécificité de Windows et de ses prédécesseurs.
+			\item Pratique pour indiquer le type des fichiers...
+		\end{itemize}
+	\end{alertblock}
+\end{frame}
+
+\begin{frame}[fragile]{Remarques}
+
+	\begin{block}{Jokers dans les chemins}
+		Le chemin fait partie du nom des fichiers, on peut mettre des jokers dans ceux-ci.
+		
+		\cmd{ls /var/*/*.log} 
+
+		liste tous les fichiers de logs dans tous les sous-répertoires directs de \cmd{/var}
+
+		\cmd{ls /var/*/*/*.log} 
+		
+		liste tous les fichiers de logs dans tous les sous-répertoires des sous-répertoires de \cmd{/var}
+		
+	\end{block}
+	
+	\begin{block}{Si le motif ne correspond à aucun fichier?}
+		Dans ce cas, le motif est transmis tel quel à la commande.
+	\end{block}
+	\begin{beamercolorbox}[rounded=true,shadow=true]{terminal}
+	\begin{Verbatim}
+$ rm file?
+rm: impossible de supprimer 'file?': Aucun fichier ou dossier de ce type
+	\end{Verbatim}  
+	\end{beamercolorbox}		
+\end{frame}
+
+\begin{frame}[fragile]{Remarques}
+	\begin{alertblock}{Attention aux noms pris comme des options}
+	   On suppose qu'il existe un fichier ``-R''.
+	   
+	   Si on exécute ``\cmd{rm *}'', l'englobement va passer le nom \cmd{-R} à ``\cmd{rm}'' qui l'interprétera comme une option.
+	   
+	   La commande réellement exécutée sera ``\cmd{rm -R *}''. Oups!
+	\end{alertblock}
+	
+	\begin{block}{Séparer les options des arguments}
+		\begin{itemize}
+			\item ``\cmd{-{}-}'' est utilisé dans les commandes pour séparer explicitement les options des arguments.
+	
+			\item Tout ce qui suit ``\cmd{-{}-}'' est interprété comme un argument.
+		\end{itemize}
+		
+		``\cmd{rm -{}- *}'' est donc plus sûr, puisque c'est bien la commande ``\cmd{rm -{}- -R *}'' qui sera exécutée.
+	\end{block}
 \end{frame}
 
 \begin{frame}[fragile]{Et les fichiers cachés?}
-	%% globs
-	%% Attention aux fichiers cachés
+	\begin{block}{Des fichiers cachés? Où ça?}
+		Tous les fichiers dont le nom commence par un point sont cachés.
+		\begin{itemize}
+			\item Ils ne sont pas affichés par ``\cmd{ls}''.
+			\item Ils ne sont pas considérés pour l'englobement.
+		\end{itemize}
+	\end{block}
+	
+	\begin{beamercolorbox}[rounded=true,shadow=true]{terminal}
+	\begin{Verbatim}
+$ touch .hidden
+$ ls
+$ ls -a
+\textcolor{blue}{.}  \textcolor{blue}{..}  .hidden
+$ rm *
+$ ls -a
+\textcolor{blue}{.}  \textcolor{blue}{..}  .hidden
+	\end{Verbatim}  
+	\end{beamercolorbox}
+	
+\end{frame}
+
+\begin{frame}[fragile]{Et les fichiers cachés?}
+	\begin{alertblock}{\cmd{shopt}}
+		\cmd{shopt} permet de changer certaines options du shell.
+		\begin{itemize}
+			\item \cmd{shopt -s <option>} active l'option \cmd{<option>}
+			\item \cmd{shopt -u <option>} active l'option \cmd{<option>}
+		\end{itemize}
+	\end{alertblock}
+
+	\begin{block}{L'option \cmd{dotglob}}
+		Si elle est active, les fichiers commençant par un point sont candidats à l'englobement. Par défaut désactivée.
+	\end{block}
+	
+	\begin{beamercolorbox}[rounded=true,shadow=true]{terminal}
+	\begin{Verbatim}
+$ ls -a
+\textcolor{blue}{.}  \textcolor{blue}{..}  .hidden
+$ \textcolor{yellow}{shopt -s dotglob}
+$ rm *
+$ ls -a
+\textcolor{blue}{.}  \textcolor{blue}{..}
+	\end{Verbatim}  
+	\end{beamercolorbox}
 \end{frame}
 
 \subsection{Chercher des fichiers}
+
+\begin{frame}{Trouver des fichiers}
+	Des centaines de milliers de fichiers sur une distribution classique.
+	
+	Difficile de s'y retrouver sans outils...
+	
+	\begin{block}{\cmd{locate}}
+		Recherche des fichiers dans une base de données préremplie
+	\end{block}
+	
+	\begin{block}{\cmd{find}}
+		Recherche des fichiers dans l'arborescence, éventuellement avec des filtres
+		précis.
+	\end{block}
+\end{frame}
+
 \begin{frame}[fragile]{\cmd{locate}}
-	%% find
-	%% Exécution de commandes
+	\begin{block}{}
+		\begin{description}
+			\item[\cmd{locate <motif>}] recherche \cmd{<motif>} dans la base de données \cmd{/var/lib/mlocate/mlocate.db}
+		\end{description}
+	\end{block}
+	
+	\begin{beamercolorbox}[rounded=true,shadow=true]{terminal}
+	\begin{Verbatim}
+$ locate issue
+/etc/issue
+/etc/issue.net
+[...]
+	\end{Verbatim}  
+	\end{beamercolorbox}	
+	
+	\begin{alertblock}{Si \cmd{locate} ne renvoie rien}
+		\begin{itemize}
+			\item Rien n'a été trouvé
+			\item La base de donnée est vide
+		\end{itemize}
+	\end{alertblock}
+\end{frame}
+
+\begin{frame}[fragile]{\cmd{updatedb}}
+	\begin{block}{}
+		\begin{description}
+			\item[\cmd{updatedb}] met à jour la base de données \cmd{/var/lib/mlocate/mlocate.db}
+		\end{description}
+	\end{block}
+	
+	\begin{alertblock}{\cmd{sudo} obligatoire!}
+		Cette commande modifie un fichier que seul le superutilisateur peut modifier.
+		
+		Il faut exécuter \cmd{sudo updatedb}.
+	\end{alertblock}
+	
+	\begin{alertblock}{\cmd{sudo} (\emph{SuperUserDO})}
+		\begin{itemize}
+			\item Cette commande exécute une autre commande avec les droits du superutilisateur.
+			\item Seuls certains utilisateurs ont le droit de l'invoquer.
+			\item Elle demande le mot de passe de l'utilisateur qui l'invoque avant de s'exécuter.
+		\end{itemize}
+	\end{alertblock}
 \end{frame}
 
+
 \begin{frame}[fragile]{\cmd{find}}
+
+	\begin{block}{}
+		\begin{description}
+			\item[\cmd{find}] recherche un fichier dans le système de fichiers.
+		\end{description}
+	\end{block}
+	
+	Il suffit de spécifier le point de départ et ce qu'on cherche.
+	
+	\begin{beamercolorbox}[rounded=true,shadow=true]{terminal}
+	\begin{Verbatim}
+$ find . -name file_1
+./api/file_1
+	\end{Verbatim}  
+	\end{beamercolorbox}	
+	
+	On peut utiliser des jokers dans le nom
+	\begin{beamercolorbox}[rounded=true,shadow=true]{terminal}
+	\begin{Verbatim}
+$ find . -name 'file_1*' -print
+./api/file_11
+./api/file_18
+./api/file_1
+[...]
+	\end{Verbatim}  
+	\end{beamercolorbox}
+	
+	\begin{alertblock}{Attention aux quotes}
+		Le motif doit être entre quotes, sinon il sera interprété par le
+		shell.
+	\end{alertblock}
+\end{frame}
+
+\begin{frame}[fragile]{Filtrer avec \cmd{find}}
+
+	\begin{block}{}
+		\cmd{find} est capable de filtrer la recherche 
+		\begin{itemize}
+			\item{Par type de fichier}
+			\item{Par taille}
+			\item{Par date de modification}
+			\item ...
+		\end{itemize}
+	\end{block}
+	
+	\begin{exampleblock}{Cherchons les fichiers de plus de 10 Mo}
+		\cmd{find / -size +10M -print} 
+	\end{exampleblock}
+	
+	\begin{alertblock}{Il y a plein d'erreurs!}
+		Elles sont dûes au permissions d'accès à certains fichiers. 
+		On peut les supprimer en redirigeant la sortie d'erreur vers 
+		le périphérique 'poubelle' \cmd{/dev/null}:
+		
+		\cmd{find / -size +10M -print 2> /dev/null}
+	\end{alertblock} 
 \end{frame}
 
 \begin{frame}[fragile]{Exécuter des commandes avec \cmd{find}}
+
+	\cmd{find} peut exécuter une commande sur chaque fichier trouvé
+	avec l'option \cmd{-exec}.	
+	
+	\begin{exampleblock}{Créer un backup de chaque fichier}
+		\cmd{find api -name 'file*' -exec cp \{\} \{\}.bak \textbackslash;}
+	\end{exampleblock}
+
+	\begin{block}{Explication}
+		\begin{itemize}
+			\item \cmd{cp}] est exécutée pour chaque fichier trouvé
+			\item \cmd{\{\}} est remplacé par le nom du fichier trouvé
+			\item \cmd{\textbackslash;} indique la fin de la commande.
+		\end{itemize}			
+	\end{block}	
+	
+	\begin{alertblock}{}
+		\begin{itemize}
+			\item \cmd{-exec} n'autorise qu'une seule commande.
+			\item On peut avoir plusieurs \cmd{-exec}.
+		\end{itemize}
+	\end{alertblock}
 \end{frame}
 
 \subsection{Chercher à l'intérieur des fichiers}
 
 \begin{frame}[fragile]{\cmd{grep}}
+	\begin{block}{}
+		\begin{description}
+			\item[\cmd{grep}] recherche un motif dans des fichiers
+		\end{description}
+	\end{block}
+	
+	\begin{exampleblock}{Chercher tous les mots qui contiennent ``aard''}
+		\cmd{grep 'aard' /usr/share/dict/words}
+	\end{exampleblock}
+	\begin{beamercolorbox}[rounded=true,shadow=true]{terminal}
+	\begin{Verbatim}
+$ grep 'aard' /usr/share/dict/words
+Kierkeg\textcolor{red}{aard}
+Kierkeg\textcolor{red}{aard}'s
+\textcolor{red}{aard}vark
+\textcolor{red}{aard}vark's
+\textcolor{red}{aard}varks
+	\end{Verbatim}  
+	\end{beamercolorbox}
+	
+	\begin{block}{Remarques}
+		\begin{itemize}
+			\item{\cmd{grep} peut être utilisée récursivement: 
+			option \cmd{-R}}
+			\item{\cmd{grep} sans argument, cherche le motif sur l'entrée
+			standard}
+		\end{itemize}
+	\end{block}
 \end{frame}
 
-\begin{frame}[fragile]{Expressions régulières}
+\begin{frame}[fragile]{Expressions régulières (\emph{regex})}
+	\begin{block}{}
+		\begin{itemize}
+			\item Chaîne de caractères qui décrit précisément un ensemble 
+			de chaînes de caractères possibles.
+			\item Dans les commandes qui utilisent un motif (comme \cmd{grep}), le motif est presque toujours une expression régulière.
+		\end{itemize}
+	\end{block}
+\end{frame}	
+	
+\begin{frame}[fragile]{Expressions régulières (\emph{regex})}	
+	\framesubtitle{Bases}
+		\begin{itemize}
+			\item Décrit la suite de caractères qui doivent correspondre dans une chaîne.
+			\item Les alternatives sont séparées par une barre verticale: \cmd{a|b} reconnaît tout
+			mot contenant 'a' ou 'b'.
+			\item Les parenthèses regroupent les expressions:
+			\begin{itemize}
+				\item \cmd{ab|cd} reconnaît tout mot contenant 'ab' ou 'cd'
+				\item \cmd{a(b|c)d} reconnaît tout mot contenant 'abd' ou 'acd'.
+			\end{itemize}
+		\end{itemize}
+		
+		\begin{alertblock}{Attention aux caractères interprétés par le shell}
+			Les parenthèses et les barres verticales sont interprétées par le shell.
+			Il faut les échapper pour les utiliser dans des regex. Pour exploiter le motif 
+			\cmd{a(b|c)d} avec grep, il faudra écrire:
+			\begin{center}
+				\cmd{grep 'a\textbackslash(b\textbackslash|c\textbackslash)d'}
+			\end{center}
+		\end{alertblock}
 \end{frame}
 
+\begin{frame}[fragile]{Expressions régulières (\emph{regex})}	
+	\framesubtitle{Caractères}
+		Chaque caractère de la chaîne à reconnaître doit être spécifié, soit en donnant sa valeur 
+		directement ou en donnant sa classe.
+		\begin{itemize}
+			\item	\cmd{abcd} : la	suite 'abcd'.
+			\item	\cmd{[ab]bcd} : soit a, soit b suivi de bcd. Les crochets définissent une 
+			classe de caractères acceptables pour un caractère donné.
+			\item	\cmd{[a-z]bcd} : on peut utiliser des intervalles dans les classes.
+			\item	\cmd{a.b} : trois caractères commençant par a et finissant par b. 
+			Le point correspond à n'importe quel caractère.
+			\item	\cmd{[:alnum:]} : tout caractère alphanumérique
+			\item	\cmd{[:digit:]} : tout chiffre
+			\item	\cmd{[:space:]} : tout espace
+		\end{itemize}
+\end{frame}
+
+\begin{frame}[fragile]{Expressions régulières (\emph{regex})}	
+	\framesubtitle{Quantificateurs et prédicats}
+		Il représentent le nombre de répétitions d'une expression et ajoutent des contraintes sur
+		sa position dans la chaîne.
+
+		\begin{itemize}
+			\item	\cmd{expr*} : le motif \cmd{expr} répété 0 ou plusieurs fois.
+			\item   \cmd{expr+} : le motif \cmd{expr} répété 1 ou plusieurs fois.
+			\item	\cmd{expr?} : le motif \cmd{expr} répété 0 ou une fois.
+			\item	\verb+^expr+ : le motif \cmd{expr} en début de ligne.
+			\item	\cmd{expr\$} : le motif \cmd{expr} en fin de ligne.
+		\end{itemize}
+\end{frame}
+
+\begin{frame}[fragile]{\cmd{grep} et expressions régulières}
+	\begin{exampleblock}{Trouver tous les mots commençant par ab}
+		\verb+grep '^ab' /usr/share/dict/words+
+	\end{exampleblock}
+	
+	\begin{exampleblock}{Trouver tous les mots de quatre lettres commençant par g et finissant par t}
+		\verb+grep '^g..t$' /usr/share/dict/words+
+	\end{exampleblock}
+	
+	\begin{exampleblock}{Trouver tous les mots commençant par g et finissant par t}
+		\verb,grep '^g.\+t$' /usr/share/dict/words,
+	\end{exampleblock}
+	
+	\begin{alertblock}{C'est très pratique...}
+		...pour les mots croisés!
+	\end{alertblock}
+\end{frame}
+			
 \subsection{Identifier des fichiers}
 
 \begin{frame}[fragile]{\cmd{file}}
+	\begin{block}{}
+		\begin{description}
+			\item[\cmd{file}] identifie la nature des données d'un fichier.
+		\end{description}
+	\end{block}
+
+	\begin{beamercolorbox}[rounded=true,shadow=true]{terminal}
+	\begin{Verbatim}
+$ file /usr/lib/libreoffice/program/intro.png
+/usr/lib/libreoffice/program/intro.png: PNG image data, 661 x 169, 8-bit/color RGBA, interlaced
+
+$ file /bin/bash 
+/bin/bash: ELF 64-bit LSB shared object, x86-64, version 1 (SYSV), dynamically linked, 
+interpreter /lib64/ld-linux-x86-64.so.2, for GNU/Linux 3.2.0,
+BuildID[sha1]=b636f50d85c3cca7cf2518030446660c1d90d660, stripped
+	\end{Verbatim}
+	\end{beamercolorbox}
+	
+	\begin{block}{Remarque}
+		\cmd{file} fonctionne en analysant réellement le contenu du fichier, il ne se sert pas de
+		l'extension.
+	\end{block}
 \end{frame}
 
 \subsection{Manipuler des fichiers}
 
 \begin{frame}[fragile]{Un peu de manipulation de fichiers}
-	%% cut
-	%% sort
-	%% wc
-	%% diff
+	Il existe de nombreuses commandes de manipulation de fichiers utiles:
+	\begin{description}
+		 \item[\cmd{wc}] Compte les lignes, mots, etc. d'un fichier
+		 \item[\cmd{sort}] Trie les lignes d'un fichier
+		 \item[\cmd{uniq}] Supprime les doublons adjacents d'un fichier
+		 \item[\cmd{tr}] Transforme les caractères d'un fichier
+		 \item[\cmd{diff}] Compare deux fichiers et affiche les différences
+		 \item[\cmd{cut}] Découpe un fichier en champs
+		 \item[\cmd{sed}] Édite un fichier à la volée
+	\end{description}
+\end{frame}
+
+\begin{frame}[fragile]{\cmd{tr}}
+	\begin{block}{}
+		\begin{description}
+			\item[\cmd{tr}] Transforme des caractères entre deux ensembles
+		\end{description}
+	\end{block}
+
+	\begin{beamercolorbox}[rounded=true,shadow=true]{terminal}
+	\begin{Verbatim}
+$ cd ~/api ; echo 'The quick brown fox jumps over the lazy dog' > file.txt
+	\end{Verbatim}
+	\end{beamercolorbox}
+	
+	\begin{columns}
+		\begin{column}{.45\textwidth}
+
+			Un peu de cryptographie...
+
+			\begin{beamercolorbox}[rounded=true,shadow=true]{terminal}
+			\begin{Verbatim}
+$ \textcolor{yellow}{tr 'a-z' 'b-za' < file.txt}
+Tif rvjdl cspxo gpy kvnqt pwfs uif mbaz eph
+			\end{Verbatim}
+			\end{beamercolorbox}
+
+			Passage en capitales...
+
+			\begin{beamercolorbox}[rounded=true,shadow=true]{terminal}
+			\begin{Verbatim}					
+$ \textcolor{yellow}{tr [:lower:] [:upper:] < file.txt}
+THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG
+			\end{Verbatim}
+			\end{beamercolorbox}
+		\end{column}
+		
+		\begin{column}{.45\textwidth}
+		
+			Séparons les mots...
+			
+			\begin{beamercolorbox}[rounded=true,shadow=true]{terminal}
+			\begin{Verbatim}
+$ \textcolor{yellow}{tr [:blank:] '\textbackslash{}n' < file.txt}
+The
+quick
+brown
+fox
+jumps
+over
+the
+lazy
+dog
+			\end{Verbatim}
+			\end{beamercolorbox}					
+		\end{column}		
+	\end{columns}
+	
+	\begin{alertblock}{Séquences d'échappement}
+		Interprétées par le shell comme des caractères spéciaux: \cmd{\textbackslash{}n} est un retour à la ligne, \cmd{\textbackslash{}t} une
+		tabulation...
+	\end{alertblock}
+\end{frame}
+
+\begin{frame}[fragile]{\cmd{cut}}
+	\begin{block}{}
+		\begin{description}
+			\item[\cmd{cut}] Supprime des sections de chaque ligne d'un fichier.
+		\end{description}
+	\end{block}
+	
+	\begin{columns}
+		\begin{column}{.45\textwidth}
+
+			On garde les caractères 5 à 9...
+			\begin{beamercolorbox}[rounded=true,shadow=true]{terminal}
+			\begin{Verbatim}
+$ \textcolor{yellow}{cut -c 5-9 file.txt }
+quick
+			\end{Verbatim}
+			\end{beamercolorbox}
+
+		\end{column}
+		
+		\begin{column}{.45\textwidth}
+		
+			On garde les champs 3 et 5...
+			\begin{beamercolorbox}[rounded=true,shadow=true]{terminal}
+			\begin{Verbatim}					
+$ \textcolor{yellow}{cut -f 3,5 -d' ' file.txt}
+brown jumps
+			\end{Verbatim}
+			\end{beamercolorbox}
+		\end{column}		
+	\end{columns}
+	
+	\begin{alertblock}{Délimiteur}
+		Le délimiteur de champs est par défaut la tabulation. L'option \cmd{-d} permet de le changer.
+	\end{alertblock}
+\end{frame}
+
+\begin{frame}[fragile]{\cmd{sed}}
+	\begin{block}{}
+		\begin{description}
+			\item[\cmd{sed}] (\emph{Stream EDitor}) Édite le fichier ligne par ligne à la volée. 
+		\end{description}
+	\end{block}
+	
+	Remplaçons \emph{brown} par \emph{yellow}...
+	
+	\begin{beamercolorbox}[rounded=true,shadow=true]{terminal}
+	\begin{Verbatim}
+$ \textcolor{yellow}{sed 's/brown/yellow/g' file.txt }
+The quick yellow fox jumps over the lazy dog
+	\end{Verbatim}
+	\end{beamercolorbox}
+	
+	\begin{itemize}
+		\item \cmd{s} est la commande de remplacement. Elle prend deux paramètres:
+			\begin{itemize}
+				\item le motif à rechercher (c'est une regex)
+				\item le texte à substituer aux correspondances
+			\end{itemize}
+		\item \cmd{g} indique que le remplacement affecte toutes les occurrences.
+		\item Le séparateur est le caractère qui suit directement la commande \cmd{s}.
+		On aurait pu utiliser un autre caractère que ``/''.
+	\end{itemize}
+	
+	\begin{alertblock}{RTFM}
+		\cmd{sed} est une commande très puissante mais très complexe. Lisez le man.
+	\end{alertblock}
 \end{frame}
 
 \subsection{Combiner les commandes: les pipes}
-\begin{frame}[fragile]{Pipes}
+\begin{frame}[fragile]{Les Pipes}
+	\framesubtitle{Généralités}
+	\begin{alertblock}{KISS (Keep It Simple, Stupid)}
+		Les commandes, aussi complexes qu'elles soient, sont chacune spécialisées dans une 
+		fonction spécifique. C'est la philosophie générale des commandes Unix: ne faire qu'une 
+		chose, mais la faire bien.
+	\end{alertblock}
+
+	\begin{block}{Les pipes (ou tubes)}
+		\begin{itemize}
+			\item Connectent la sortie standard d'une commande à l'entrée standard d'une autre.
+			\item Permettent de chaîner des commandes pour construire des traitements complexes.
+		\end{itemize}
+	\end{block}
+\end{frame}
+
+\begin{frame}[fragile]{Les Pipes}
+	\framesubtitle{Comment ça marche?}
+
+	Supposons qu'on veuille voir le listing complet des fichiers du système. On peut 
+	exécuter ``\cmd{ls -lR /}'' mais la sortie est trop grande et on ne pourra pas tout voir...
+	
+	On peut utiliser les services de \cmd{less} pour paginer la sortie.
+	
+	Il suffit de taper: 
+	\begin{exampleblock}{}
+		\cmd{ls -lR / | less}
+	\end{exampleblock}
+	
+	Le symbole ``|'' représente le pipe entre les deux commandes.	
+	
+\end{frame}
+
+\begin{frame}[fragile]{Les Pipes}
+	\framesubtitle{Remarques}
+	
+	\begin{itemize}
+		\item Les pipes ne sont pas de taille infinie. Les commandes qui produisent 
+		les données (ici \cmd{ls}) attendent lorsqu'ils sont pleins. \textbf{On ne peut pas perdre
+		de données dans un pipe.}
+		\item Si on arrête le consommateur (ici \cmd{less}), le producteur se termine également 
+		par fermeture de son fichier de sortie standard.
+		\item De même, la fin du producteur entraine la fermeture de l'entrée standard du
+		consommateur et donc son arrêt.
+	\end{itemize}
 \end{frame}
 
-\begin{frame}[fragile]{\cmd{tee}}
+\begin{frame}[fragile]{Les Pipes}
+	\framesubtitle{La commande \cmd{tee}}
+	
+	On peut vouloir enregistrer la sortie d'une commande dans un fichier en même temps
+	qu'on la transmet à une autre commande par un pipe.
+	
+	\begin{block}{\cmd{tee}}
+		\begin{description}
+			\item[\cmd{tee}] lit son entrée standard, l'enregistre dans un fichier et 
+			la recopie sur sa sortie standard.
+		\end{description}
+	\end{block}
+	
+	\begin{exampleblock}{Enregistrer la sortie de \cmd{ls -lR} pendant qu'on compte les fichiers}
+		\verb+ls -lR ~ | tee listing.txt | wc -l+
+	\end{exampleblock}
+\end{frame}
+
+\begin{frame}[fragile]{Les Pipes}
+	\framesubtitle{A vous de jouer!}
+	
+	\begin{itemize}
+		\item Téléchargez ``Vingt mille lieues sous les mers'' de Jules VERNE depuis le site du 
+		projet Gutemberg:
+	\end{itemize}
+	\begin{exampleblock}{}
+		\cmd{wget http://www.gutenberg.org/files/54873/54873-0.txt}
+	\end{exampleblock}
+	
+	\begin{exampleblock}{Combien de mots différents sont utilisés par l'auteur?}
+		Il faut: lire le fichier, le transformer pour qu'il ait un mot par ligne, trier les mots,
+		éliminer les mots en double ou plus, compter le nombre de lignes.
+	\end{exampleblock}
+	
+	\begin{exampleblock}{Combien de fois le Capitaine Nemo est-il nommé?}
+		L'approche est similaire, mais il faut aussi ne garder que le mot ``Nemo''.
+	\end{exampleblock}
 \end{frame}
 
 \subsection{Processus et jobs}
 
 \begin{frame}[fragile]{Les processus}
+	\framesubtitle{Définition}
+	\begin{block}{Qu'est-ce que c'est?}
+		\begin{itemize}
+			\item Un processus est un programme en cours d'exécution.
+			\item Un programme est un exécutable binaire stocké sur le disque dans un fichier
+			\item A son exécution, le programme est copié en mémoire par le système et 
+			devient un processus.
+			\item De nombreux processus s'exécutent en même temps: c'est une des fonctions 
+			principales du système de partager le processeur et la mémoire entre ceux-ci.
+		\end{itemize}
+	\end{block}
 \end{frame}
 
-\begin{frame}[fragile]{Mettre fin à des processus}
+\begin{frame}[fragile]{Les processus}
+	\framesubtitle{Hierarchie des processus}
+	\begin{block}{PID}
+		Les processus sont identifiés par in nombre: l'identifiant du processus, 
+		ou \emph{Process ID (PID)}.
+	\end{block}
+	
+	\begin{block}{Arborescence des processus}
+		Un processus a un père unique: c'est le processus qui l'a créé. L'ID du
+		processus père est le \emph{Parent Process ID (PPID)}.
+	\end{block}
+	
+	\begin{block}{Processus initial}
+		Le premier processus est exécuté directement par le noyau au démarrage. Il s'agit du
+		processus \cmd{init} (\cmd{systemd} sur Ubuntu). Son PID est 0 et il est l'ancêtre de
+		tous les processus.	
+	\end{block}
+\end{frame}
+
+\begin{frame}[fragile]{Les processus}
+	\framesubtitle{État des processus}
+		A tout instant, un processus est dans l'un des états suivants:
+		
+		\begin{itemize}
+			\item R (Running): Processus éligible au processeur
+			\item S (Sleeping): Processus en attente d'un événement
+			\item D (Uninterruptible Sleep): Processus en attente d'une entrée / sortie
+			\item T (Stopped): Processus interrompu par un signal de contrôle
+			\item Z (Zombie): Terminé, en attente du processus père
+		\end{itemize}
+%	\begin{center}
+%	\begin{tabular}{|m{1cm}|m{3cm}|m{5.5cm}|}
+%			\hline
+%			\textbf{Lettre} & \textbf{Signification} & \textbf{Description} \\
+%			\hline\hline
+%			R & Running & Processus éligible au processeur \\
+%			\hline
+%			S & Sleeping & Processus en attente d'un événement \\
+%			\hline
+%			D & Uninterruptible Sleep & Processus en attente d'une entrée / sortie \\
+%			\hline
+%			T & Stopped & Processus interrompu par un signal de contrôle \\
+%			\hline
+%			Z & Zombie & Terminé, en attente du processus père \\
+%			\hline
+%	\end{tabular}
+%	\end{center}
+\end{frame}
+
+\begin{frame}[fragile]{Les processus}
+	\framesubtitle{Voir les processus}
+
+	\begin{block}{\cmd{ps}}
+		\begin{description}
+			\item[\cmd{ps}] affiche les processus en cours d'exécution et les informations associées
+		\end{description}
+	\end{block}
+
+	\cmd{ps} seul affiche tous les processus de l'utilisateur associé au terminal:
+	\begin{beamercolorbox}[rounded=true,shadow=true]{terminal}
+	\begin{Verbatim}
+$ ps 
+  PID TTY          TIME CMD
+10923 pts/2    00:00:01 bash
+12472 pts/2    00:00:00 cat
+12622 pts/2    00:00:00 ps
+	\end{Verbatim}
+	\end{beamercolorbox}	
+	
+	Il y a ici trois processus. Les champs s'interprètent comme suit:
+	\begin{description}
+		\item[PID] Le PID
+		\item[TTY] Le terminal de contrôle
+		\item[TIME] Le temps réellement passé à utiliser le processeur
+		\item[CMD] La commande exécutée
+	\end{description}
+\end{frame}
+
+\begin{frame}[fragile]{Les processus}
+	\framesubtitle{Voir les processus}
+	La commande ``\cmd{ps a}'' affiche tous les processus de l'utilisateur.
+	\begin{beamercolorbox}[rounded=true,shadow=true]{terminal}
+	\begin{Verbatim}			
+$ ps a
+  PID TTY      STAT   TIME COMMAND
+  986 tty1     Ssl+   0:00 /usr/lib/gdm3/gdm-x-session --run-script env GNOME_S
+  988 tty1     Sl+   21:46 /usr/lib/xorg/Xorg vt1 -displayfd 3 -auth /run/user/
+  999 tty1     Sl+    0:00 /usr/lib/gnome-session/gnome-session-binary --sessio
+ 1163 tty1     Sl+   41:15 /usr/bin/gnome-shell
+ 1208 tty1     Sl    14:18 ibus-daemon --xim --panel disable
+ 1212 tty1     Sl     0:00 /usr/lib/ibus/ibus-dconf
+ [...]
+ 	\end{Verbatim}
+	\end{beamercolorbox}	
+
+	\medskip
+	La commande ``\cmd{ps aux}'' affiche tous les processus de tous les utilisateurs.
+\end{frame}
+
+\begin{frame}[fragile]{Les processus}
+	\framesubtitle{Voir les processus}
+	\begin{block}{\cmd{pstree}}
+		La commande \cmd{pstree} affiche l'arbre des processus en cours d'exécution/
+	\end{block}
+	
+	\begin{beamercolorbox}[rounded=true,shadow=true]{terminal}
+	\begin{Verbatim}			
+$ pstree -A
+systemd-+-ModemManager---2*[{ModemManager}]
+        |-NetworkManager-+-dhclient
+        |                `-2*[{NetworkManager}]
+        |-2*[VBoxClient---VBoxClient]
+        |-2*[VBoxClient---VBoxClient---{VBoxClient}]
+        |-VBoxClient---VBoxClient---2*[{VBoxClient}]
+        |-VBoxService---7*[{VBoxService}]
+        |-accounts-daemon---2*[{accounts-daemon}]
+        |-acpid
+        |-avahi-daemon---avahi-daemon
+        |-boltd---2*[{boltd}]
+        |-colord---2*[{colord}]
+        |-cron	
+[...]
+	\end{Verbatim}
+	\end{beamercolorbox}	
+	
+	\begin{alertblock}{}
+		\cmd{systemd} est bien l'ancêtre de tout les processus...
+	\end{alertblock}
+\end{frame}
+
+\begin{frame}[fragile]{Les processus}
+	\framesubtitle{Suivre les processus en temps réel}
+	
+	\begin{block}{\cmd{top}, \cmd{htop}}
+		\begin{itemize}
+			\item \cmd{top} affiche l'évolution des processus en temps réel. Quitter avec ``q''.
+			\item \cmd{htop} fait la même chose avec une interface plus moderne.
+		\end{itemize}
+	
+		Ces deux commandes montrent aussi en temps réel l'utilisation des processeurs et 
+		l'occupation de la mémoire. Elles permettent de suivre les performances du système.
+	\end{block}
+\end{frame}
+
+\begin{frame}[fragile]{Les processus}
+	\framesubtitle{Les signaux}
+	
+	\begin{block}{Signal}
+		Le noyau peut transmettre des signaux aux processus pour des raisons diverses.
+		Les processus peuvent intercepter certains de ces signaux. S'il ne le font pas, alors
+		les signaux ont des effets par défaut sur le processus.
+	\end{block}
+	
+	\begin{block}{Transmission de signaux par le clavier}
+		Quand un processus est exécuté au premier plan, certaines combinaisons de touches
+		provoquent la transmission de signaux vers celui-ci.
+		\begin{itemize}
+			\item \cmd{CTRL+C} envoie SIGINT. Met fin au processus avec potentielle perte de données.
+			\item \cmd{CTRL+Z} envoie SIGTSTP. Stoppe le processus et rend la main au shell.
+			\item \cmd{CTRL+]} envoie SIGQUIT. Met fin au processus plus brutalement que \cmd{CTRL+C}.
+		\end{itemize}
+	\end{block}
+
 \end{frame}
 
-\begin{frame}[fragile]{Terminaux}
+\begin{frame}[fragile]{Les processus}
+	\framesubtitle{Effet des signaux}
+
+	\begin{exampleblock}{CTRL+C vs. CTRL+]}
+		\begin{itemize}
+			\item Installez \cmd{sl}: \cmd{sudo apt install sl}
+			\item Lancer sl. Le train passe.
+			\item Observez la différence entre CTRL+C et CTRL+] pendant le passage du train.
+		\end{itemize}
+	\end{exampleblock}	
 \end{frame}
 
 \begin{frame}[fragile]{Exécution en arrière plan}
+	Une commande exécutée en arrière plan est dite \emph{détachée} du terminal.
+	
+	\begin{block}{Exécution en arrière plan}
+		Faire suivre la commande de ``\&''. La commande se lance et rend la main au shell.
+		
+		``\cmd{gedit \&}'' lance l'éditeur de texte gedit et rend la main.
+	\end{block}
+	
+	\begin{block}{Arrière plan et signaux}
+		\cmd{CTRL+Z} suspend le processus attaché au terminal.
+		
+		``\cmd{bg}'' le relance en arrière plan, comme si on l'avait exécuté avec ``\&''.
+	\end{block}
+
+	\begin{beamercolorbox}[rounded=true,shadow=true]{terminal}
+	\begin{Verbatim}				
+$ xeyes
+^Z
+[1]+  Arrêté                xeyes
+$ \textcolor{yellow}{bg}
+[1]+ xeyes &
+$
+	\end{Verbatim}
+	\end{beamercolorbox}		
+\end{frame}
+
+
+\begin{frame}[fragile]{Mettre fin à des processus}
+
+	\begin{block}{\cmd{kill}}
+		Pour mettre fin à un processus, la commande à utiliser est \cmd{kill} suivie du PID du processus à tuer.
+	\end{block}
+	
+	\begin{beamercolorbox}[rounded=true,shadow=true]{terminal}
+	\begin{Verbatim}				
+$ ps
+  PID TTY          TIME CMD
+13154 pts/5    00:00:00 bash
+\textcolor{yellow}{13162} pts/5    00:00:01 xeyes
+13178 pts/5    00:00:00 ps
+$ kill \textcolor{yellow}{13162}
+$ 
+[1]+  Complété              xeyes
+$
+	\end{Verbatim}
+	\end{beamercolorbox}		
+	
+	\begin{alertblock}{Processus récalcitrants}
+		Par défaut, \cmd{kill} envoie \cmd{SIGTERM} au processus. Si le processus ne se termine pas avec 
+		ce signal,
+		
+		``\cmd{kill -KILL}'' (ou ``\cmd{kill -9}'') suivie du PID y mettra fin systématiquement mais avec plus de 
+		risques de perte de données.
+	\end{alertblock}	
+	
 \end{frame}
 
 \begin{frame}[fragile]{Gestion des jobs}
+
+	\begin{itemize}
+		\item \cmd{jobs} affiche la liste des processus en arrière plan
+		\item \cmd{fg} ramène le processus indiquer en avant plan
+		\item \cmd{bg} passe le dernier processus arrêté en arrière plan
+		\item \cmd{kill} peut aussi s'utiliser avec un numéro de job.
+	\end{itemize}
+	\begin{beamercolorbox}[rounded=true,shadow=true]{terminal}
+	\begin{Verbatim}				
+$ xeyes &
+[1] 13507
+$ jobs
+[\textcolor{yellow}{1}]+  En cours d'exécution   xeyes &
+$ kill \textcolor{yellow}{%1}
+$ 
+[1]+  Complété              xeyes
+$
+	\end{Verbatim}
+	\end{beamercolorbox}	
 \end{frame}
 
 \subsection{Substitution de commandes}
 
 \begin{frame}[fragile]{Substitution de commandes}
+
+	Consiste à récupérer la sortie d'une commande pour remplacer le texte de la commande.
+	
+	\begin{block}{Syntaxe de la substitution de commande}
+		Deux syntaxes sont possibles:
+			\begin{itemize}
+				\item \cmd{\$( commande )}
+				\item \cmd{` commande `}
+			\end{itemize}
+	\end{block}
+
+	\begin{beamercolorbox}[rounded=true,shadow=true]{terminal}
+	\begin{Verbatim}				
+$ echo Nous sommes le \textcolor{yellow}{$(date +'%A %d %B %Y').}
+Nous sommes le mardi 22 janvier 2019.
+	\end{Verbatim}
+	\end{beamercolorbox}			
+
 \end{frame}
 
 \subsection{L'historique}
 \begin{frame}[fragile]{Rappeler des commandes}
-	%% Historique + manipulation
-	%% Où est l'historique (bases)
+	\cmd{bash} maintient un historique des commandes et permet de les rappeler pour ne pas avoir à les retaper. 
+	L'historique est stocké 
+	dans le fichier \verb+~/.bash\_history+.
+	
+	\begin{itemize}
+		\item La commande ``\cmd{history}'' affiche l'historique.
+		\item Les touches haut et bas permettent de naviguer dans l'historique.
+		\item Le point d'exclamation suivi d'une chaîne rappelle la dernière commande commençant par cette chaîne.
+		\item La combinaison \cmd{CTRL+R} entre en mode recherche dans l'historique. \cmd{CTRL+R} recherche à nouveau.
+	\end{itemize}
+	
+	\begin{block}{Astuce}
+		La commande \cmd{!!} relance la dernière commande. On peut l'utiliser avec \cmd{sudo} pour relancer une commande
+		en superutilisateur:
+		\begin{center}
+			\cmd{sudo !!}		
+		\end{center}
+	\end{block}	
 \end{frame}
-
-\begin{frame}[fragile]{Rechercher dans l'historique}
-\end{frame}
-