Assignment and object names

Object names cannot start with a digit and cannot contain certain other characters such as a comma or a space. You will be wise to adopt a convention for demarcating words in names.

i_use_snake_case
other.people.use.periods
evenOthersUseCamelCase

Make another assignment:

this_is_a_really_long_name <- 2.5

To inspect this, try out RStudio’s completion facility: type the first few characters, press TAB, add characters until you disambiguate, then press return.

Make another assignment:

science_rules <- 2 ^ 3

Let’s try to inspect:

sciencerules

## Error in eval(expr, envir, enclos): object 'sciencerules' not found

sceince_rules

## Error in eval(expr, envir, enclos): object 'sceince_rules' not found

Implicit contract with the computer / scripting language: Computer will do tedious computation for you. In return, you will be completely precise in your instructions. Typos matter. Case matters. Get better at typing.

Built-in functions

R has a mind-blowing collection of built-in functions that are accessed like so:

functionName(arg1 = val1, arg2 = val2, and so on)

Let’s try using seq() which makes regular sequences of numbers and, while we’re at it, demo more helpful features of RStudio.

Type se in the console and hit TAB. A pop up shows you possible completions. Specify seq() by typing more to disambiguate or using the up/down arrows to select. Notice the floating tool-tip-type help that pops up, reminding you of a function’s arguments. If you want even more help, press F1 as directed to get the full documentation in the help tab of the lower right pane. Now open the parentheses and notice the automatic addition of the closing parenthesis and the placement of cursor in the middle. Type the arguments 1, 10 and hit return. RStudio also exits the parenthetical expression for you. IDEs are great.

seq(1, 10)

##  [1]  1  2  3  4  5  6  7  8  9 10

The above also demonstrates something about how R resolves function arguments. You can always specify in name = value form. But if you do not, R attempts to resolve by position. So above, it is assumed that we want a sequence from = 1 that goes to = 10. Since we didn’t specify step size, the default value of by in the function definition is used, which ends up being 1 in this case. Be careful relying on this feature too often. If you use a function where you’re specifying more than 3 arguments, you might want to use name = value to avoid any later confusion.

Make this assignment and notice similar help with quotation marks.

yo <- "hello world"

If you just make an assignment, you don’t get to see the value, so then you’re tempted to immediately inspect.

y <- seq(1, 10)
y

##  [1]  1  2  3  4  5  6  7  8  9 10

This common action can be shortened by surrounding the assignment with parentheses, which causes assignment and “print to screen” to happen.

(y <- seq(1, 10))

##  [1]  1  2  3  4  5  6  7  8  9 10

Not all functions have (or require) arguments:

date()

## [1] "Tue Jan  3 12:56:45 2017"

Now look at your workspace – in the upper right pane. The workspace is where user-defined objects accumulate. You can also get a listing of these objects with commands:

objects()

## [1] "science_rules"              "this_is_a_really_long_name"
## [3] "x"                          "y"                         
## [5] "yo"

ls()

## [1] "science_rules"              "this_is_a_really_long_name"
## [3] "x"                          "y"                         
## [5] "yo"

If you want to remove the object named y, you can do this

rm(y)

To remove everything:

rm(list = ls())

or click the broom in RStudio’s Environment pane.

.gitignore

By default, Git tracks all directories and files in your repository. Sometimes you may not want it to track everything. For instance, if you store a private API key or personally-identifiable data, you won’t want these files tracked by Git. If you did, when you push your repository to GitHub your private files will be shared with the world.

You could just store all of these files outside your repository, but that’s a pain and inconvenient. Instead, you can create a .gitignore file in your repository. This is a special file Git uses to determine what files it should ignore. Any file listed in .gitignore will not be tracked by Git.

When you create a new repository in GitHub (as opposed to forking an existing one), you have the option to add a template .gitignore file depending on what programming language you will use. For example, the default .gitignore file for R is

# History files
.Rhistory
.Rapp.history

# Session Data files
.RData

# Example code in package build process
*-Ex.R

# Output files from R CMD build
/*.tar.gz

# Output files from R CMD check
/*.Rcheck/

# RStudio files
.Rproj.user/

# produced vignettes
vignettes/*.html
vignettes/*.pdf

# OAuth2 token, see https://github.com/hadley/httr/releases/tag/v0.3
.httr-oauth

# knitr and R markdown default cache directories
/*_cache/
/cache/

# Temporary files created by R markdown
*.utf8.md
*.knit.md
.Rproj.user

Most of these files are not sensitive, but are merely temporary work files that you don’t need to save and track using version control. You can specify files and directories by their full name, a partial name, or file extension. Starting with homework 2 I will always include a .gitignore in the repository, but for your own projects you will need to create these files as you find necessary.

Clone from the fork, not the master

Make sure whenever you clone a homework repository, use the url for the forked version, not the master repository. So for the first homework, I would use https://github.com/bensoltoff/hw01 when I clone the repo, not https://github.com/uc-cfss/hw01. If you use the master repo url, you will get an error when you try to push your changes to GitHub.

For an example, let’s say I wanted to make a contribution to ggplot2. I should fork the repo and clone the fork. Instead I goofed and cloned the original repo. When I try to push my change, I get an error message:

remote: Permission to hadley/ggplot2.git denied to bensoltoff.
fatal: unable to access 'https://github.com/hadley/ggplot2.git/': The requested URL returned error: 403

I don’t have permission to edit the master repo on Hadley Wickham’s account.

How do I fix this? I could go back and clone the correct fork, but if I’ve already made several commits then I’ll lose all my work. Instead, I can change the upstream url: this changes the location Git tries to push my changes. To do this:

1. Open up the shell
2. Change the current working directory to your local project (should use the cd command)

3. List your existing remotes in order to get the name of the remote you want to change.

   git remote -v

   origin  https://github.com/hadley/ggplot2.git (fetch)
   origin  https://github.com/hadley/ggplot2.git (push)

4. Change your remote’s URL to the fork with the git remote set-url command.

   git remote set-url origin

5. Verify that the remote URL has changed.

   git remote -v

   origin  https://github.com/bensoltoff/ggplot2 (fetch)
   origin  https://github.com/bensoltoff/ggplot2 (push)

Now I can push successfully to my fork, then submit a pull request.

Use the proper shell (GitBash for Windows)

Make sure to use the proper program when entering the shell. For Mac users, that is Terminal. For Windows users, that is GitBash: if you followed the setup instructions properly, you should have this program on your computer. Look for it under the Start Menu > Git > GitBash. If you try to use the Command Prompt, you will run into errors because it uses different commands than GitBash.