\documentclass[10pt]{beamer}

\usepackage{ucs}
\usepackage[utf8]{inputenc}
\usepackage[french]{babel}
\usepackage[T1]{fontenc}
\usepackage{graphicx}

\title{Git c'est la vie}
\subtitle{Un cours sur cet outil magique qui s'appelle git}
\author{Francesco Bariatti}

% Put table of contents at the beginning of each section
\AtBeginSection[]
{
  \begin{frame}
    \frametitle{}
    \tableofcontents[currentsection]
  \end{frame}
}

\usetheme{CambridgeUS}
\usecolortheme{beaver}


\begin{document}

\frame{\titlepage}

\section{Prérequis}

\begin{frame}[fragile]
\frametitle{Prerequis}
	\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.
	\end{itemize}
\end{frame}

\section{Présentation de git}
\begin{frame}
\frametitle{C'est quoi git}
	\begin{columns}[T]
		\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.

		\column{0.5\textwidth}
			\begin{center}
				\includegraphics[scale=0.2]{img/linus}
			\end{center}
	\end{columns}
\end{frame}

\begin{frame}
\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)
	\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.

	\begin{alertblock}{}
		Git fonctionne très mal avec les fichiers binaires
	\end{alertblock}

\end{frame}

\section{Le commit}

\begin{frame}
	\begin{block}{}
		Le commit est l'entité de base de git.
	\end{block}

	Un commit c'est:
	\begin{itemize}
		\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 hash unique} basé sur tout ça (plus ou moins).
	\end{itemize}

	\begin{alertblock}{}
		Les commit doivent raconter une histoire!
	\end{alertblock}
\end{frame}

\begin{frame}
\frametitle{Un historique git}
	\begin{columns}[c]
		\column{0.5\textwidth}
			\begin{center}
				\includegraphics[height=0.7\textheight]{img/gitrepo}
			\end{center}
		\column{0.5\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 Un commit non pointé est un commit perdu.
			\end{itemize}
	\end{columns}
\end{frame}

\begin{frame}[fragile]
\frametitle{Des commandes!}
	\begin{itemize}
		\item Création d'un projet: \verb|git init DOSSIER| ou \verb|git clone URL [DOSSIER]|
		\item Visualisation de l'état (est-ce qu'il y a eu des modifications?): \verb|git status|
		\item Visualisation des modifications: \verb|git diff|
		\item Ajouter des modifications au prochain commit: \verb|git add FICHIERS...|
		\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|
	\end{itemize}
\end{frame}

\section{Les branches}
\subsection{Le concept des branches}
\begin{frame}
\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.
	\end{itemize}
\end{frame}

\begin{frame}
\frametitle{C'est quoi?}
	\begin{columns}[c]
		\column{0.5\textwidth}
			\begin{center}
				\includegraphics[height=0.7\textheight]{img/branches}
			\end{center}
		\column{0.5\textwidth}
			\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}
	\end{columns}
\end{frame}

\subsection{Le merge}
\begin{frame}
\frametitle{Le merge}
	\begin{columns}[c]
		\column{0.5\textwidth}
			\begin{center}
				\includegraphics[height=0.7\textheight]{img/merge}
			\end{center}
		\column{0.5\textwidth}
			\begin{itemize}
				\item Intègre les changements d'une branche dans une autre
				\item Création d'un commit de merge: commit spécial avec deux parents
				\item À partir de la branche de destination (Branche1 dans l'exemple) il est possible de voir l'historique des deux branches.
				\item Git fusionne intelligemment les modifications des deux branches
			\end{itemize}
	\end{columns}
\end{frame}

\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.

	\begin{block}{}
		Le commit de merge peut introduire des modifications: utilisé pour résoudre les conflits
	\end{block}


	\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'humaine de choisir la version finale (en modifiant le code et supprimant les chevrons)
		\item Il est aussi possible d'abandonner le merge
	\end{itemize}

	\begin{block}{}
		En faisant des petits commits, il est plus simple de repérer quelle modification a introduit le conflit.
	\end{block}
\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 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|
			\end{itemize}
		\item Il est aussi possible d'abandonner la fusion pendant un conflit: \verb|git merge --abort|
	\end{itemize}
\end{frame}

\section{Dépôts distants (remotes)}
\begin{frame}
\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.

	\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).
	\end{block}

\end{frame}

\begin{frame}
	\begin{columns}[T]
		\column{0.5\textwidth}
			\begin{center}
				\includegraphics[height=0.7\textheight]{img/remotes_non_diverging}
			\end{center}
		\column{0.5\textwidth}
			\begin{center}
				\includegraphics[height=0.7\textheight]{img/remotes_diverging}
			\end{center}
	\end{columns}
\end{frame}





\end{document}
