Are you ready for Shiny?

qplot() is defined in the ggplot2 package, which means that you will not be able to use qplot() until you install and load the ggplot2 package. If you try to use qplot() without loading the ggplot2 package, R will return the error

Error: could not find function "qplot"

You can install the ggplot2 package from CRAN with

install.packages("ggplot2")

Once you’ve installed ggplot2 you can run the command above with

library("ggplot2")
qplot(Sepal.Width, Sepal.Length, data = iris)

You will need to load ggplot2 with library() once in each new R session that you would like to use qplot() in.

The error message suggests that you have not yet run cat <- 4. In this case, R will evaluate the expression with the object named cat that comes in base R. This object is a function. Since + does not know how to operate on functions, it returns an error message.

cat
## function (..., file = "", sep = " ", fill = FALSE, labels = NULL, 
##     append = FALSE) 
## {
##     if (is.character(file)) 
##         if (file == "") 
##             file <- stdout()
##         else if (substring(file, 1L, 1L) == "|") {
##             file <- pipe(substring(file, 2L), "w")
##             on.exit(close(file))
##         }
##         else {
##             file <- file(file, ifelse(append, "a", "w"))
##             on.exit(close(file))
##         }
##     .Internal(cat(list(...), file, sep, fill, labels, append))
## }
<bytecode: 0x109fe8008>
<environment: namespace:base>

cat + 1
## Error in cat + 1 : non-numeric argument to binary operator

Compare this to

cat <- 4
cat
## [1] 4

cat + 1
## [1] 5

Notice that the error message would have been more clear had we used a different object name, one that is not already used by base R, e.g.

dog + 1
## Error: object 'dog' not found

But in practice it is difficult to tell which names are already in use and which are not.

You can subset the result of make_list(), but not make_list() itself.

When you run the name of an object in R, R will show you the contents of the object. If the object is a function, this content will be the code in the function body, e.g.

make_list
## function() {
##     list(date = Sys.Date(),
## 	     time = Sys.time(),
## 	     timezone = Sys.timezone())
## }

make_list$time
## Error in make_list$time : object of type 'closure' is not subsettable

This body of code is not subsettable so make_list$time fails.

To return the result of a function in R, you must follow the function name with a pair of parentheses, (). If you add these parentheses to the call above, R will use $time to subset the list returned by make_fun(), which produces a valid result.

make_list()
## $date
## [1] "2015-03-12"
## 
## $time
## [1] "2015-03-12 17:11:59 EDT"
## 
## $timezone
## [1] "America/New_York"

make_list()$time
## [1] "2015-03-12 17:11:59 EDT"

lst$numbers and lst[[1]] will return the first element of lst as a vector of integers. lst[1] will return a new list that has one element – the first element of lst.

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

class(lst$numbers)
## [1] "integer"
class(lst[1])
## [1] "list"
class(lst[[1]])
## [1] "integer"

In summary, subsetting a list with dollar signs or double brackets will return elements of the list just as they are. Subsetting with single brackets will return the elements as part of a new list. This is an important distinction because many R functions cannot work with an element when it is contained in a list.

You can calculate the sum with

sum(pressure$temperature)
## [1] 3420

pressure$temperature returns the temperature column of the pressure data frame as a vector. The sum function calculates the sum of the vector.

You can draw a scatterplot with the plot function

plot(pressure$temperature, pressure$pressure)

Or you could use the qplot function in the ggplot2 package

library(ggplot2)
qplot(temperature, pressure, data = pressure)

You can make a scatterplot in R with other functions as well. As long as you know at least one way to visualize your data, you will be able to include visualizations in your Shiny apps.

sum will return an NA because it no longer has enough information to calculate the sum of the column. You can avoid this by including the argument na.rm = TRUE. Then sum will return the sum of all of the elements that do not equal NA.

sum(pressure$temperature)
## [1] NA

sum(pressure$temperature, na.rm = TRUE)
## [1] 3420

Your function should look and work like this.

my_mean <- function(vec) {
  sum(vec)/length(vec)
}

my_mean(1:10)
## [1] 5.5

To make the most of Shiny, you should feel comfortable writing your own functions in R.

The code returns

f()
## 1 2

f returns the last line of its function body, c(x, y), which uses an object named x. There is no object named x defined in the function body or arguments of f, so f looks in the environment where f was defined. There it finds an object named x that is equal to 1.

The code will return 1. change_obj creates a copy of obj in its local environment when it runs, and it gives that copy the value 2. However, this does not affect the verison of obj that lives in the global workspace. As a result, obj still returns 1 after you run change_obj(obj).

As a general rule in R, the value of an object will not change when you change a copy of the object. However, there are some exceptions to this rule. For example, reference class objects (also known as RC or R5 objects) will change when a copy of the object changes. The Shiny package uses this behavior, but you should realize that it is not common in other parts of the R language.

You can install the Shiny package by running the R command

install.packages("shiny")

R will then download Shiny from cran.r-project.org and install it on your hard drive (so you will need to be connected to the internet when you install the package).

You only need to install a package once, but you may wish to reinstall the package when an updated version becomes available.

To use the Shiny package, you will need to load it with

library(shiny)

You’ll need to reload Shiny each time you start a new R session (if you want to use Shiny in that R session).

Your working directory is a folder on your computer that R associates itself with. When you ask R to open a file, it will look for the file in the working directory. When you ask R to save a file, it will save the file in the working directory. In general, R will interpret file paths as if they begin in the working directory. You can prevent this by using full file paths that start at your root directory.

You can learn the location of your working directory with

getwd()

You can change your working directory with setwd. Provide setwd with a file path that leads to the new working directory, e.g.

setwd("/Users/garrett/")

You can also set your working directory with the RStudio menu command Session > Set Working Directory > Choose Directory…

or with the More > Set as Working Directory option in RStudio’s Files tab.

An R script is a text file that contains R code.

When you “source” an R script, R reads the file and runs all of the code in the script. You can source an R script with the source command. Give source the filepath to the script you wish to source, e.g.

source("/Users/garrett/script.R")

You can also source a script by opening it in RStudio’s Scripts pane and then clicking the “Source” icon in the top right corner of the pane.