Who am I?

• Frie Preu
• data scientist / IT consultant / software developer at codecentric
• volunteer at CorrelAid: IT infrastructure, internal projects (R packages), miscellaneous mischief
• Add me:
  • LinkedIn: Friedrike Preu
  • Twitter: @ameisen_strasse
  • GitHub: friep
  • GitLab: friep

Slides, installation and account creation

• slides: https://gost.netlify.com/en/rladies/
• see README of the repo
• https://gitlab.com/friep/git-our-shit-together

Partner up!

Why Git?

• masterthesis.docx
• masterthesis_v1.docx
• masterthesis_FINAL.docx
• masterthesis_FINAL_TimsEdits.docx
• masterthesis_FINAL_FINAL.docx

Version Control to the Rescue!

• Example: https://github.com/friep/git-our-shit-together-test-repo/
• RMarkdown presentation (more on this later!)

Fork and clone

Repository

A Git repository is a virtual storage of your project. It allows you to save versions of your code, which you can access when needed. (Source)

Fork and Clone

Fork

A fork is a copy of a repository. Forking a repository allows you to freely experiment with changes without affecting the original project. (Source)

Clone

Cloning a repository syncs it to your local machine. After you clone, you can add and edit files and then push and pull updates. (Source)

Hands On 1 - fork a repo

Mona

1. https://github.com/friep/git-our-shit-together-test-repo/: Fork (top right)
2. https://github.com/{USERNAME}/git-our-shit-together-test-repo opens
3. go to Settings->Collaborators and add Grace as a collaborator

SSH vs HTTPS

-> influences how GitHub authenticates you

Authentification

Hands On 1.1: connect Gitkraken with GitHub

1. Gitkraken profile (top right)
2. Preferences->Authentification->GitHub
3. connect to GitHub
4. Generate SSH key and add to GitHub

Hands On 2 - clone a repo

Mona & Grace

1. Gitkraken: Clone Repo -> Clone with URL
2. enter copied link to URL field

Real life

• open source contribution: fork + clone
• job / collab with friends: only clone

Commit

Commit

A commit is the Git equivalent of a "save".[...] Git committing is an operation that acts upon a collection of files and directories. (Source)

--> Commit = a "save point" in Git.

Commit

• a commit saves changes w.r.t. the previous commit
  • edits of file(s)
  • creation of new file(s)
  • deletion of file(s)
  • renaming of file(s)
• a commit can contain several changes!

Adding and Staging Area

(Source: https://git-scm.com/about/staging-area)

Hands On 3 - Go back in time

1. reset master to this commit
2. play with: hard, mixed, soft
3. fast forward master to origin/master (commit at top)

RMarkdown

• R flavour of Markdown (a markup language)
• easy way to write...
  • notes
  • texts
  • presentations
  • ...
• and render them to good looking documents!
• RMarkdown can include R code ...
• https://rmarkdown.rstudio.com/lesson-1.html

xaringan

• package to make RMarkdown presentations
• install.packages("xaringan")
• xaringan::inf_mr() with index.Rmd open

Hands On 4 - make a commit

Grace + Mona

1. Change stuff (e.g. README.md or index.Rmd)
2. GIT ADD the "unstaged files" you want to commit / "save in Git"
3. write a (at least partly) informative "commit message"
4. GIT COMMIT

Git Hosting

• GitHub:
• GitLab:
• Keybase:

Git local and git remote

... what?

• local: your laptop / machine
• remote: in the Cloud (GitHub, GitLab, ...)

Sync: Git Pull and Git Push

• Git Pull: "download" new commits from GitHub / GitLab
• Git Push: "upload" the commits you made locally to GitHub / GitLab

Hands On 5 - Pull and Push

1. Grace: Push
2. Mona: Pull
3. Mona: Push
4. Grace: Pull

When things go wrong...

1. as long nothing is pushed, all is (kind of) ok -> don't push if things are messed up!
2. if things are really messed up: save your code somewhere else and clone again

Merge conflicts

Merge conflicts occur when competing changes are made to the same line of a file, or when one person edits a file and another person deletes the same file. (Source)

Merge conflicts

1. you commit changes
2. you pull to get the newest updates
3. your coworker has changed something that clashes with your changes
4. git:

Solving merge conflicts

• you need to solve merge conflicts on your machine -> decide which version / changes you keep
• Gitkraken has an integrated merge conflict tool

Hands on 6: Merge conflicts

1. Mona or Grace: edit README.md on GitHub in a certain line
2. Mona & Grace: edit README.md locally on your machine in the same line (edit it differently!)
3. Monat & Grace: commit your own changes (don't push yet!)
4. Mona & Grace: pull
5. Mona & Grace: solve the merge conflict locally and push your own version.

Sidenote: Git stash

-> something Gitkraken often does for you to keep your changes safe.

git stash temporarily shelves (or stashes) changes you've made to your working copy so you can work on something else, and then come back and re-apply them later on. Stashing is handy if you need to quickly switch context and work on something else, but you're mid-way through a code change and aren't quite ready to commit. (Source)

Git stash for solving merge conflicts

1. git stash
2. git pull
3. apply stash
4. solve merge conflicts
5. (delete stash)

Issues

• issues: todos / bugs / ideas
• each issue has a number

• #issueno in commit message associates commit with issue

• example: https://github.com/jandix/sealr/issues

Hands On 7: Issues

1. Mona: create an issue "add Grace's favorite GIF"
2. Grace: go to giphy.com, find a funny gif and add it to the presentation (-> copy link)
3. Grace: add + commit. link the issue number in the commit message (#issueno)
4. Grace: push
5. Mona: reload the issue (ctrl + r)

Recap issues

• very useful for project organization
• discussion is centralized (but: don't put sensitive information in GitHub)
• Tip: create a GitHub project with a kanban board for process tracking

Branches

Branch

A branch represents an independent line of development. Branches serve as an abstraction for the edit/stage/commit process. You can think of them as a way to request a brand new working directory, staging area, and project history. (Source)

Checkout

The git checkout command lets you navigate between the branches created by git branch. Checking out a branch updates the files in the working directory to match the version stored in that branch, and it tells Git to record all new commits on that branch. Think of it as a way to select which line of development you’re working on. (Source)

Why branches?

• stability: only have working code on "master" branch
  • e.g. CI/CD directly to dev
  • users download your code from GitHub (e.g. devtools::install_github())
• collaboration: independent development of code ("feature branches")
• experiments: try it out in a branch
• example: https://github.com/jandix/sealr/branches

Branches Workflow

1. create a branch in Gitkraken with a meaningful name (e.g. issue1-add-favorite-gif)
2. checkout branch (double-click on branch name in Gitkraken)
3. continue working as usual (pull-commit-push cycles)
4. (optional: merge other branches into your branch to get their updates)
5. merge your branch into the master branch

Merging branches

• Gitkraken: right-click on branch name or master
• depends on which branch is ahead of which and which branch is currently checked out (?)
• right-click on master: merge master into issue1-add-favorite-gif -> branch is updated
• right-click on branch: merge issue1-add-favorite-gif into master -> master is updated (usually via Pull Request)

Pull Requests (PRs)

Pull requests let you tell others about changes you've pushed to a branch in a repository on GitHub. Once a pull request is opened, you can discuss and review the potential changes with collaborators and add follow-up commits before your changes are merged into the base branch. (Source)

• to be used in combination with branches
• useful "review" and feedback functionality

Hands on 8 - branches & pull requests

1. Grace & Mona together: create a new issue (think of something!)
2. Mona: create a branch called issue2-{description} locally
3. Mona & Grace: work together on issue 2 on Mona's machine
4. Mona: push the branch
5. Mona: open a pull request and assign Grace as a reviewer
6. Grace: review Mona's PR and merge it

Real life: Branches and Pull Requests

• branches
  • very useful when developing R packages / applications / shiny apps in a team: feature branches
  • relevance for data analysis projects: enables working in parallel on several methods, keep master clean of non-working code, backup (!)
• pull requests
  • centralize discussion
  • code review stage

What we learned today

• Fork and clone a GitHub repository
• make a commit in Gitkraken
• pull and push commits from / to GitHub
• work with branches and pull requests

If you ever need help...contact me!

Frie Preu

• data scientist / IT consultant @ codecentric AG
• friep
• friep
• friep
• ameisen_strasse
• RLadies Slack