Merge branch 'advanced-training' into 'develop'

Advanced training slides

See merge request !44

2019/2019-09-24_advancedGitTraining/slides/amend.md

-# Theory: Git Amend
+# Amend a commit
 
-* Enables to change the specifics of the commit on HEAD (the last commit)
+* Enables to change a commit on `HEAD` (the last commit)
 
-
-
-
-# Practical: Git Amend
-
-* Start by creating and committing a file
+* Start by creating and committing a file in the `attendees` directory:
 ```bash
-$ echo "This file contains errors and needs to be amended" > amend.txt
-$ git add amend.txt
-$ git commit -m "this file needs to be amended"
+$ cd attendees
+$ echo "# Firstname Lastname" > myName.md
+$ git add myName.md
+$ git commit -m "Add firstname lastname to attendees"
 ```
 
-* Check the commit
+* Check the commit in the `log`:
 ```bash
 $ git log
 ```
 
 
 
-# Practical: Git Amend - Commit Message
+# Example 1: change the commit message
 
 * Verify that your staging area is clear:
 ```bash
 $ git status
 ```
 
-* use the `commit --amend` with the `-m` flag to edit only the commit message:
-```bash
-$ git commit --amend -m "This commit title has been amended"
-```
+* Use `git commit --amend` to change the commit
+
+    Alternatively, you can use the `-m` flag to edit only the commit message:
+    ```bash
+    $ git commit --amend -m "Add title"
+    ```
 
-* See the commit message in the log has changed:
+* Check the commit message in the `log`:
 ```bash
 $ git log
 ```
 
 
 
-# Practical: Git Amend - Commit Content
+# Example 2: change the commit content
 
-* In your editor, change the text in the amend.txt file:
+* In your editor, change the text in the `myName.md` file. For instance:
 ```bash
-"This file's content have been corrected"
+My biography ...
 ```
 
-* Check if the changed file is in the staging area:
+* You can see that the file changed:
 ```bash
 $ git status
 ```
 
-* With the changes stages use the following command to commit the changes into the previous commit:
+* With the changes staged use the following command to commit the changes into the previous commit:
 ```bash
-$ git commit --amend -no-edit
+$ cd ../ # change directory one up if required
+$ git add attendees/myName.md
+$ git commit --amend --no-edit
 ```
 
-* This will create and commit a new commit with the staged changes added.
-* Force push your changes to develop
+* This will create and commit a new commit with the staged changes added and the same commit message.
+* (Force) push your changes to your branch `myBranch`

2019/2019-09-24_advancedGitTraining/slides/chPick.md

-# Theory: Git Cherry-picking
+# Cherry-picking
 
-* It enables the user to pick specific commits from a list of commits.
+* Cherry-pick allows to pick one (or more) specific commits from a list of commits.
+* Cherry picking only picks the selected commit(s), not everything up to that commit.
 
-Careful!
-Cherry picking only picks the selected commit,
-not everything up to that commit.
-
-<div style="top: 15em; left: 30%; position: absolute;">
-    <img src="slides/img/cherryPick.png">
+<div style="top: 8em; left: 25%; position: absolute;">
+    <img src="slides/img/cherryPick.png" height=500px>
 </div>
 
 
 
-# Practical: Git Cherry-picking
+# Example (1)
 
-* In your branch, create and commit a reference file
+* Create and commit two files in the `develop `branch
 ```bash
-$ echo "This is the start of a commit chain" > reference.txt
-$ git add reference.txt
-$ git commit origin myBranch
+$ echo "# Venue details" > location.md
+$ # add and commit the file location.md
+$ echo "# Speakers" > speakers.md
+$ # add and commit the file speakers.md
 ```
 
-* Create and commit two files in the develop branch
+
+
+# Example (2)
+
+* Check the `log` and note down the `SHA1` of the commits you want to cherry-pick. Then:
 ```bash
-$ echo "This is a commit to keep" > keep.txt
-$ git add keep.txt
-$ git commit origin develop
-$ echo "Ignore this commit" > ignore.txt
-$ git add ignore.txt
-$ git commit origin develop
+$ git checkout myBranch
+$ git cherry-pick <SHA1>
+```
+* Check the log again and see if the changes were applied correctly. Note the new SHA1!
+```bash
+$ git show <newSHA1>
 ```
+* Repeat for the second commit
+
+* Push the changes to `myBranch`
+```bash
+$ git push origin myBranch
+```
+
+* Note that the `-f` flag is not needed to force push (no history has been rewritten)
+
+
+
+# Partial chery-picking
+
+* Partial cherry-picking allows you to unpack the changes from a commit.
+* Imagine you committed many files, and you want to remove certain files.
+* In practice:
+    - You commited all files, and you realize that there is your data inside!
+    - You have committed accidentally sensitive data, such as your password
+    - You committed hidden files, for instance `.DS_Store` files
 
 
 
-# Practical: Git Cherry-picking
 
-* Check the commit reference of the two commits in develop
-* Chose the commit to keep and add it to your branch
+# Example (1)
+
+* Reset the `develop` branch:
 ```bash
-$ git checkout myBranch
-$ git cherry-pick <commit reference>
+$ git checkout develop
+$ git reset HEAD~2
 ```
-* Check the log again and see if the changes were applied correctly
-
-* push the changes to the develop branch
+* Add the `location.md` and the `speakers.md` files as 1 commit:
 ```bash
-$ git push origin myBranch -f
+$ echo "# Venue details" > location.md
+$ echo "# Speakers" > speakers.md
+$ git add location.md speakers.md
+$ git commit -m "add location and speakers files"
 ```
 
-* The `-f` flag is used to force push into develop
\ No newline at end of file
+
+
+# Example (2)
+
+Cherry-pick the commit from `develop` over to `myBranch`:
+
+```bash
+$ git checkout myBranch
+$ git cherry-pick -n <SHA1>
+$ git status
+```
+Now, remove the file `location.md`:
+```bash
+$ git restore --staged location.md
+$ rm location.md
+```
+Commit the changes:
+```bash
+$ git commit -m "add speakers file"
+```

2019/2019-09-24_advancedGitTraining/slides/conflict.md

-# Theory: Conflict resolution
+# Conflict resolution
 
-* A conflict emerges when two files push two different changes
-to a one target branch
+* A conflict occurs when two changes change the same line in a file
 
 * Some conflict may be resolved automatically, but major conflicts
 always need to be resolved manually
 
-* Tools exist to streamline conflict resolutions, we use kdiff3
+* Tools exist to streamline conflict resolutions, we use `kdiff3`
 
+* Conflicts can happen during `merge`, `cherry-pick`, and `rebase`
 
 
-# Practical: Conflict resolution using kdiff3
 
-* create a branch named changeMicheal and in the editor you change
-the content of `Michael.md`:
+# Example 1: Conflict resolution when locally merging (1)
+
+* Checkout the branch `myNewBranch` and change the file `template.md`:
+
 ```bash
-$ git checkout develop
-$ git checkout -b changeMichael
+$ git checkout myNewBranch
 ```
 
-Change Michael file...
+* Use your favorite editor and type:
 
 ```bash
-$ git fetch upstream
-$ git checkout develop
-$ git merge upstream/develop
+# Advanced git training course
+
+## Firstname Lastname
 ```
 
-summary:
-michael.md on develop:
+* Add and commit that change.
+
+* Checkout the branch `myBranch` and change the file `template.md`:
+
+```bash
+# Advanced git training -- Course
+
+## Firstname Lastname
 ```
-# Michael
+* Then, save, add, and commit that change.
+
+
+
+# Example 1: Conflict resolution when locally merging (2)
+
+* Merge the `myNewBranch` into the `myBranch` branch:
+
+```bash
+$ git merge myNewBranch
 ```
 
-michael.md on changeMichael (example)
+* A conflict appears:
+```bash
+$ git merge myNewBranch
+Auto-merging attendees/template.md
+CONFLICT (content): Merge conflict in attendees/template.md
+Automatic merge failed; fix conflicts and then commit the result.
+```
+* Start the merge tool:
 ```
-## Michael Evans
+$ git mergetool
 ```
 
 
 
-# Practical: Conflict resolution using kdiff3
+# Example 1: Conflict resolution when locally merging (3)
+
+* This opens kdiff3 if it was properly set up. There are 3 versions:
+    - **A**: version on `myBranch` before the recent change.
+    - **B**: version on `myNewBranch`
+    - **C**: version on `myBranch` after the recent change
 
-If then there is a rebase done on develop:
+* Resolve the conflict and save. Then:
 ```bash
-$ git rebase develop
+$ git merge --continue
 ```
-A conflict should emerge
 
-* When facing the merge conflict message, use the command
+* If you check the status, you will find a `.orig` file. This is a backup and contains the conflict.
 ```bash
-$ git mergetool
+$ git status
+$ cat template.md.orig
 ```
+* If you do not need anymore the backup file, you can remove it.
+* You can either `rm` the `.orig` file, or you can use `git clean -fdx`. **Tip:** use `--dry-run` first to list all files that would be deleted.
 
-* This opens kdiff3 if it was properly set up. Selecting A will keep the changes of the target branch,
-while B will keep your changes. Selecting A and B will combine both changes to the merged file.
 
 
 
+# Example 2: Conflict resolution when cherry-picking (1)
 
-# Practical: Conflict resolution using kdiff3
 
-* After resolving the conflicts, continue in your terminal
+If you follwed **Example 1**, reset the `myBranch` branch:
+```
+$ git checkout myBranch
+$ git reset --hard HEAD~1
+```
+Get the SHA1 of the commit on the `myNewBranch` branch:
 ```bash
-$ git rebase --continue
+$ git show myNewBranch HEAD
 ```
-* Then check the status:
+Then, cherry-pick that commit:
 ```bash
-$ git status
+$ git cherry-pick <SHA1>
 ```
 
-* It shows you a `.orig` file. This `.orig` file contains information about the conflict.
+
+
+# Example 2: Conflict resolution when cherry-picking (2)
+
+You will get a message that there is a conflict:
+```
+error: could not apply e3ffc09... edit content of template
+hint: after resolving the conflicts, mark the corrected paths
+hint: with 'git add <paths>' or 'git rm <paths>'
+hint: and commit the result with 'git commit'
+```
+* Start the merge tool as before:
+```
+$ git mergetool
+```
+* Resolve the conflict and save. Then:
 ```bash
-$ rm _attendees/michael.md.orig
+$ git cherry-pick --continue
 ```
-* You can either `rm` the `.orig` file, or you can use `git clean -fdx`.
\ No newline at end of file
+The remaining steps are the same as explained in **Example 1**.
\ No newline at end of file

2019/2019-09-24_advancedGitTraining/slides/gettingStarted.md

 # Getting Started
 
-Fork and clone the tutorial repository
+Fork and then clone the tutorial repository
+<a href="https://git-r3lab.uni.lu/R3/school/git/advanced-practice">https://git-r3lab.uni.lu/R3/school/git/advanced-practice</a>
+
 ```bash
-$ git clone ssh://git@git-r3lab-server.uni.lu:8022/<yourName>/presentations-internal.git
+$ git clone ssh://git@git-r3lab-server.uni.lu:8022/<first.last>/advanced-practice.git
 ```
+
 Add a remote upstream
 ```bash
-$ git remote add upstream ssh://git@git-r3lab-server.uni.lu:8022/R3/school/advanced-git/presentations-internal.git
+$ cd advanced-practice
+
+# add upstream URL
+$ git remote add upstream ssh://git@git-r3lab-server.uni.lu:8022/R3/school/git/advanced-practice.git
+$ git fetch upstream
 ```
-Go to the develop branch
+Check the remotes
 ```bash
-$ git checkout develop
+$ git remote -v
 ```
-And create your own branch using the `-b` flag
+
+Create your own branch `myBranch` based on the `develop` branch from `usptream` using the `-b` flag
+```bash
+$ git checkout -b <mybranch> upstream/develop
+```
+
+
+
+# Installing the mergetool `kdiff3`
+
+* Download it here: http://kdiff3.sourceforge.net/
+
+* The downloadable file should match your OS
+
+* Setting up `kdiff3`:
+
 ```bash
-$ git checkout -b myNameBranch
-```
\ No newline at end of file
+$ git config --global --add merge.tool kdiff3
+$ git config --global --add mergetool.kdiff3.path "<kdiff3 path>"
+```
+
+* omit `""` when setting up on Linux or macOS
+
+
+
+# A note on common commands:
+
+This workshop will not cover in detail the following commands, assuming you are familiar with them:
+
+- `git checkout`
+- `git add`
+- `git commit`
+- `git log`
+- `git show`
+
+Feel free to ask any questions if you run into any issues!
+
+For your reference:
+```bash
+$ git <command> --help
+```
+Replace `<command>` with the command you want help for.
+
+Exit with `q`

2019/2019-09-24_advancedGitTraining/slides/headRebase.md

-# Theory: Amending with Git Rebase
-
-* The same operations can be made with `git rebase -i`
-
-* The flag HEAD~X will let you amend the X previous commits instead of just the last one
-
-* In the Interactive rebase menu, be sure to select the `edit` option.
-
-
-
-# Practical: Amending with Git Rebase
-
-```bash
-$ git rebase -i HEAD~3
-```
\ No newline at end of file

2019/2019-09-24_advancedGitTraining/slides/index.md

@@ -9,11 +9,11 @@
 <div style="top: 5em; left: 60%; position: absolute;">
     <img src="slides/img/r3-training-logo.png" height="200px">
     <br><br><br>
-    <h1>Advanced Git Practices</h1>
+    <h1>Advanced Git Concepts</h1>
     <br><br><br>
-    <h4>
+    <h2>
         Laurent Heirendt, PhD<br><br>
         laurent.heirendt@uni.lu<br><br>
         <i>Luxembourg Centre for Systems Biomedicine</i>
-    </h4>
+    </h2>
 </div>

2019/2019-09-24_advancedGitTraining/slides/kdiff3Install.md

-# Installing kdiff3
-
-* Recommended tool: KDiff3
-
-* Download it here: https://sourceforge.net/projects/kdiff3/files/
-
-* The downloadable file should match your OS
-
-
-
-# Setting up kdiff3
-
-```bash
-git config --global --add merge.tool kdiff3
-git config --global --add mergetool.kdiff3.path " <Kdiff3 path> "
-git config --global --add mergetool.kdiff3.trustExitCode false
-
-git config --global --add diff.guitool kdiff3
-git config --global --add difftool.kdiff3.path " <Kdiff3 path> "
-git config --global --add difftool.kdiff3.trustExitCode false
-```
-
-* omit `""` when setting up on linux or mac
\ No newline at end of file

2019/2019-09-24_advancedGitTraining/slides/list.json

@@ -2,14 +2,12 @@
     { "filename": "index.md" },
     { "filename": "overview.md" },
     { "filename": "gettingStarted.md" },
+    { "filename": "amend.md" },
+    { "filename": "reset.md" },
+    { "filename": "revert.md" },
     { "filename": "rebase.md" },
     { "filename": "chPick.md" },
-    { "filename": "revert.md" },
-    { "filename": "reset.md" },
-    { "filename": "amend.md" },
-    { "filename": "headRebase.md" },
     { "filename": "merge.md" },
     { "filename": "conflict.md" },
-    { "filename": "kdiff3Install.md" },
     { "filename": "thanks.md" }
 ]

2019/2019-09-24_advancedGitTraining/slides/merge.md

-# Theory: Merging branches
+# Merging branches locally
 
+* Merge a branch into another one locally
 * Combines all the commits from a source branch onto a target branch
+* In practice, this is very useful if you 'just want to try out something', or 'draft' something
 
 
 
-# Practical: Merging branches
+# Example (1)
 
-* Create a new branch from your own branch:
+* Create a new branch from your `myBranch` branch:
 ```bash
-$ git checkout -b Feature1
+$ git checkout myBranch
+$ git checkout -b myNewBranch
 ```
 
-* Add two files to the Feature1 branch in two separate commits:
+* Add two files to the `myNewBranch` branch in two separate commits:
 ```bash
-$ echo "Code that is merged into myBranch" > merge1.txt
-$ git add merge1.txt
-$ git commit -m "first commit to be merged"
-```
-```bash
-$ echo "Code that is merged into myBranch" > merge2.txt
-$ git add merge2.txt
-$ git commit -m "second commit to be merged"
+$ echo "# Trevor Westman" > trevor.md
+$ # add and commit the file trevor.md
+$ echo "# Gustav Bergen" > gustav.md
+$ # add and commit the file gustav.md
 ```
 
 
 
-# Practical: Merging branches
+# Example (2)
 
-* Check the commit log of the myBranch and Feature1 branch
+* Check the `log` of the `myNewBranch` and `myBranch` branches:
 ```bash
-$ git log
+$ git log myBranch
+$ git log myNewBranch
 ```
 
-* Go to myBranch and merge the Feature1 branch into it
+* Go to `myBranch` and merge the `myNewBranch` branch into it
 ```bash
-$ git merge Feature1
+$ git checkout myBranch
+$ git merge myNewBranch
+$ git log myBranch
 ```
-
-* This will move all changes made in the Feature1 branch
-onto myBranch, effectively fusing the two together.
\ No newline at end of file

2019/2019-09-24_advancedGitTraining/slides/overview.md

 # Overview
 
-1. Rebasing in Git
-2. Git cherry-picking
-3. Reverting commits
-4. Resetting to a previous commit
-5. Amend last commit
+1. Installation and getting started
+
+2. Amend last commit
+
+3. Resetting to a previous commit
+
+4. Reverting commits
+
+5. Rebasing in Git
+
+6. Git cherry-picking
+
 7. Merging branches
+
 8. Conflict Resolution

2019/2019-09-24_advancedGitTraining/slides/rebase.md

-# Theory: Git Rebasing
+# Rebasing (1)
 
-* Git rebase enables to keep up with changes made to a branch
-* Straightens the workflow
+* Git rebase enables to forward your commits
+* Move/combine a sequence of commits to a new base commit
 * Avoid discrepancies when multiple people work on the same project
+* Linear git history (no merge commits)
+* Rebasing is like saying, “I want to base my changes on what everybody has already done.”
 
 Imagine the following situation:
 <div style="top: 10em; left: 30%; position: absolute;">
-    <img src="slides/img/beforeRebase.png" height="400px">
+    <img src="slides/img/beforeRebase.png" height="500px">
 </div>
 
 
 
-# Theory: Git Rebasing
+# Rebasing (2)
 
-* Develop branch is several commits ahead of master.
-* Commits implemented into master that aren't in develop.
+* `myBranch` is several commits ahead of `develop`.
+* Commits implemented into `develop` that aren't in `myBranch`.
 
 <div style="top: 10em; left: 30%; position: absolute;">
-    <img src="slides/img/afterRebase.png" height="400px">
+    <img src="slides/img/afterRebase.png" height="500px">
 </div>
 
 
 
-# Practical: Git Rebasing
+# Example (1):
 
-* Create a file in your branch
+* Create a file in your branch `myBranch`
 ```bash
-$ git checkout myBranch
-$ echo "# message" > yourName.md
+$ git checkout myBranch # if necessary
+$ cd attendees
+$ echo "# List of attendees" > list.md
+$ # add and commit the file
 ```
 
-* Then create a file in the develop branch
+* Then, update your `develop` branch from the `upstream` remote:
 ```bash
+$ git fetch upstream
 $ git checkout develop
-$ touch startRebase.txt
+$ git merge upstream/develop
+$ git checkout myBranch
 ```
 
 * Check the histories of both branches
@@ -43,29 +49,31 @@ $ git log
 
 
 
-# Practical: Git Rebasing
+# Example (2):
 
-* rebase the develop branch onto your branch
+* Rebase `myBranch` on top of the updated `develop`:
 ```bash
 $ git checkout myBranch
 $ git rebase develop
 ```
 
-* check the history of your branch again
+* Check the history of your branch again
 ```bash
 $ git log
 ```
 
+* If you pushed previously your branch `myBranch`, you need to rewrite its history remotely - you need to **force push**.
 
 
-# Theory: Git Interactive Rebasing
+
+# Interactive Rebasing - flag `-i`
 
 ```bash
 git rebase -i <branch>
 ```
 
 * Enables more precise control over the rebased commits
-* Before committing many actions are at disposal
+* Before committing many actions are available
 
 ```bash
 #  p, pick = use commit
@@ -78,54 +86,51 @@ git rebase -i <branch>
 
 
 
-# Practical: Git Interactive Rebasing
+# Example 1: Reword and fixup (1)
 
 * Create and switch to your own branch
 * Add and commit two files to this branch:
 
 ```bash
-$ echo "# Michael" > Michael.md
-$ git add Michael.md
-$ git commit -m "Add Michael to the list of attendees"
-$ git push origin yourBranch
-
-$ echo "# Kevin" > Kevin.md
-$ git add Kevin.md
-$ git commit -m "Add Kevin to the list of attendees"
+$ cd attendees
+$ echo "# William Odell" > william.md
+$ # add and commit the file william.md with the message 'add william to attendee list'
+$ echo "# Roberta Ross" > roberta.md
+$ # add and commit the file roberta.md with the message 'add roberta to attendee list'
 $ git push origin yourBranch
 ```
 
+Now, we want to:
 
+- Reword the first commit's message to: `Add William and Roberta to attendee list`
+- Combine the second and first commit into one
+- Omit the commit message of the second commit.
 
-# Practical: Git Interactive Rebasing
 
-* Perform an interactive rebase with the two last commits:
 
-```bash
-$ git rebase -i HEAD~2
-```
-
-* reword the first commit's message to:
-`These are the two squashed commits`
-* combine the second and first commit into one,
-omitting the second's commit message.
 
+# Example 1: Reword and fixup (2)
 
+Perform an interactive rebase with the two last commits:
 
-# Practical: Git Interactive Rebasing
+```bash
+$ git rebase -i HEAD~2
+```
 
 The prompt shows up:
 ```bash
-$ pick 1234567 add Micheal to attendee list
-$ pick abcdef0 add Kevin to attendee list
+$ pick 1234567 add william to attendee list
+$ pick abcdef0 add roberta to attendee list
 ```
 
-The keywords should be changed to:
+The keywords `pick` can now be changed to `reword` and `fixup` respectively:
 ```bash
-$ reword 1234567 add Micheal to attendee list
-$ fixup abcdef0 add Kevin to attendee list
+$ reword 1234567 add william to attendee list
+$ fixup abcdef0 add roberta to attendee list
 ```
 
+**Note:** The SHA1s of each commit are different.
+
 Upon confirming, change the message of commit 1234567:
 ```bash
 $ Add Micheal and Kevin to the attendee list
@@ -138,12 +143,12 @@ $ git push origin myBranch -f
 
 
 
-# Practical: Git Interactive Rebasing
+# Example 2: Pick and squash (2)
 
-* If you wanted to keep both commit messages in one commit, instead change the prompts to squashing instead
+* If you wante to keep both commit messages in one commit, change the action to `squash`
 ```bash
-$ pick 1234567 add Micheal to attendee list
-$ squash abcdef0 add Kevin to attendee list
+$ pick 1234567 add william to attendee list
+$ squash abcdef0 add roberta to attendee list
 ```
 
-* This will create a commit with both files still in, but the commit message of that commit will be the two commit messages of the two files combined.
\ No newline at end of file
+* This will create a commit with both modified files, with the commit message being a combination of the two commit messages.
\ No newline at end of file

2019/2019-09-24_advancedGitTraining/slides/reset.md

-# Theory: Git Reset
+# Reset a branch
 
-* Enables to reset back to a previous commit HEAD
+* Enables to reset back to a previous commit
 * Discards ALL commits made after the selected commit HEAD
 
+* This happens often in **practice**:
+    you pushed to a branch, then realize that you made a mistake in the commit, and want to start over.
 
 
-# Practical: Git Reset
+
+# Example: Hard reset of a branch (1)
 
 * Start by committing two files:
 ```bash
-$ echo "This file is the one we want to keep" > header.txt
-$ git add header.txt
-$ git commit -m "Reset here"
-```
-```bash
-$ echo "This file contains faulty code" > undo.txt
-$ git add undo.txt
-$ git commit -m "Undo this commit"
+$ cd attendees
+$ echo "# CV of Firstname Lastname" > myCV.md
+$ git add myCV.md
+$ git commit -m "add cv for Firstname Lastname"
+$ echo "# Biography of Firstname Lastname" > myBio.md
+$ git add myBio.md
+$ git commit -m "add biography for Firstname Lastname"
+$ git push origin myBranch
 ```
-* Check the commits again and copy the relevant commit header:
+
+* Check the commits, copy the `SHA1` of the second last commit:
 ```bash
 $ git log
 ```
+
+
+
+# Example: Hard reset of a branch (2)
+
 * Use the `reset --hard` command in order to undo the faulty commit:
 ```bash
-$ git reset --hard <sha1>
+$ git reset --hard <SHA1>
 ```
+
 * Check what happened in the log
-* Force push your now solitary commit to develop
\ No newline at end of file
+* Force push your branch (overwrite the history)
+
+
+
+# Notes
+
+Alternatively, you can also remove the last commit:
+```bash
+$ git reset --hard HEAD~1
+```
+With a `--hard` reset, the index and the working tree are reset.
+
+If you omit the `--hard` flag, a mixed reset is made. This resets the index, but not the working tree
+```bash
+$ git reset HEAD~1
+```
\ No newline at end of file

2019/2019-09-24_advancedGitTraining/slides/revert.md

-# Theory: Git Revert
+# Reverting a commit
 
-* Enables the deletion of committed commits
+* Enables the deletion of committed commits by reverting the changes.
+* A trace is kept in history of the original commit and the reverted one.
 
 
 
-# Practical: Git Revert
+# Example:
 
 * On your branch, create and commit a file:
 ```bash
-$ echo "# This commits contains errors" > revert.txt
-$ git add revert.txt
-$ git commit -m "Error"
+$ cd attendees
+$ echo "# Grades for Firstname Lastname" > grades.md
+$ git add grades.md
+$ git commit -m "File with grades for Firstname Lastname"
 ```
-* check the commit log and copy the `Error` commit ID:
+
+* check the commit log and copy the SHA1:
 ```bash
 $ git log
 ```
-* Use the 'git revert' command to undo this selected commit:
+* Use the `git revert` command to undo this selected commit:
 ```bash
 $ git revert <sha1>
 ```