How to Create a Project in R and Upload It to Github

By Aaron Gullickson

Aaron Gullickson will teach GitHub for Information Analysis remotely on March fifteen-17, 2022. Acquire to use GitHub and integrate it into your workflow.

Increasingly, bookish scholars, information scientists, and quantitative researchers are turning to GitHub for collaboration and to share data, lawmaking, and results. GitHub allows people to host public and individual "repositories" that let for the easy communication of research procedures and results. Underlying the GitHub compages is the version command system, git, which provides further benefits to researchers.

Why should you lot use git/GitHub?

Version control systems like git have long been used past programmers to sanely collaborate and organize software projects, and they can serve the same purpose for quantitative researchers who spend much of their time coding. If you lot have never used version control systems, then the process tin can seem arcane and the benefits unclear. One time y'all starting time using a version command arrangement, withal, information technology becomes hard to encounter how y'all ever got by before. What are some of the benefits of this arroyo?

First and probably foremost, git will allow you lot to interact sanely. Users make changes to lawmaking ("commits") and and so "push" them to a centrally shared repository (located at GitHub, for example). Other users can clone this repository and and then easily "push" their own changes as well as "pull" in other changes, assuasive everyone to easily stay in-sync. Complex coding projects can too be "branched" so later merged back into the main code base of operations to avoid conflicts betwixt users.

2d, by using version control systems, you lot effortlessly create your own research log. All changes to your code base are committed to the repository with a brief clarification of your changes. Collectively these commits serve as a research log of your work. You no longer accept to retrieve when exactly y'all added that one variable to the model. The changes are right there in your history log.

Third, yous can cease fearing change. Have y'all been in the situation where you know your code kind of works, just maybe it'southward not the best? People oftentimes practise one of 2 things in this situation. You lot might just go out it alone, because why mess with a piece of lawmaking that seems to work? Are you trying to acrimony the coding gods? Alternatively, you lot might decide to fix information technology, but fearful that you might make it worse, you duplicate the file (with a name like "analysis_just_trying_a_thing_v2.R"). Neither of these approaches is nifty. If yous employ version control, you can brand radical changes to your code without fear. Did you mess it up? No worries, simply revert dorsum to the last "commit" and effort again. To describe out an analogy from Hadley Wickham, the "free-climbing" approach to coding is dangerous and scary. Git is there to take hold of you lot when you fall.

Quaternary, you tin finally go along your project tidy. The tendency I note in a higher place to simply indistinguishable files with slightly different names ("newspaper-v2.1_06272017_FINAL_REALLY_THIS_TIME.docx") is its own form of very inefficient version control. Over time, the directory containing your project becomes littered with files, and the ability to sympathize this chaos is locked somewhere deep in your ain brain alone. If yous practise this form of horizontal versioning, so assistance is on the way! Proper version control systems, like git, apply "vertical" versioning. Because all of your changes are tracked on whatsoever given file, in that location is no need to duplicate a bewildering assortment of slightly different versions of the same file. Considering you no longer need to fear alter, you can keep your project tidy and compact. You but need one script to organize and clean your information. You simply need one file to write the paper. Your projection will suddenly become easier to navigate for yourself and everyone else.

Your Get-go GitHub Repository

Have I piqued your interest? Let's talk about how to ready a git repository using RStudio and link information technology to an online repository on GitHub. The instructions hither assume that you have some directory with R code in it that y'all want to turn into a repository on GitHub. You lot will likewise need to create an account on GitHub. I also will assume you are using RStudio to run R which provides a nice user interface for working with git.

Git itself is a command line interface. Y'all can piece of work with it from inside RStudio using a GUI interface only to get information technology prepare properly, yous volition demand to exist able to work on the command line in the working directory of your project. The easiest way to use the command line in RStudio is to apply the "Concluding" tab right adjacent to the console tab in the lower left panel. You lot should see something like:

If you are on a Windows organization, you will desire a UNIX mode command line. When you install git (as described beneath), you will proceeds access to a UNIX mode terminal with an application chosen Git Fustigate. Y'all tin can set up Git Bash to exist your default terminal in the RStudio preferences.

One thing to keep in listen is that GitHub has a single file size limit of 100 mb. If you have a unmarried file in your directory that is larger than 100 mb, and then GitHub will not allow you to push that file upward to your GitHub repository. This event near frequently arises with big datasets. Sometimes this can be fixed by compressing the file, since R can read straight from compressed files. Another solution is to host the large file somewhere else (e.1000. DropBox).

Step Zero: Install and configure git

To get started you will need to install git on your local arrangement. Git is extremely lightweight and piece of cake to install and is available on all major operating systems. You can download and install the version for your operating system hither.

Once you lot install git, you will want to fix a couple of initial parameters before you go started. The easiest fashion to set up git is the usethis R package, which includes several functions for working with git. Virtually importantly, y'all need to ready a user proper name and e-mail that volition be shown for all commits. You tin do this with the following code:

library(usethis) use_git_config(user.proper name = "Jane Doe", user.e-mail = "jane@example.com") git_vaccinate()

When you perform git operations on your GitHub repository, yous volition need to authenticate with GitHub. Every bit I write this, you lot tin do this by entering your GitHub user proper noun and password. However, this functionality will soon be going away and you will be required to have a personal access token (PAT) to authenticate with GitHub. Luckily, y'all tin easily set up a PAT through the usethis package as well. Beginning, you lot can use the create_github_token() command in R which will directly you to a GitHub folio that will generate a PAT for your use:

create_github_token()

You can also get to this page for instructions on generating a PAT.

Once you accept a PAT, copy it and enter the following into R:

gitcreds::gitcreds_set()

This will and so guide you through the process of setting your PAT. One time this PAT is prepare upward, pushing and pulling to GitHub should work seamlessly.

To check that everything seems to be working, you lot can always use the git_sitrep() command in the usethis package.

usethis::git_sitrep()

Pace One: Turn your lawmaking into an R project and git repository

Now that git is set up, you can turn that directory of code into a proper git repository. To accomplish this, you will offset demand to turn your directory into an R project.

As an example, I have gear up a uncomplicated directory that I want to convert into a git repository, pictured below:

This repository just has some data in CSV format, an R script with some code, and an R Markdown file that I am using as a lab notebook.

Although this may be a "project" in my caput, it is not all the same an R project. If I plough this directory into an R projection, RStudio volition add an *.Rproj file with some additional information. R projects are useful in their own correct, only the real advantage here is that I can use the built-in git features of RStudio on an R project.

To plow this into an R project, you will become to File > New Project which volition bring upward a dialog including several options for creating the project. In this case, you desire to create the project from an existing directory.

From the side by side dialog, y'all tin can browse to your directory and then just click the create push button to turn it into an R project. RStudio volition refresh and your working directory will shift to the chosen directory where yous will run into a new *.Rproj file.

Now that your directory is an R projection, you want to turn this directory into a git repository. To do this, you will use the command line equally described above. Once yous take a command line interface in the right working directory of your project, but type:

git init

This will create a git repository in your working directory. Because yous are using the command line, RStudio volition typically not immediately recognize the change, so you should close RStudio and re-open up this project. To re-open the project, you lot can double-click the *.Rproj file or use the dropdown menu for managing projects in the upper-right corner of RStudio itself. One time the project is re-opened, you lot should see an additional "Git" tab located in the upper right panel that should expect something like this:

Stride Two: Time to commit

The git tab is the principal way that yous will collaborate with git now that we accept it prepare. The tab will testify yous new files that are not yet tracked by git besides every bit files that take been modified or removed since the last commit. The question marker icon for the status of each file is showing me that none of the files in my directory are currently being tracked (since I simply created this repository).

What I need to do is commit these files. That will so tell git to track them allowing me to besides commit time to come changes. To commit, just click the "Commit" button to bring upwardly the commit dialog. From this dialog, you need to select all the files you desire to commit and add a commit bulletin equally the picture below shows:

One time you click commit, all of these files volition be committed and will disappear from the git tab. Congratulations, you have just made your commencement commitment to the world of git! For fun, you can view the history dialog from the git tab, to encounter the history of all your commits (not many yet).

Step Three: Brand a new repository on GitHub and push!

Committing the files ensures that they are now tracked locally, simply I still practise not have a remote repository on GitHub. The final step is to set upwards that repository and push all of the local commits to information technology.

To ready a new repository on GitHub, you simply demand to utilise the "+" dropdown card in the upper right of your GitHub contour page and select the "New repository" option. The new repository dialog has several options, but for now all you demand to do is enter a name for this repository. You can as well make up one's mind whether yous want the repository to be public or individual.

Once you create the repository, you lot volition see a screen that gives you several options for initializing the lawmaking in your repository. Nosotros want the second option of "…or push an existing repository from the command line" which will requite y'all code that looks something similar:

git remote add origin https://github.com/AaronGullickson/example_project.git git branch -M main git button -u origin chief

The outset line volition look different considering you are not me, and so you should copy that code rather than what I have above. All you need to do is copy and paste that lawmaking to the command line interface in your project directory. This will setup GitHub as the remote "origin" repository and button all of your existing local commits to information technology. You lot can then refresh your GitHub repository folio and run into that all of your files and lawmaking are at present showing.

Because you used the command line to set up your remote repository, yous should restart RStudio and re-open your project to refresh it. One time you practice so, you should see that the big arrows saying "Pull" and "Push button" are no longer greyed out. Y'all now have the full capability to perform the basic git workflow of pull-commit-push using the RStudio git tab.

The bones git workflow

Now that you have your R project connected to GitHub, you lot can use the basic git workflow to go on your project synced between the two repositories. When you sit down to piece of work on the project, you should do the post-obit:

1. Pull changes from the main repository on GitHub to the local repository. This will ensure that your local repository has all of the latest changes fabricated to the key repository (for example by a co-author).
2. Make changes to the project as desired. When you lot are satisfied with those changes, commit them to your local repository with a helpful message like "imputed missing values" or "corrected my horrible grammar."
3. Committing but adds the changes to your local repository. If y'all desire to make sure everyone has access to those changes, you lot then push the changes to the fundamental repository on GitHub.

Lets go through a uncomplicated instance of this workflow on my projection. I want to change the default ggplot colors of the graph in my R Markdown document to something more … colorful. I am going to use the wonderful Wes Anderson R color palette instead. To exercise that I need to add the appropriate library and the following line to my ggplot command:

scale_fill_manual(values=wes_palette("Darjeeling1", iii, type = "discrete"))+

Once I brand these changes, the git tab will show that my R Markdown file has been modified:

Striking the commit button will bring up the commit dialog which will bear witness me all of the pending changes. I tin can select any changes I want to commit and write a helpful commit message.

Once I commit these changes, I can then use the handy "Push" button to push these changes up to the GitHub repository. You can run across for yourself how well this works by exploring this example GitHub repository.

In many cases you may repeat step (2) multiple times earlier pushing. When possible it makes sense to break upward your commits into logical chunks in which you complete a sure task rather than "all the stuff I did today." This will make it easier to understand your log history later. Then y'all may actually do 3-4 smaller commits then when you button, all of those commits will be pushed upward to the GitHub repository at the same time.

Yous tin can exercise so much more!

This tutorial is intended to get y'all set upwards with the bones git workflow connecting a local R project to a GitHub repository. This provides powerful functionality simply is really only the tip of the iceberg of what git can do for you. Git offers the ability to work in multiple branches and to revert changes. GitHub offers additional features for collaboration, most notably the wonderful pull request feature. But even the basic git workflow can help change the way that your organize your work and allows you to lawmaking with the confidence that you lot are no longer "free-climbing" your enquiry. Happy gitting!

mccoyforaw1949.blogspot.com

Source: https://codehorizons.com/making-your-first-github-r-project/

Share this post