SEES: comparison versionControl/vcs.tex

equal deleted inserted replaced

-:1d623f8d52a3
+:c52c9a615356
 \begin{block}{From a blog post}
 ``Version control (or source control) is nothing more arcane than keeping copies of ones work as one make changes to it.''
 \end{block}
 \pause
 \begin{block}{}
-It is better to use these tools rather then wasting creativity to invent VCS which have files with names like \begin{color}{red}{prog1.py, prog2.py}\end{color} or \begin{color}{red}prog-old.py, prog.py.\end{color}
+It is better to use these tools rather than wasting creativity to invent VCS which have files with names like \begin{color}{red}{prog1.py, prog2.py}\end{color} or \begin{color}{red}prog-old.py, prog.py.\end{color}
 \end{block}
 \end{frame}
 \begin{frame}
 \frametitle{Motivation behind such tools}
 \item To collaborate effectively on a project.
 \item \begin{color}{red}``To err is Human''\end{color} \pause for recovery we have ``Version Control''
 \end{itemize}
 \end{frame}
-\begin{frame}
+%% Introduction to how logs are managed in VCS.
-\frametitle{How is done What is done?}
+%% A analogy in logs and day-to-day life?
+\begin{frame}[fragile]
+\frametitle{How does it work?}
+It can roughly be related to Computer/Video Games.
+\begin{itemize}
+\item We play games in stages.
+\item We pass a stage/task- \begin{color}{red}we SAVE the game.\end{color}
+\item We resume playing from there onwards.
+\item In-case we want to replay or revisit some particular stage, we start from position we saved earlier.
+\item Even we can change the course of play henceforth.
+\end{itemize}
+\end{frame}
+\begin{frame}[fragile]
+\frametitle{Better way to say:}
+\begin{center}
+\includegraphics[height=2.5in,width=2.5in, interpolate=true]{mario}
+\end{center}
+\emphbar{VCS provides power to save and resume from a stage.}
+\end{frame}
+\begin{frame}
+\frametitle{How is it done?}
 \begin{itemize}
 \item It keeps track of changes you make to a file. You can improvise, revisit, and amend.
 \item All procedure is logged/recorded, so you and others can follow the development cycle.
 \end{itemize}
 \end{frame}
 \item git
 \end{itemize}
 \inctime{10}
 \end{frame}
-% Introduction to jargons
+% Introduction to jargon
 \section{Learning the Lingo!}
 \begin{frame}
-\frametitle{Common jargons: Basic setup}
+\frametitle{Common jargon: Basic setup}
 \begin{itemize}
 \item Repository(repo):\\
 The folder with all files.
 \item Server:\\
 Machine with main inventory/repo.
 \frametitle{Actions}
 \begin{itemize}
 \item Add:\\
 Adding file into the repo for the first time.
 \item Version:\\
-Version number of a file.
+Version number(Die Hard 4.0).
 \item Head/Tip:\\
-The latest revision of the repo.
+Most recent revision/stage.
 \item Check out/Clone:\\
-Initial download of repo onto machine.
+Initial download of working copy.
 \item Commit:\\
-Recording a change.
+Saving(recording) a change.
 \item Change log/History:\\
-List of changes made to repo.
+List of all past changes.
 \end{itemize}
 \end{frame}
 \begin{frame}
 \frametitle{Actions cont...}
 \begin{itemize}
 \item Branch:\\
-Separate local copy of repo for bug fixing, testing.
+Separate local copy for bug fixing, testing.
 \item Diff/Change:\\
-Finding the differences in a file in two versions.
+Changes made in a file in two different versions.
 \item Merge (or patch):\\
-Apply the changes to file, to make it up-to-date.
+Appling the changes to file, to make it up-to-date.
 \item Conflict:\\
 When merging a file is not obvious.
 \item Resolve:\\
 Fixing the conflict manually.
 \end{itemize}
 % Types of Version Controls
 \section{Types of VCS}
 \begin{frame}
 \frametitle{Types:}
-Based on way of managing the repo there are two types of VCS:
+Based on ways of managing the repo there are two types of VCS:
 \begin{itemize}
 \item Centralized VCS\\
-cvs, svn falls under this category.
+cvs, svn fall under this category.
 \item Distributed VCS\\
 hg, bzr, git follows this methodology.
 \end{itemize}
 \emphbar{We would be covering \typ{hg}}
 \end{frame}
 \includegraphics[height=.75in, interpolate=true]{mercurial}
 \begin{itemize}
 \item Easy to learn and use.
 \item Lightweight.
 \item Scales excellently.
-\item Based on Python.
+\item Written in Python.
 \end{itemize}
 \inctime{10}
 \end{frame}
 % Initializing the repo, cloning, committing changes, pushing, pulling to repo.
 $ hg clone Fevicol Fevicol-pull
 updating working directory
 0 files updated, 0 files merged,
 0 files removed, 0 files unresolved
 \end{lstlisting}
-\inctime{15}
+\inctime{20}
 \end{frame}
 %% Should we here stress on how are distribute VCS have
 %% different approach then centralized ones? Maybe a pic
 %% or some other graphical representation.
-%% Introduction to how logs are managed in VCS.
-%% A analogy in logs and day-to-day life?
-\begin{frame}[fragile]
-\frametitle{How does it work?}
-It can roughly be related to Computer/Video Games.
-\begin{itemize}
-\item We play games in stages.
-\item We pass a stage/task- We save the game.
-\item We resume playing from that point.
-\item In-case we want to replay or revisit some particular stage, we have it saved.
-\item Even we can change the course of play henceforth.
-\end{itemize}
-\end{frame}
-\begin{frame}[fragile]
-\frametitle{Better way to say:}
-\begin{center}
-\includegraphics[height=2.5in,width=2.5in, interpolate=true]{mario}
-\end{center}
-\emphbar{\typ{hg} provides power to save and resume from a stage.}
-\end{frame}
 \begin{frame}[fragile]
 \frametitle{Revisiting saved points:history/logs}
 In \typ{hg}, the difference between consecutive stages is termed as changeset.\\
 Once we have saved stages, we need a mechanism to review and access them, for that use \typ{log} command.
 \begin{lstlisting}
 \end{lstlisting}
 tip/latest changes can be seen via:
 \begin{lstlisting}
 $ hg tip
 \end{lstlisting} %%$
-\inctime{10}
+\inctime{5}
 \end{frame}
 \begin{frame}[fragile]
-\frametitle{Advancing through state:status}
+\frametitle{Advancing through a stage:status}
 We often need to add/delete some files from directory(repo). The structure keeps on evolving, and tools for handling them are needed.\\
 We will use the Fevicol repo we created earlier.
 \begin{lstlisting}
 $ cd Fevicol
 $ hg log
 ? feviStick.py
 \end{lstlisting} %%$
 \typ{st} (aka status) is command to show changed files in the working directory.\\
 \end{frame}
+%% track record is confusing for some. Duma have some doubts :(
 \begin{frame}[fragile]
 \frametitle{Adding files}
 "?" indicates that these file are aliens to track record.\\
 \typ{add} command is available to add new files to present structure.
 \begin{lstlisting}
 summary:     First commit.
 \end{lstlisting}
 \end{frame}
 \begin{frame}[fragile]
-\frametitle{More basic operations}
+\frametitle{Other operations}
+\typ{hg} supports basic file-management functions like copy, remove, rename etc.
 \begin{lstlisting}
 $ hg cp feviStick.py pidiLite.py
 $ hg rename pidiLite.py feviCol.py
 $ hg st
 A feviCol.py
 $ hg ci -u "Shantanu <shantanu@fossee.in>"
 -m "Added feviCol.py."
 $ hg tip| grep summary
-summary:     Renamed feviStick.py.
+summary:     Added feviCol.py.
 \end{lstlisting} %$
-%% Other commands which can be handy are \typ{cp}, \typ{remove}, \typ{revert} etc.
+%% Other commands which can be handy are \typ{remove}, \typ{revert} etc.
 \inctime{10}
 \end{frame}
 % Introduction to concepts of branches, merging patch?
 \section{Sharing and Collaborating}
 \begin{frame}[fragile]
 \frametitle{Distributing changes}
-As this repo is self-contained, hence changeset just created are local and are not propagated to previously cloned Fevicol-pull.
+\begin{itemize}
+\item All directory-structure(repo) are self-contained.
+\item Changes created are local.
+\begin{itemize}
+\item Until we sync. previously cloned repos.
+\end{itemize}
+\end{itemize}
 \begin{lstlisting}
 $ hg pull
 pulling from /home/baali/Fevicol
 requesting all changes
 adding changesets
 \end{lstlisting} %$
 \end{frame}
 \begin{frame}[fragile]
 \frametitle{Pulling changesets cont...}
-As pointed by previous command output, hg \typ{pull} does not(by default) update current directory. It just imports changesets. To add all these changesets one have to update using \typ{up} command:
+\typ{pull} command doesn't update current directory, it just imports changesets. To add all these changes, use \typ{up}:
 \begin{lstlisting}
 $ cd Fevicol-pull
 $ ls -a
 .  ..  .hg
 $ hg up
 2 files updated, 0 files merged,
 0 files removed, 0 files unresolved
 $ ls -a
 .  ..  feviCol.py  feviStick.py  .hg
 \end{lstlisting}
-\end{frame}
+\pause
+\emphbar{Why \typ{pull} and \typ{up} are needed separately?}
-\begin{frame}[fragile]
+\end{frame}
-\frametitle{Making changes across the repos}
-\begin{lstlisting}
+\begin{frame}[fragile]
-$ Fevicol-clone/
+\frametitle{Making changes across branches}
+\begin{lstlisting}
+$ cd Fevicol-pull/
 \end{lstlisting} %$
 Lets edit and correct the feviStick.py
 \begin{lstlisting}
 $ echo "print 'Ab no more Chip Chip'"
 > feviStick.py
 $ hg st
 M feviStick.py
 \end{lstlisting}
-'M' sign indicates that Mercurial has noticed change.\\
+'M' sign indicates that \typ{hg} has noticed change.\\
 \end{frame}
 \begin{frame}[fragile]
 \frametitle{Revisiting changes}
-To revisit changes made earlier use \typ{diff} command:
+To view changes made \typ{hg} provides \typ{diff}:
 \begin{lstlisting}
 $ hg diff
 diff -r a7912d45f47c feviStick.py
 --- a/feviStick.py   Sun Aug 23 22:34:35 2009 +0530
 +++ b/feviStick.py   Sun Aug 23 22:47:49 2009 +0530
 @@ -1,1 +1,1 @@
 -print 'Yeh Fevicol ka Majboot jod hai'
 +print 'Ab no more Chip Chip'
 \end{lstlisting} %$
-These changes are not logged until you commit them.\\
+\end{frame}
+\begin{frame}[fragile]
+\frametitle{Saving the changes}
+We have to commit these changes.
 \begin{lstlisting}
 $ hg ci -u "Shantanu <shantanu@fossee.in>"
 -m "Changed tagline for feviStick.py."
 \end{lstlisting} %$
 \end{frame}
 \begin{frame}[fragile]
 \frametitle{Syncing two repos}
-Now to bring both the repos to same stage one have to \typ{push} changes.
+To bring both the repos at same stage we have to \typ{push} differences.
 \begin{lstlisting}
 $ hg push
 pushing to /home/baali/Fevicol
 searching for changes
 adding changesets
 adding file changes
 added 1 changesets with 1 changes to 1 files
 \end{lstlisting} %$
 \end{frame}
 \begin{frame}[fragile]
 \frametitle{Syncing cont...}
-Same as pulling, pushing wont update the main repo by default. Try running following command:
+Same as pulling, pushing wont update the main directory by default.
 \begin{lstlisting}
 $ cd Fevicol
 $ hg tip
 $ cat feviStick.py
 \end{lstlisting}
 We consider scenario, two person on one project, both have local copies, and one among them is main branch.\\
 \begin{center}
 \includegraphics[height=1in, interpolate=true]{scenario}
 \end{center}
 \end{frame}
 \begin{frame}[fragile]
 \frametitle{Making changes to one of repo}
 \begin{lstlisting}
 $ cd Fevicol-pull
 $ hg st
 M feviStick.py
 $ hg ci -u "Shantanu <shantanu@fossee.in>"
 -m "Updated tag line for feviCol.py."
 $ hg tip| grep changeset
-changeset:   4:caf986b15e05
+changeset:   3:caf986b15e05
 \end{lstlisting} %$
 \end{frame}
 \begin{frame}[fragile]
 \frametitle{In the meanwhile, other repo is ...}
 $ hg st
 A firstAdd.py
 $ hg ci -u "Shantanu <shantanu@fossee.in>"
 -m "Added firsAdd.py."
 $ hg tip|grep changeset
-changeset:   4:fadbd6492cc4
+changeset:   3:fadbd6492cc4
 \end{lstlisting}
+\end{frame}
+%%\hspace*{-0.5in}
+\begin{frame}[fragile]
+\frametitle{Situation}
+\begin{columns}
+\column{0.5\textwidth}
+\begin{block}{\center{main directory}}
+\includegraphics[height=2in, interpolate=true]{main}
+\end{block}
+\column{0.5\textwidth}
+\begin{block}{\center{cloned directory}}
+\includegraphics[height=2in, interpolate=true]{clone}
+\end{block}
+\end{columns}
 \end{frame}
 \begin{frame}[fragile]
 \frametitle{Merging}
 \begin{lstlisting}

changeset 83	c52c9a615356
parent 81	3d20090b7cbd
child 84	535151a16560