Modif slide conclusion

Makefile

@@ -0,0 +1,20 @@
+TARGET=cours_git
+
+all: pdf
+
+# If there is no bibliography comment the bibtext dependency
+pdf: #bibtex
+	pdflatex $(TARGET).tex
+	pdflatex $(TARGET).tex
+
+pdf-lazy:
+	pdflatex $(TARGET).tex
+
+bibtex: pdf-lazy
+	bibtex $(TARGET)
+
+clean:
+	rm -f *.dvi *.aux *.bbl *.blg $(TARGET).ps *.toc *.ind *.out *.brf *.ilg *.idx *.log *.bcf *.nav *.run.xml *.snm *.vrb *.backup tex/*.backup *~
+
+clean_all: clean
+	rm -f $(TARGET).pdf

cours_git.tex

@@ -13,8 +13,7 @@
 % Put table of contents at the beginning of each section
 \AtBeginSection[]
 {
-  \begin{frame}
-    \frametitle{}
+  \begin{frame}[noframenumbering]{}
     \tableofcontents[currentsection]
   \end{frame}
 }
@@ -35,25 +34,26 @@
 \section{Prérequis}
 
 \begin{frame}[fragile]
-\frametitle{Prerequis}
+\frametitle{Prérequis}
+Prérequis pour suivre ce cours:
 	\begin{itemize}
 		\item Savoir lire la signature d'une commande \verb#command -a [-b] [-c | -d] --long-arg PARAM1 PARAMS2...#
-		\item Savoir lire. Git affiche des messages et il faut les lire.
+		\item Savoir lire des messages affichés dans la console. Git affiche plein de messages utiles, il faut les lire.
 	\end{itemize}
 \end{frame}
 
 \section{Présentation de git}
 \begin{frame}
-\frametitle{C'est quoi git}
-	\begin{columns}[T]
+\frametitle{Qu'est-ce que c'est?}
+	\begin{columns}[c]
 		\column{0.5\textwidth}
 			\begin{block}{}
 				Git est un logiciel de versioning.
 			\end{block}
-
-			Crée par notre modèle spirituel, Linus Torvalds en 2005.
-
-			Le logiciel de versioning qui était utilisé pour le dév du noyau Linux est devenu propriétaire, donc il en a développé un autre.
+			\begin{itemize}
+				\item Crée par notre modèle spirituel, Linus Torvalds en 2005.
+				\item Le logiciel de versioning utilisé pour le noyau Linux est devenu propriétaire, donc il en a développé un autre.
+			\end{itemize}
 
 		\column{0.5\textwidth}
 			\begin{center}
@@ -63,20 +63,27 @@
 \end{frame}
 
 \begin{frame}
-\frametitle{Ça permet de faire quoi}
+\frametitle{Ça permet de faire quoi?}
 	\begin{itemize}
 		\item Ne pas perdre son travail
 		\item Pouvoir inspecter des versions spécifiques de son travail
 		\item Travailler à plusieurs
-		\item Pouvoir donner la faute d'un bug à un collègue (on sait qui a codé quoi)
+		\item Pouvoir rejeter la faute d'un bug sur un collègue (on sait qui a codé quoi)
 	\end{itemize}
 	
-	Git n'est pas un processus qui tourne en permanence: chaque commande est un processus rapide. Tout est enregistré dans des fichiers: il est possible d'interrompre le travail à tout moment.
+	\vspace{2\baselineskip}
+	
+	\begin{itemize}
+		\item Git n'est pas un logiciel qui tourne en permanence: chaque commande est un petit processus.
+		\item Tout est enregistré dans des fichiers
+		\begin{itemize}
+			\item Possible d'interrompre le travail à tout moment
+		\end{itemize}
+	\end{itemize}
 
 	\begin{alertblock}{}
 		Git fonctionne très mal avec les fichiers binaires
 	\end{alertblock}
-
 \end{frame}
 
 \section{Le commit}
@@ -91,27 +98,27 @@
 		\item Un ensemble de changements (sur un ou plusieurs fichiers)
 		\item Une date
 		\item Un auteur
-		\item \textbf{Un message}
-		\item Un pointeur vers sont parent
+		\item \textbf{Un message}: il peut être sur plusieurs lignes!
+		\item \textbf{Un pointeur vers son parent}
 		\item \textbf{Un hash unique} basé sur tout ça (plus ou moins).
 	\end{itemize}
 
 	\begin{alertblock}{}
-		Les commit doivent raconter une histoire!
+		Les commits doivent raconter une histoire!
 	\end{alertblock}
 \end{frame}
 
 \begin{frame}
 \frametitle{Un historique git}
 	\begin{columns}[c]
-		\column{0.5\textwidth}
+		\column{0.3\textwidth}
 			\begin{center}
 				\includegraphics[height=0.7\textheight]{img/gitrepo}
 			\end{center}
-		\column{0.5\textwidth}
+		\column{0.7\textwidth}
 			\begin{itemize}
-				\item Un projet git c'est une suite de commits (et un pointeur sur le dernier).
-				\item Le contenu d'un fichier existe comme suite de modifications.
+				\item Historique git: suite de commits (+ pointeur sur dernier).
+				\item Un fichier existe seulement comme suite de modifications.
 				\item Un commit non pointé est un commit perdu.
 			\end{itemize}
 	\end{columns}
@@ -127,6 +134,7 @@
 		\item Créer un commit: \verb|git commit|
 		\item Voir l'historique: \verb|git log|
 		\item Voir le log en plus joli: \verb|git log --all --graph --decorate --oneline|
+		\item Afficher un commit plus en détail: \verb|git show COMMIT_HASH|
 	\end{itemize}
 \end{frame}
 
@@ -136,22 +144,30 @@
 \frametitle{Ça sert à quoi?}
 	\begin{itemize}
 		\item Travailler à plusieurs.
-		\item Faire plusieurs choses au même temps (nouvelle fonctionnalité, correction de bugs).
-		\item Essayer des nouvelles choses en parallèle sans impacter le projet: modifications indépendantes sur une même base.
-		\item Il est très facile de basculer de l'une à l'autre: git modifie les fichiers automatiquement.
+		\item Faire plusieurs choses en même temps (nouvelle fonctionnalité, correction de bugs, ...).
+		\item Essayer de nouvelles choses en parallèle sans impacter le projet: modifications indépendantes sur une même base.
+	\end{itemize}
+	
+	\vspace{2\baselineskip}
+	
+	\begin{itemize}
+		\item Très facile de basculer de l'une à l'autre: git modifie les fichiers automatiquement.
 	\end{itemize}
 \end{frame}
 
 \begin{frame}
 \frametitle{C'est quoi?}
 	\begin{columns}[c]
-		\column{0.5\textwidth}
+		\column{0.4\textwidth}
 			\begin{center}
 				\includegraphics[height=0.7\textheight]{img/branches}
 			\end{center}
-		\column{0.5\textwidth}
+		\column{0.6\textwidth}
+			\begin{itemize}
+				\item Branche: pointeur sur un commit
+			\end{itemize}
+			\vspace{\baselineskip}
 			\begin{itemize}
-				\item Littéralement un pointeur sur un commit
 				\item Une histoire qui diverge à partir d'un certain commit
 				\item En se positionnant sur un pointeur ou sur un autre on voit des choses différentes
 			\end{itemize}
@@ -178,7 +194,7 @@
 
 \begin{frame}
 \frametitle{Les conflits de merge :(}
-	Parfois il est impossible de fusionner proprement: si les deux branches ont modifié le même bout de code.
+	Parfois impossible de fusionner automatiquement: si les deux branches ont modifié le même bout de code.
 
 	\begin{block}{}
 		Le commit de merge peut introduire des modifications: utilisé pour résoudre les conflits
@@ -188,7 +204,7 @@
 	\begin{itemize}
 		\item Git affiche un message d'erreur en cas de conflit
 		\item Les conflits sont clairement délimités dans les fichiers à l'aide de chevrons
-		\item Git présente les deux versions du bout de code et demande à l'humain de choisir la version finale (en modifiant le code et supprimant les chevrons)
+		\item Git présente les deux versions du bout de code et demande à l'humain de choisir la version finale (en modifiant le code et en supprimant les chevrons)
 		\item Il est aussi possible d'abandonner le merge
 	\end{itemize}
 
@@ -197,37 +213,53 @@
 	\end{block}
 \end{frame}
 
+\begin{frame}{Le merge ``fast-forward''}
+	\begin{columns}
+	\column{0.5\textwidth}
+	\begin{center}
+		\includegraphics[width=\textwidth]{img/fast-forward}
+	\end{center}
+	
+	\column{0.5\textwidth}
+	\begin{itemize}
+		\item Quand il n'y a pas de modifications à fusionner
+		\item Le pointeur de branche est simplement modifié
+	\end{itemize}
+	\end{columns}
+\end{frame}
+
+
 \subsection*{Les commandes des branches}
 
 \begin{frame}[fragile]
 \frametitle{Les commandes des branches}
 	\begin{itemize}
-		\item Créer une branche avec comme base le commit courant: \verb|git branch NAME|
-		\item Bouger entre les branches: \verb|git checkout BRANCH|
+		\item Créer une branche avec comme base le commit courant: \verb|git branch NOM|
+		\item Créer une branche avec comme base un commit spécifique: \verb|git checkout -b BRANCHE COMMIT|
+		\item Bouger entre les branches: \verb|git checkout BRANCHE|
 		\item Fusionner une branche: \verb|git merge ORIGINE [DESTINATION]|
 		\item En cas de conflit:
 			\begin{itemize}
 				\item Modifier les fichiers à la main
 				\item \verb|git add FICHIERS...|
-				\item \verb|git commit| ou \verb|git merge --continue|
+				\item \verb|git commit|
 			\end{itemize}
-		\item Il est aussi possible d'abandonner la fusion pendant un conflit: \verb|git merge --abort|
+		\item Abandonner la fusion pendant un conflit: \verb|git merge --abort|
 	\end{itemize}
 \end{frame}
 
 \section{Dépôts distants (remotes)}
 \subsection{Explication}
 
-\begin{frame}
+\begin{frame}[fragile]
 \frametitle{Les dépôts distants}
 	Chaque développeur a toujours une \textit{copie intégrale} du projet.
 
-	Il est possible d'avoir une copie du projet sur un serveur pour mettre en commun le travail.
+	Il est possible d'avoir une telle copie du projet sur un serveur pour mettre en commun le travail.
 
 	\begin{block}{}
-		La copie d'un branche hébergée sur le serveur n'est qu'une branche. Elle peut être inspectée comme toute branche locale (il faut la récupérer avant).
+		Une copie de chaque branche du serveur est gardée en local pour pouvoir être inspectée (\verb|origin/branche|).
 	\end{block}
-
 \end{frame}
 
 \begin{frame}
@@ -245,32 +277,40 @@
 
 \begin{frame}
 \frametitle{Historique commun}
-	Sur git il est possible de modifier l'historique (réorganiser les commits, les modifier, ...). Même si on ne verra pas comment faire, il faut toujours retenir:
+	Sur git il est possible de modifier l'historique (réorganiser les commits, les modifier, ...). On ne verra pas comment faire, mais il faut toujours retenir:
 
 	\begin{alertblock}{}
-		Il ne faut jamais modifier l'historique commun!!!
+		\textbf{Il ne faut jamais modifier l'historique commun!!!}
 	\end{alertblock}
 	
-	Tout ce qui a été poussé sur un dépôt distant est commun.
+	\vspace{\baselineskip}
 	
-	Il ne faut modifier rien qui puisse être atteint à partir d'un commit présent sur le dépôt commun.
+	\begin{itemize}
+		\item Tout ce qui est sur le dépôt distant est commun.
+		\item Il ne faut rien modifier qui puisse être atteint à partir d'un commit présent sur le dépôt distant.
+	\end{itemize}
 \end{frame}
 
 \subsection{Les commandes}
 \begin{frame}[fragile]
-\frametitle{Les commande des remotes}
+\frametitle{Les commandes des remotes}
 	\begin{itemize}
-		\item Récupère les modifications de la branche remote sans les intégrer à la branche courante (= met à jour les branches \verb|origin/*|): \verb|git fetch|
-		\item Récupère les modifications de la branche remote et les ajoute dans la branche courante: \verb#git pull [ --merge | --rebase ]#
-		\item Pousse les modifications de la branche courante sur le remote: \verb|git push|.
+		\item Mettre à jour la copie locale de la branche remote (commande non-destructive): \verb|git fetch|
+		\item Récupérer les modifications de la branche remote et les ajoute dans la branche courante: \verb#git pull [ --merge | --rebase ]#
+		\item Pousser les modifications de la branche courante sur le remote: \verb|git push|.
 		\begin{itemize}
-			\item Dans le cas que la branche remote n'existe pas (elle va être crée): \verb|git push -u origin NAME|
+			\item Il faut avoir fait un pull avant
+			\item Dans le cas où la branche remote n'existe pas (elle sera créée): \verb|git push -u origin NOM|
 		\end{itemize}
 	\end{itemize}
 \end{frame}
 
 \subsection{Les techniques de pull}
 
+\begin{frame}[noframenumbering]{}
+	\tableofcontents[currentsection,currentsubsection]
+\end{frame}
+
 \begin{frame}
 \frametitle{Pull merge (default)}
 	\begin{columns}[T]
@@ -299,6 +339,25 @@
 	\end{columns}
 \end{frame}
 
+\begin{frame}[fragile]
+\frametitle{Merge vs Rebase}
+	\begin{itemize}
+		\item Merge: la résolution de tous les conflits est dans le commit de merge. Rebase: chaque commit est modifié pour résoudre ses conflits
+		\begin{itemize}
+			\item Rebase modifie directement les conflits (comme s'il n'y en avait pas eu) plutôt que d'ajouter un commit de ``solution''
+		\end{itemize}
+		\item Rebase: ``triche'' sur la façon de raconter l'historique
+		\item Rebase: historique propre
+		\begin{itemize}
+			\item Le seuls merge présents dans l'historique sont ceux qui signifient quelque chose (e.g. une nouvelle fonctionnalité ajoutée)
+		\end{itemize}
+	\end{itemize}
+	
+	\vspace{2\baselineskip}
+	Faire un pull rebase par défaut: \verb|git config [--global] pull.rebase true|
+\end{frame}
+
+
 \section{Pointeurs avancés}
 
 \begin{frame}[fragile]
@@ -308,12 +367,19 @@
 		\item Il pointe normalement sur la branche courante
 		\item \verb|git checkout COMMIT_HASH| permet de bouger HEAD à un autre point de l'histoire: les fichiers auront alors le contenu qu'ils avaient à ce moment là.
 	\end{itemize}
+	\vspace{2\baselineskip}
+	\begin{itemize}
+		\item Rappel: si un commit n'est pas pointé par quelque chose, il est détruit
+	\end{itemize}
+
 \end{frame}
 
 \begin{frame}[fragile]
 \frametitle{Le soft reset}
 	\verb|git reset COMMIT_HASH| permet de bouger la tête de la branche sur un commit particulier. Il n'y a plus rien qui pointe sur les commits plus récents, \textbf{ils sont alors oubliés}.
 	
+	\vspace{\baselineskip}
+	
 	Les fichiers ne sont par contre pas modifiés.
 \end{frame}
 
@@ -322,10 +388,30 @@
 	\verb|git reset --hard COMMIT_HASH| permet de bouger la tête de la branche sur un commit particulier, \textbf{en écrasant toutes les modifications faites depuis}.
 
 	\begin{block}{}
-		\verb|git reset --hard HEAD| supprime toutes les modifications faites depuis le dernier commit (donc juste les modifications pas enregistrées dans un commit).
+		\verb|git reset --hard HEAD| supprime toutes les modifications faites depuis le dernier commit (modifications non enregistrées dans un commit).
 	\end{block}
 \end{frame}
 
+\section{Conclusion}
+
+\begin{frame}{Utilitaires}
+	\begin{itemize}
+		\item Git bash: affichage d'informations sur le dépôt dans le terminal \url{https://github.com/magicmonty/bash-git-prompt}
+		\item gitk: Outil graphique
+		\item git-gui: Un autre outil graphique
+	\end{itemize}
+	
+\end{frame}
+
+\begin{frame}[fragile]{Pas vu dans ce cours}
+	\begin{itemize}
+		\item Rebase: comment modifier l'historique (très puissant et très dangereux)
+		\item Comment bouger les commits d'une branche à une autre
+		\item \verb|git reflog|: historique des actions effectuées
+		\item \verb|git bisect|: recherche interactive de bug par dichotomie
+	\end{itemize}
+\end{frame}
+
 \frame{\titlepage}
 
 \end{document}