Can You Turn Off Upload Version on Github?

---

Tutorial Aims:

1. Become familiar with version control, git and GitHub
2. Create your own repository and projection folder construction
3. Sync and collaborate with your repository through RStudio
4. Sync and interact with your repository through the command line

ane. Go familiar with version command, Git and GitHub

What is version control?

Version control allows yous to keep track of your work and helps you to easily explore the changes y'all have made, be it data, coding scripts, notes, etc. Y'all are probably already doing some type of version command, if y'all save multiple files, such equally Dissertation_script_25thFeb.R, Dissertation_script_26thFeb.R, etc. This approach will leave you with tens or hundreds of like files, making it rather cumbersome to straight compare unlike versions, and is non like shooting fish in a barrel to share amongst collaborators. With version control software such equally Git, version command is much smoother and easier to implement. Using an online platform like Github to store your files means that you take an online back up of your work, which is beneficial for both you and your collaborators.

Git uses the control line to perform more advanced actions and we encourage you to expect through the extra resource we have added at the end of the tutorial later, to get more comfortable with Git. Merely until and so, here nosotros offer a gentle introduction to syncing RStudio and Github, and so yous can start using version command in minutes.

What are the benefits of using version command?

Having a GitHub repo makes information technology easy for you lot to keep track of collaborative and personal projects - all files necessary for certain analyses tin exist held together and people tin can add in their code, graphs, etc. as the projects develop. Each file on GitHub has a history, making it piece of cake to explore the changes that occurred to it at different time points. Yous can review other people's code, add comments to certain lines or the overall document, and suggest changes. For collaborative projects, GitHub allows you to assign tasks to different users, making it clear who is responsible for which part of the analysis. Y'all can also ask certain users to review your lawmaking. For personal projects, version control allows you to proceed track of your work and easily navigate among the many versions of the files y'all create, whilst also maintaining an online fill-in.

How to get started

Delight register on the Github website.

On your figurer, you demand to install Git beginning. The procedure will depend on your operating system: delight follow the instructions below by clicking the relevant button.

Linux

If you are using a Linux distribution, y'all can usually install Git by running the following control in the Terminal:

If this doesn't work, look upward Git installation instructions for your distribution.

Windows

If you lot are on a personal Windows motorcar, download and install Git for your operating arrangement. Below are some recommended installation instructions, to keep things simple. However, if you know what these options do, and want to change them to suit y'all, go ahead:

1. For "Select Components", check:
   • "Git Bash Here"
   • "Git GUI Here"
   • "Git LFS (Big File Support)"
   • "Acquaintance .git* …"
   • "Associate .sh …"
2. When prompted to choose the default editor, choice Notepad or if available, Notepad++ (a free graphical text editor designed for coding you can download here).
3. For "Adjusting the proper noun of the initial branch in new repositories", select: "Override the default…" and write in "principal".
4. For "Adjust your PATH surroundings", select: "Git from the control line and also…"
5. For "Choose HTTPS transport backend", select: "Use the OpenSSL library"
6. For "Configuring the line catastrophe conversions", select: "Checkout Windows-fashion,…"
7. For "Choose the default behavior of git pull", select: "Default (fast-forward or merge)"
8. For "Choose a credential helper", select: "Git Credential Manager Cadre"
9. For "Configure the terminal emulator …", select: "Use MinTTY …"
10. For "Configure extra options", select:
    • "Enable file system caching"

For any configurations non listed here, select the default option.

macOS

If you are on a personal Mac machine, install Git via Homebrew, which is a parcel manager for command line programs on Mac. First, open up a terminal, which tin be institute at ~/Application/Utilities/Terminal.app. Then, copy and paste this line into the last and hit "Enter":

              /usr/bin/blood-red                -e                "                $(curl                -fsSL                https://raw.githubusercontent.com/Homebrew/install/principal/install)                "                          

Now enter the following to install Git:

Follow whatsoever instructions in the terminal window, you may need to enter your Mac's password or hold to questions by typing aye.

The files you put on GitHub will be public (i.due east. everyone can run across them & suggest changes, but only the people with access to the repository tin direct edit and add/remove files). You lot tin besides have individual repositories on GitHub, which means that only you can see the files. GitHub now offers free private repositories equally standard with up to three collaborators per repository. They also offering a costless education package, with admission to software and other perks, you tin use for one using this link.

How does version control piece of work?

What is a repository?

You tin call up of a repository (aka a repo) as a "primary folder", everything associated with a specific project should be kept in a repo for that project. Repos can take folders within them, or but be split files.

You volition take a local copy (on your estimator) and an online copy (on GitHub) of all the files in the repository.

The workflow

The GitHub workflow tin be summarised past the "commit-pull-push" mantra.

1. Commit
   • Once you've saved your files, you need to commit them - this means the changes you have fabricated to files in your repo volition be saved equally a version of the repo, and your changes are now ready to go up on GitHub (the online copy of the repository).
2. Pull
   • At present, before yous send your changes to Github, you need to pull, i.e. brand sure y'all are completely upwardly to date with the latest version of the online version of the files - other people could accept been working on them even if you oasis't. You lot should e'er pull before you start editing and before you push.
3. Push
   • Once you are up to engagement, you tin can push your changes - at this point in fourth dimension your local copy and the online copy of the files will be the same.

Each file on GitHub has a history, so instead of having many files like Dissertation_1st_May.R, Dissertation_2nd_May.R, you can accept merely 1 and by exploring its history, you lot can see what it looked at dissimilar points in time.

For example, here is the history for a repo with an R script inside it, every bit viewed on Github. Obviously information technology took me a while to calculate those model predictions!

ii. Create your own repository and projection folder structure

To make a repository, go to Repositories/New repository - choose a concise and informative proper noun that has no spaces or funky characters in it. This can exist your master repo that holds together by and ongoing research, data, scripts, manuscripts. Subsequently you might want to have more than repositories - eastward.grand. a repository associated with a particular projection that y'all desire to make public or a project where y'all are actively seeking feedback from a wider audience. For now, we will focus on organising and using your main repository that holds the files for all your work. With a free GitHub account, you can utilise public or private respositories.

Let'due south create a new private repository. You can call information technology any y'all similar if the name is bachelor.

Click on Initialise repo with a README.md file . It's common practice for each repository to have a README.md file, which contains information about the projection, the purpose of the repository, as well as any comments on licensing and data sources. Github understands several text formats, including .txt and .physician. .md stands for a file written in Markdown. You might have used Markdown before from inside RStudio to create neatly organised reports of your lawmaking and its outputs (you tin also bank check out our Markdown tutorial. You can likewise use Markdown to write patently text files, for example the file you are reading now was written in Markdown.

We will also create a .gitignore file. This file lets Git know what kind of files should not exist included in the repository. We'll have a await at that file in a bit. Tick the box, then search for R in the drop-down template (or whatsoever programming language yous will exist using for the project).

Once you are ready, click on Create repository.

Here is how the repository should wait:

You can directly edit your README.md file on Github by clicking on the file and then selecting Edit this file.

Exercise 1: Write an informative README.md file

You can now write the README.md file for your repository. To make headings and subheadings, put hashtags earlier a line of text - the more than hashtags, the smaller the heading will announced. You can make lists using - and numbers 1, 2, 3, etc.. When working on a shared project, talk over what you may want to include with your collaborators - here are some things you might desire to consider:

            - Your proper noun  - Projection title  - Links to website & social media  - Contact details                      

Once you take written your README.dr. file, scroll to the lesser of the page. You can now commit the file to the repository. To practice so, specify a commit message which briefly describes the changes. Commit messages should concise, only descriptive. Select Commit directly to the principal branch and then click on Commit changes.

Exercise two: Edit the .gitignore file

Repositories often have a file called .gitignore and nosotros are about to brand one shortly. In this file you specify which files y'all want Git to ignore when users make changes and add files. Examples include temporary Word, Excel and Powerpoint files, .Rproj files, .Rhist files, etc. Some files y'all might want to merely have on your local repository (i.due east. on your computer), simply non online every bit they might be too big to store online.

Select the .gitignore and click 'Edit'. As you volition see, the template GitHub provides for R already includes many file types normally found in R projects that should not be included in shared repositories. You tin can add more files by specifying each file blazon on a separate line. Coil to the lesser of the certificate and paste the following additions, without overwriting the rest. Comments in the file are designated by a # sign. So, commit the file to the main branch.

            # Forbid users to commit their own .RProj *.Rproj  # Temporary files *~ ~$*.doc* ~$*.xls* *.xlk ~$*.ppt*  # Prevent mac users to commit .DS_Store files *.DS_Store  # Prevent users to commit the README files created by RStudio *README.html *README_cache/ #*README_files/                      

Practise 3: Create folders

Think of different folders yous may desire to include in your repository. If working on a shared repo, discuss with your collaborators. For the repository for a lab group, some examples include: manuscripts, data, figures, scripts, scripts/users/personal_folder_your_name. To make a new folder, click on Create new file and add in the name of your new folder, east.yard. manuscripts/ before the file name, in this case a quick README.md file. When creating folders inside your repo through GitHub's website, you ever need to brand at least one file associated with them, you can't merely create an empty folder. You lot tin then write and commit the file.

GitHub etiquette

If you'll be sharing the repository with collaborators and even for your ain benefit, it's a good idea to define some rules on how to employ the repository before we start working within it - for example what GitHub and coding etiquette should people exist following? Is there a prefered folder construction, file naming organization?

We tin can make a new github-etiquette.dr. file that outlines the rules that people with access to your repository should follow.

Do 4: Write a github-etiquette.md file

Get to your lab'south chief repository, click on Create new file and add github-etiquette.medico as a file proper noun. Remember to include the file extension .md - otherwise GitHub won't know what'southward the file format.

A few GitHub rules:

• Go on file paths short and sensible.
• Don't use funky characters and spaces in your file names, these cause trouble because of differences in Mac/Windows systems.
• Always pull before you offset working on your projection and before you push button in case someone has done any work since the last time you pulled - you wouldn't want anyone's work to become lost or to have to resolve many coding conflicts.

3. Sync and collaborate with your repository through RStudio

The "commit-pull-push" workflow can be embedded within RStudio using "Projects" and enabling version command for them - we volition be doing that shortly in the tutorial.

Log into your Github account and navigate to the repository yous created earlier

Click Code and re-create the HTTPS link.

Now open RStudio, click File/ New Project/ Version control/ Git and paste the HTTPS link from the Github repository into the Repository URL: field. Select a folder on your figurer - that is where the "local" re-create of your repository volition be (the online i being on Github).

Once you endeavour the project, yous volition be asked to cosign. You only need to do this once on your computer. In that location are multiple possible ways to authenticate your GitHub account on your calculator and make it work with RStudio. Here are two recommended approaches:

Sign in via Personal Access Token (All platforms, recommended)

Create a Personal Admission Token (All platforms)

Creating a Personal Access Token (PAT) is the recommended most secure method for all platforms. However, if you are using Windows (as of September 2021) you may exist able to cosign using the quick "Sign in via browser" option. If you wish to exercise and so, follow the instructions under the side by side button (Sign in via internet browser (Windows just)).

You lot can create a PAT using the GitHub website and specify the exact permissions that it provides your computer when interacting with GitHub in the cloud. Nosotros will create a token that allows for admission and modifications to the repository.

Step 1: Create PAT at GitHub website

1. In the GitHub website, click on your contour picture in the peak-right corner and go to Settings.
2. In the left sidebar, go to Developer settings. Then, again in the left sidebar, click Personal access tokens.
3. Click Generate new token. Give the token a proper noun (something that describes what you volition use it for, e.g. "Local machine token").
4. Select an Expiration fourth dimension. You can set to no expiration and so that you will not take to re-cosign.
5. And so, select the permissions you grant to this token. Simply select the "repo" group in bold.
6. Click Generate token. Make certain to re-create the token and shop it securely, since the website volition non prove it to you again. (If something goes wrong, you tin always generate a new ane.)

You can also follow this guide with screenshots: https://docs.github.com/en/authentication/keeping-your-account-and-data-secure/creating-a-personal-access-token

Step two: Authenticate (within RStudio)

On Windows, in one case yous interact with a private repository you should become a prompt looking like this:

Simply paste the token into the Personal admission token field and go along.

On Linux/macOS, yous should get a prompt for your username and then for your countersign. Input your GitHub username, and under password, input your PAT instead.

Your hallmark should now be successful and you tin interact with GitHub repositories directly from RStudio.

Sign in via cyberspace browser (Windows, fast)

Sign in via internet browser

On Windows, once y'all try to clone a private repository from GitHub, you should go a prompt similar this:

Simply click "Sign in via browser" and authorise your device in the browser window that pops upward. Authentication may happen automatically if already logged into GitHub in your browser.

If you practise not get a window like this, simply simply a request to input your username, follow the instructions for Personal Access Token to a higher place.

Troubleshooting (GitHub in RStudio)

Practice yous have troubles with authenticating with GitHub? Follow this guide to remove GitHub authentication from your computer and sign in anew.

Important: This is relevant if you used GitHub in an RStudio projection earlier August 13, 2021 and it has since stopped working. This has likely occurred due to changes implemented by GitHub on that appointment to make authentication more secure. Here is how to fix this issue, past removing GitHub authentication credentials from your figurer and logging in once more. These instructions may be helpful for other GitHub authentication issues besides.

Step one (all platforms):

In your R session in RStudio, execute the following lines:

                              install.packages                (                'gitcreds'                )                                                library                (                gitcreds                )                                                gitcreds_delete                ()                                                          

Do not worry if yous receive a alarm or error and go on to the next step. Shut RStudio (of import!).

Pace ii:

Windows

In the Starting time Carte du jour, search for and open Credential Managing director. Click on Windows Credentials. For all listed items that include 'github', click on the pointer and then click Remove. Close the window.

Linux

In the terminal, execute:

              git config                --global                --unset                credential.helper                rm                $Abode/.git-credentials                          

macOS

In the terminal, paste the following and press Return:

              git credential-osxkeychain erase                host                =github.com                protocol                =https                          

Do non worry if you do not find the credentials (under Windows) or the commands produce an error. Go along to Step iii.

Pace 3: Open up your projection inside RStudio over again and endeavour to interact with the GitHub repository (due east.g. Pull whatever changes). You should see a prompt to authenticate. Follow the instructions under the buttons above (Personal Access Token or Login via Browser).

Before your outset commit from your computer, you will demand to configure your username and email. This is easily done, and you only need to do it one time, later you tin commit-pull-push at your convenience!

In the top right corner of the RStudio screen (in the Git tab), click on More/Shell.

Annotation: If using a Windows PC, the Shell option should launch Git Bash. If it doesn't open up Git Bash, please find Git Bash on your estimator instead. You lot tin can normally search for information technology in the Starting time carte, or correct-click on the empty space in whatsoever folder in the File Explorer and click "Git Fustigate Here".

Re-create the following code:

            git config --global user.email your_email@example.com # Add together the email with which you lot registered on GitHub and click Enter  git config --global user.name "Your GitHub Username" # Add your GitHub username and click Enter                      

If it worked fine, there will be no messages, yous tin can shut the crush window and do your commit again, this time it will work!

Hiccups?

We know that in that location might be problems with the newest updates of the Mac software and installing git and linking information technology with RStudio. The solutions appear to be very specific to the Mac version yous have, so if the above steps didn't work, a adept starting point is googling "rstudio tin can't notice git mac your version" and trying out the suggested solutions.

Once the files take finished copying across (this may accept a while depending on the size of the repo yous're joining), you will notice that a few things about your RStudio session have changed: there is a Git tab in the superlative right corner of RStudio, and all the files that are in the repo are now on your computer every bit well.

Y'all are at present set up to offset making changes and documenting them through Github! Note that you lot tin can't push empty folders.

You lot tin can open up some of the files you fabricated online earlier - for example if you click on your README.md file, it will open in RStudio and y'all can make changes. Add some more text just for the sake of exemplifying how version control works. Relieve the file in the same location (i.e., your repository).

If yous click on the Git tab you lot will see that now your README.md file is listed at that place. Add a tick next to it. At present information technology has an Grand - this means yous accept modified the file. If there'due south an A, that'southward an added file, and a D is a deleted file.

If y'all select the README.md file and click on Diff, y'all will see the changes y'all have made. Once the file is selected, it is staged, ready to be commited to Github.

Click on Commit and add in your commit bulletin - aim to be concise and informative - what did you do? Once you take clicked on Commit, y'all volition get a message near what changes y'all have made.

You lot will see a message saying that your co-operative is now i commit ahead of the origin/main co-operative - that is the branch that is on Github - we at present need to let Github know about the changes we take fabricated.

We tin can't echo it enough: always Pull earlier you Push. Pull means that you are retrieving the most recent version of the Github repository onto your local branch - this command is specially useful if several people are working within the same repository - imagine there was a second script examining soil pH along this height gradient, and your collaborator was working on it the same time as you - you wouldn't want to "overwrite" their work and cause trouble. In this case, you are the only one working on these files, just it's still good to develop the exercise of pulling before you push. Once yous've pulled, you'll run into a message that y'all are already up to engagement, yous tin can now push! Click on Push, wait for the loading to be over and then click on Close - that was it, you accept successfully pushed your piece of work to Github!

Become dorsum to your repository on Github, where yous tin now see all of your updated files online.

Click on your script file and then on History - this is where you can see the unlike versions of your script - obviously in existent life situations yous will brand many changes as your work progresses - here we simply have two. Thanks to Github and version command, you don't demand to save hundreds of almost identical files (eastward.k. Dissertation_script_25thFeb.R, Dissertation_script_26thFeb.R) - you accept 1 file and by clicking on the different commits, yous can see what information technology looked like at different points in time.

You are now ready to add your scripts, plots, information files, etc. to your new project directory and follow the same workflow equally outlined above - phase your files, commit, pull, push.

Potential problems

Sometimes y'all will see mistake letters as you endeavour to commit-pull-push. Usually the error message identifies the trouble and which file it'southward associated with, if the message is more obscure, googling information technology is a good step towards solving the problem. Here are some potential problems that might ascend:

Lawmaking conflicts

While you were working on a sure part of a script, someone else was working on it, too. When you go through commit-pull-push button, GitHub volition make you make up one's mind which version you lot want to continue. This is chosen a code conflict, and you tin can't proceed until you've resolved it. You will encounter arrows looking like >>>>>>>>> around the two versions of the code - delete the version of the code you don't want to keep, likewise as the arrows, and your conflict should disappear.

Pushing the incorrect files

If you accidentally push what y'all didn't intend to, deleted many things (or everything!) and and so pushed empty folders, you can revert your commit. You can keep reverting until y'all reach the point in fourth dimension when everything was okay. This is an easy way out if you're the only person working in the repository - be aware that if there are other people that accept committed to the repository, reverting will likewise disengage all of their work, equally reverting refers to the repository as a whole, not just your ain piece of work in it.

Using these "undo" commands can be daunting, so brand sure you read up on the different commands before yous attempt anything that may delete work permanently: hither'due south a starter. It'south a good idea to regularly support your repository to an external hard drive juuuust in case!

Verified commits

When you browse your commit history through the GitHub website, you may notice that commits made through the website are listed every bit "Verified", while commits pushed from your computer are non. This is generally non a big deal, but in large collaborative projects you may desire to verify your locally made commits - here is a guide how.

4. Sync and interact with your repository through the command line

Traditionally, Git uses the command line to perform deportment on local Git repositories. In this tutorial nosotros ignored the command line but information technology is necessary if yous desire more than control over Git. There are several splendid introductory guides on version control using Git, eastward.g. Prof Simon Mudd'south Numeracy, Modelling and Data direction guide, The Software Carpentry guide, and this guide from the British Ecological Order Version Control workshop. For more generic command line tools, look at this general cheat sheet and this crook canvas for mac users. Nosotros have too created a table and period diagram with some bones Git commands and how they fit into the Git/Github workflow. Orange lines refer to the core workflow, the blue lines draw actress functions and the green lines deal with branches:

Command	Origin	Destination	Description
git clone REPO_URL	Personal Github	Local	Creates a local copy of a Github repo. The URL can be copied from Github.com past clicking the `Clone or Download` button.
git add README.md	Working Dir	Staging Area	Add "README.physician" to staging surface area.
git commit	Staging Area	Local	Commits changes to files to the local repo.
git commit -a	Working Dir	Local	adds and commits all file changes to the local repo.
git pull	Personal Github	Local	Call back any changes from a Github repo.
git push	Local	Personal Github	Sends commited file changes to Github repo.
git merge	Other branch	Current branch	Merge whatever changes in the named co-operative with the current co-operative.
git checkout -b patch1	NA	NA	Create a branch called "patch1" from the electric current co-operative and switch to it.
git init	NA	NA	Initialise a directory as a Git repo.
git log	NA	NA	Display the commit history for the current repo
git status	NA	NA	See which files are staged/unstaged/changed
git unequal	NA	NA	Encounter the difference betwixt staged uncomitted changes and the near contempo commit
git stash	NA	NA	Save uncommitted changes in a temporary version and revert to the nigh contempo commit

Below is a quick exercise then you lot can familiarise yourself with these control line tools. There are a few ways to use collaborate with Git using the last:

1. If you are already in RStudio on a Mac or Linux machine, you can open up a last inside RStudio by going to Tools -> Terminal -> New Terminal in the menu.
2. If you are on a Mac or Linux auto you lot could just open up a terminal plan and run Git from there. Virtually Mac and Linux machines will have Git installed past default. On Mac you can get open a final past going to: Applications/Utilities/Terminal.app.
3. If y'all are on a personal Windows motorcar, you can run Git using Git Bash, which can exist installed when you installed Git. You should exist able to launch it from More than -> Beat out in RStudio. If that doesn't work, wait upwards the programme nether your Start Menu.

One time you take opened a terminal using one of the above methods, start by creating a binder somewhere on your local organization called git_test, using the mkdir (make directory) control by typing the following into the terminal and hitting "Enter". For case, to create the directory in the Documents folder:

                          mkdir              ~/Documents/git_test                      

And so enter that folder using cd (change directory):

To brand the folder into a Git repository:

Now the folder has been made into a Git repository, assuasive you to runway changes to files. At present, lets create a README.md file inside the repository and put some text in it, using any text editor y'all are comfortable with. Make sure to identify this README.doc file into the repository binder on your device then information technology can exist found!

You tin can create empty text files via a single command in the shell:

                          touch              README.doc              bear on              .gitignore              touch              test.R                      

Now, to add together a file to be tracked past the Git repository:

To check what files have been staged and unstaged changes:

The README.md file has now been added to the staging area, but has not yet been committed to a version of the repository. To commit a version:

            git commit              -m              "Your commit bulletin here"                      

Currently, the Git repository is still merely on our local computer. Versions are beingness committed, but they are non being backed up to a remote version of the repository on Github. Go to Github and create a repository called git_test, similar you did earlier on in the workshop, but this time don't create a README.doc because we have only made one on the local computer. Now, copy the HTTPS link for that repository. In the terminal, link the local Git repository with the remote repository using the following code, replacing <HTTPS_LINK> with the link you copied:

            git remote add origin <HTTPS_LINK>                      

Then brand the first push to that newly linked remote repository:

At present you tin proceed editing files, adding changes (git add together <FILE>), committing changes (git commit), pulling (git pull) and pushing (git button) changes, like to the process y'all did with clicking buttons in RStudio. Feel free to explore some of the more avant-garde commands laid out in the tabular array and menstruum diagram above. You can also bank check out a more than advanced command line tutorial written past Prof Simon Mudd for Numeracy, Modelling and Data direction guide.

This tutorial was developed as part of the collaboration between Coding Gild and the NERC E3 Doctoral Training Plan. To learn more about the E3 DTP, check out the program's website.

harrellfackon.blogspot.com

Source: https://ourcodingclub.github.io/tutorials/git/

Share this post