LIFE 4138: R Workshop 1 - Hannah Jackson

Welcome to your first R workshop! 😁🥳

The aim of todays session is to give you an introduction to R, talk you through some of its uses, and how it might be useful to you as bioinformaticians.

The learning objectives for todays session are as follows:

• To learn what R is, and how we interact with it
  • Focus on RStudio as an interface and project management system
• To understand data structures and basic functions in R
• To begin to use R’s plotting and visualisation tools
• To practice reading in datasets
• To learn how to install and load packages

We’ve got lots to cover, but no introduction can ever give you everything you need to know. The general idea here is to give you some level of familiarity with R, to remove the barrier to entry. Hopefully, you’ll be able to go away from these sessions with some confidence to practice, play, and gain some experience using everybodies (well, my) favourite coding language! We’ll have a quick introduction before we get into the coding proper, so bare with that and then we can play with some code! Right, let’s get cracking.

An introduction to R:

R is the coding language that I primarily use, and have used throughout my career thus far. I have dabbled in both Python and unix, but R is my favourite, and the one I return to most frequently. I never had a formal introduction to R, such as the one you guys are getting now - I taught myself out of necessity, as you can imagine, this took quite some time. Over the last decade, however, R has become increasingly wide spread and accessible - there are more courses than you can shake a stick at online.

Before we start proper, I also think it’s important to know that even people who have been using R for years still make mistakes. There’s a fair amount that I can do in R off of the top of my head (for example, I am currently making this document in RStudio!), but I regularly still have to google things. It’s really easy to feel a bit overwhelmed and unsure where to start with any coding language, but remember that nobody is expecting you to suddenly become fluent or memorise everything (as another example, I’ve just had to google how to code sub-bullet points to the above list!). We just want you to get some familiarity and experience.

Now then, I’ve said all of this, but haven’t answered one key question - what is R?!

R is a freely available programming language, developed in the early 1990s, made open source in 1995. R was developed on top of another language, S. S was a propriatory language, which ultimately, R became the open source version of.

R’s ethos was to develop something specifically for statistical computation and visualisataion - it was developed by researchers, for researchers.

So, in 2023, when you may have already begun to learn, for example, Python, why bother with R?

• The statistics and data-vis packages in Python are very recent, they did not exist 10 years ago!
• The “default” language varies from field to field, but certainly in ecology and evolution, you’re likely to be working with colleagues who use R (interestingly, ecologists were actually one of the first user bases of R)
• R is designed to be an efficient, interpreted language in a way that is fundementally different to the initial design of Python, which is typically interacted with via a script. R is designed to be a sort of “statistical conversation” where you interactively program.
• R was designed to have efficient data handling and storage mechanisms. There aer lots of types of data structures in R - these might seem unnecessary at first, but as we delve deeper into R and how it works, you’ll see why they’re important. R is written in a way that makes accessing reasonably sized datasets super efficient. Typically, this is not true of Python for a plethora of reasons that we don’t have the time to talk about (although admittedly this is getting better with the advent of modules such as Pandas)
• R contains a large collection of tools specifically developed for data analysis, as well as some really good built in data visualisation features!
• There is a huge multiverse that has been built around R with loads of different flavours associated with it. We’ll discuss this in more detail next week.
• Finally, R is fundementally designed to be simple. This is why it’s taught to non-programmers. You don’t have to do complicated things like for loops if you don’t want to (although we’re going to!). These can be avoided and R can be used for it’s base functionality of data analysis and plotting with no fancy extras if you don’t want them.

More specifically:

• R is a major part of the bioinformatic and biostatistics toolkits, and it isn’t going away any time soon.
• It was explicitly designed to handle data, particularly in a format known as data.frames - this is extremely important to the way that R functions
• It is free, and widely supported. In Evolution and Ecology papers in the last decade, 66% mention R. If you want to have a career in research, R is a vital skill.
• R is used by loads of major tech companies for their analytics - including facebook, google, and twitter!

So, how do we interact with R?

How do we use R to have those statistical conversations that I referenced earlier? There are 2 main ways. The first way is to use R directly through an interface known as “base R” or “native R”. This is using R in it’s purest form, and is actually quite tricky. If we load base R, we see a window like this:

This console window contains a load of gobbledegook abut version numbers etc., which will vary between individual machines and R installs. The OS that you’re running will also dramatically impact how your R window looks - this is the MacOS R version. Essentially, R is waiting for you to enter commands and tell it what to do next. As you can see, it’s not overly user friendly. That being said, the MacOS version is much nicer. The Windows version is clunky, and even less friendly. MacOS R has features not available on Windows too, which means using R across multiple machines can be a bit of pain.

Here, we will use an R IDE, known as RStudio (although you might also hear it referred to as posit). An IDE, or an interactive developer environment, is a built-on interface that helps you to run a programming language more easily and effectively. Other examples of IDEs can be found in Python - you might have come across Spyder or Jupyter for example. RStudio is completely free, and the best R IDE I’ve found. It’s also the most well supported, which is useful. There are others, but RStudio is particularly good. It will help to make your R journey much smoother, and actually helps you to spot errors in your code, which is always a bonus!

It looks a bit like this:

You’ll notice that my version of RStudio is differently coloured to yours - this is just due to personal preference. I spend lots of time staring at my R window rather intently, so having it darker really helps!!!

RStudio standardises the R interface across all platforms - it looks the same whatever OS you might be running. It also has a lot of powerful features that makes running R more straightforward, we’ll talk about these in more detail in the coming sessions. It also has great project management tools, which are endlessly useful when you’re working on multiple projects all at the same time!

Now, let’s talk through what all the bits are about.

As you can see above, the RStudio interface is made up of various parts. The first of which is the console. This, like native R, is waiting for your input in the “statistical conversations” that you’ll be having with R. It gives you a bit of an odd blurb about versioning etc. Each of the versions has a slightly odd name, I’m not sure why. Some of them are named after various albums but that’s as far as I’ve got with figuring out the naming system!

Anyway, theres loads of other stuff over on the right hand side, most of which is not imortant or useful to you right now. The “Environment” section keeps track of what you’ve got loaded in terms of datasets and variables etc., which can prove incredibly useful. Underneath, you can find file trees, plots that you have created, help files, and loads of other stuff that we can talk more about later on.

Project Management in R

Starting with project management tools feels a bit bizarre, but as someone who used R for many many years without this functionality, trust me, it’s easiest to get to grips with it early doors. Something that people struggle with, and something you might have come across with other coding languages, is where files are stored on a computer. RStudio has a great feature that will make this much easier to deal with. So, to demonstrate what I mean, type the following code into your console window, and press enter.

getwd()

This is the get working directory command, and is similar to commands in unix and python - in unix, you’d use pwd(). This command prints the working directory. (A quick note on functions in R which we will come back to - anything followed by () is a function i.e. something that takes an input and does something with it) If you run the getwd() command, you will get an output with a filepath, this is your current working directory, or, where R is looking for files! You can use R by putting stuff places and then using loads of really long and difficult path names to navigate through your computers file system and then sticking to the same directory. This quickly becomes a nightmare if you’re working on multiple projects at once though, because you end up trying to read files from and write files to the wrong directories, which you have to keep changing!

A better idea is to set up R using projects. These contain everything you need which is associated with a single bit of analysis or a single project (see what I did?) that you’re using R to work on. We will create a project for this session, which will create a self-contained directory, which R will always open when looking for files associated with what we’re doing, so you don’t have to try and navigate through complicated file structures within R itself. This is relatively straight forward, and we’ll do it now.

Up in the right hand corner of your RStudio window, there should be a bit of text that reads project or similar. Click on this, and you’ll get a drop down menu appear. From this menu, select “new project”, which will give you some more options. Chose “new directory” and call it something sensible, like “LIFE4138-R”.

Note: Don’t ever use spaces in file or directory names. It’s a really easy way to make sure that R will kick off at you! Use an underscore instead!

Finally, click “create project” and R will do the rest for you. Now, if you try the getwd() function again, it should print of the location of the new directory! It will also have changed the information displayed in the “files” section, having created a new folder wherever you asked it to. The easiest way to access files now is to pop them directly into this folder. You could now send someone this .Rproj file, and they’d have all the stuff they needed to recreate your work!

Anyway, that was an odd place to start, but it is important to get this part right.

Interacting with the R environment

When we interact with R, generally we are typing in the console. You can also write scripts (if you don’t have a script already open, you can open a new one by clicking the new script option from the menu at the top left of the screen - the white rectangle with a green + in the top corner!). A script is effectively a record of what you have done using R, allowing you to keep track. When you’ve written commands in a script, you can run them with your cursor on the line of code you wish to run, and pressing ctrl+enter (cmd+enter on MacOS). You may have come across scripts in python and unix, but generally we run them a little differently in R. We tend to run scripts interactively, either a single line or a few lines at a time, assess an output, and then run some more.

Let’s get started using R!

R as a calculator

First things first, R can be used as a basic calculator. Try typing the following commands into your script window and running them with ctrl/cmd+enter.

4
4 + 3
50 - 5
50 * 2000
9 / 3
10 ^ 2

You can see by doing this that R is able to perform basic mathematical functions. You’ll have noticed when you gave it a single number input, it echoed this number back to you. Play around with this, and see what R is capable of! Whilst you’re unlikely to often use R explicitly as a calculator, it is important to understand that it can handle numerics.

Note: the “>” prompt in the console is waiting for you to ask it something - try running the examples directly in the console as well as in script form!

R and text input

R can also interpret text! You can give it a character string, and it will print it back to you - try running the following:

"Hello world!"
'Hello world!'
Hello world

Note that the last example of this does not work, because R is looking for an object called Hello world which it cannot find. Without the quotation marks (either type is fine, but be consistent), it does not recognise the text as a string.

You’ll have got a funky error in the last example, something about an unepexted symbol - it likely wont have made much sense to you. This is fairly typical of R error messages unfortunately, they are famed for being tricky to interpret. They take some getting used to, but eventually you will be able to translate these bizarre messages into something that actually makes sense. For example, here, the “unexpected symbol” is referring to the space between the words “Hello” and “world”. Without the quotation marks, R expects these things to be functions or objects rather than a character string, and cannot process the space.

R as a logical interpreter

R can tell you whether a statement is true or false. This seems basic, but it will build up to create a useful tool alongside the other parts of it’s functionality that we’re discussing. The logical interpreter within R is a key part of how R functions as a peice of software, and is commonly in-built into many sophisticated functions and analyses. R will tell you if something is logical, or if it makes sense, by returning either TRUE or FALSE to an input. This is possible with numerical input and character strings - try the following for example:

2 == 2
5 > 10
9 <= 10
"Mario" == "Mario"
"Mario" == "Luigi"

Note: you’ll notice that when we are asking R if things are equivelant to one another, we use a double == sign. This is because a single = sign is used in R to asign something to a variable name. I’ll explain more about that in a minute!

Right, time to start building up to using R practically.

Assigning objects

So, it’s useful to know how to make a variable in your R environment. You may already know this from your adventures with Python. In Python, you use an = to assign a variable. Whilst you can do this in R, it’s best practice to use the <- operator instead. Note this creates an object in R, not a variable. This is because of the statistical nature of R - in statistics, a variable means something entirely different. I use <- because it is how I was taught to use R, but it’s okay to use = if you’d prefer. It does get complicated because of the == function, so I like to use <- instead. Some programmers get a bit picky and judgy if you use a different way to them, but my philosophy with R is if it works, it works.

So, why asign? It saves time and makes your scripting easier! There are some rules, however. Assignment is case sensitive, so don’t type something with loads of varying cases. Your object name also can’t start with a number, and some words that are associated with common functions like if or else are not allowed and will bring up an error message. Try the following and take note of the error messages you see:

my_number <- 150302

my_number2 = 204211

my_text <- “Hello world”

1my_text <- "Hello world"

for <- "Hello world"

Also, it is important to make sure you don’t name an object the same as a variable in your data structure, or you’ll run into some trouble!!

A note on scripting:

Scripts are essentially a record of what you’ve done - like a live document you can edit and add to as you go. When I script, it’s almost literally a stream of consciousness, which includes bits of code that don’t work so I don’t make the same error again. You should leave comments to remind yourself of what you’re doing, because even if you think you’ll remember, I promise if you come back to it in six months, you’ll be lost! You denote a comment by starting a line with a #. R will ignore these lines (they will be greyed out in RStudio), so add as many as you like!

When you’re thinking about not using comments, remember the Voyrich manuscript. It was written in gibberish, and nobody knows what it means because there is no way of translating it, and no way to work out what the author was thinking. I go super over-board with comments to myself, particularly when I’m sharing scripts with others.

Data structures

Right, lets get to the real meat. Data structures. There are 4 main data structures that we’ll cover here (well, 3.5 because we’ll cover lists properly another time) - Vectors, Matricies, and Dataframes.

Vetors

We’ll start with vectors. We’ve already considered all three main classes of data above, numeric, character, and logical. We use these and others to build up our data structures in R.

A vector is just a 1-dimensional series of values - the length of the vector is its only dimension. This is the most basic data structure you’ll find in R, and the fundementals of accessing its contents are different to Python. So, we’ll start by creating a series of vectors, starting with a numeric vector: Note: c() is a useful function here, it’s short for concat or combine, we’ll talk more about functions later!

x <- c(1, 2, 3, 4, 5)

y <- 1:5

z <- seq(from = 1, to = 5, by = 1) 

All of these examples will give you a number vector that ranges from 1-5. The first combines all listed numbers, the second creates a series of numbers from 1:5 (the : essentially means from 1 to 5), and the third creates a sequence from 1 to 5, going up in 1s.

We can also create character vectors. Later, we will discuss how you access an individual component of each of these vectors, but for now, let’s build some character vectors (using my favourite nintendo examples!). Note that you can only create a character vector with the c() function. Without this, R is only expecting a single value in your assignment and will throw an error up. Let’s try:

a <- c(“Mario”, “Luigi”, “Peach”)

b <- c(“Link”, “Zelda”, “Gannon”

We can also create a vector of logical values. Remember that TRUE and FALSE have to be in caps for R to interpret them as logicals. Here, we’ll create a logical vector using logcal values, and then one from character vectors with ==:

e <- c(TRUE, FALSE, TRUE)

f <- a == b

Vector properties

It’s time to have a look at the properties of a vector - later we’ll move on to sticking vectors together to make new data structures, but for now, we’ll have a look at vectors as stand alone objects. We can do mathematical operations on entire numeric vectors - we can apply a single operation to all values in a vector, or we can perform operations on two different vectors:

x <- 1:10
x + 5
x – 5

y <- 11:20
x + y
x * y

Vector operations such as those above are a very important and powerful tool in R for rapid calculations across large sets of numbers.

Data structures in R have properties - the main property of a vector is its length. Once you know something about the length of a vector, you can more easily access the stuff inside of it. You find the length of a vector using length(x).

You will get warnings to do with the length of a vector in various circumstances, for e.g. if two vector lengths are not multiples of one another in some mathematical calculations. Try the following:

x <- 1:10
length(x)

y <- 1:5
x + y
x * y

z <- 1:3
y * z 

Here, you’ll notice that the operation causes the shorter vector (z) to be looped across until it fits the longer. So, your result from y * z is actually:

• 1 * 1,
• 2 * 2,
• 3 * 3,
• 4 * 1, and
• 5 * 2

R will still perform these operations, but it will warn you that vector lengths are not multiples of one another.

So, how do we interact with vectors and start to pull items from them? Vectors are great, but they’re not overly useful unless we can get at the stuff inside of them. We’ll create another character vector, x.

x <- c("dog", "cat", "mouse")
x[] # This will print all vector values
x[1] # This will print the first value - note that R is indexed from 1 unlike Python!!
x[c(1, 3)] # This gives you the first and third values - note the use of c()
x[2:3] # this gives you values 2 through to 3.

So, now we can pull out whatever values we want, we can use this to manipulate the contents of our vector! If we wanted to, for example, replace the mouse with an elephant, we’d use the following:

x[3] # This prints "mouse"
x[3] <- "elephant" # This assigns the string "elephant" to the third index of the vector, replacing "mouse".
x

Now, what if we want to remove number 3 all together? We can do this by assignin it an NA value, which indicates to R that there is no value present at this location:

x[3] <- NA

A note on NA:

NA is a placeholder in R, for when data is “Not Available”, and it usually denotes missing data. For example, you might be collecting blood samples from patients in a longitudinal trial, and a patient is unable to provide a sample at point 3 of 5, so here, your value for whatever you’re measuring in the blood would be NA. Other commonly encountered missing value placeholders in R are NaN (Not A Number) and Inf (Infinity).

Functions

We’ll take a brief interlude from data structures for a brief word about functions now. Functions are the bread and butter of R. They are code that takes an input, processes it, and returns a result in the form of an output. We have already used some functions above, such as length() and seq(). There are thousands of functions available to you in R, from the very basic to the extremely complicated and involved. You can (and you will!) write your own functions, much like you can in Python, although the syntax is different. Pre-built functions often come with help files, try the following:

y <- 1:10
length(y)
?length

Use ?function or help("function") to access help. The help files generally contain a description of the function and details of all the arguments which may be supplied to it. These help files do take some getting used to, as true to R’s style, they can be quite tricky to interpret!

The anatomy of a function

Try running the following code:

y <- 1:10
sum(y)
y[5] <- NA # Replace the 5th index with NA
sum(y)

You’ll notice that if a vector contains NA, functions such as sum() will return NA. Something hasn’t quite worked here, so we need to add an additional argument to our function to deal with those pesky NAs…

sum(y, na.rm = TRUE)

Here, the na.rm argument is set to TRUE, so that NA is ignored (or, more accurately, removed). Note that the assignment of things inside of a function is always done with = and not <-.

Plotting and visualisation

Now is a good time to start thinking about what we can actually get out of what we’ve learned so far, so we’ll use Rs integrated plotting software to create some nice plots! You can have a look at what R has to offer using the now slightly outdated demo(graphics) command. Try taking a tour through the graph types.

Let’s use the skills we’ve learned so far to make a plot!

x <- 1:100
y <- x^2
plot(x, y)

Nice! You should have produced a scatter plot. What if we want to turn that into a line plot?

plot(x, y, type = "l")

Fabulous. The ways to customise graphics in R are almost endless - we’ll have a closer look later on! For now though, we’ll get back to our data structures.

Returning to data structures

Matricies

The second type of data structure we’ll look at is the humble matrix. These data structures store data in rows and columns (i.e. like a table!). They are very similar to vectors, only they are two-dimensional. In fact, we can build our first matrix from some vectors using the cbind() and rbind() functions:

x <- 1:4
y <- 21:24
z <- cbind(x, y)
z

cbind() binds vectors togther by column, whereas rbind() does it by row, effectively flipping our table. Try running z1 <- rbind(x, y) and looking at the output.

There is a simple way to determine whether your data structure is a matrix, which is by running the is.matrix(z) command. Try it! It should give a logical output of TRUE or FALSE. You can also access the dimensions of a matrix in a similar way to a vector (although slightly different). dim(z) tells you the dimensions overall, nrow() tells you the number of rows, and unsurprisingly, ncol() gives you information about the number of columns in the matrix. Try it with our matrix z.

An important consideration with matricies is that we refer to them by the row index, and then the column. This is something that is very easy to forget, and I often have to look it up, so don’t worry if you can’t remember. Matricies are also only capable of storing 1 type of data, either logical, character, or numeric. If your data is mixed in type, you’ll need a dataframe rather than a matrix, but we’ll get to that soon. Let’s see what happens if we try and store multiple data types:

x <- c(“Mario”, “Luigi”, “Peach”)
y <- c(“Toad”, “Bowser”, “Wario”)
z <- c(1, 2, 3)
m <- cbind(x, y, z)

Here you can see that the numbers in z are transformed into characters!

Anyway, how do we extract and access information stored in a matrix?! Like with vectors, we use square brackets. Let’s make a bigger matrix and have a go. Note that we are using the matrix() function here rather than cind().

m <- matrix(1:10, ncol = 2) # ncol = 2 tells R that we want the numbers 1-10 split into 2 columns
m[1, ] # return first row
m[, 2] # return second column
m[1,2] # return the information in the first row of the second column, in this example, 6.

Data frames

Right, on to our third (and probably final) data structure - data frames. Most “real” data that you come across in your travels will be in a dataframe. It’s a bit like a matrix, but capable of storing multuple data classes in the same object. Let’s make one from 3 vectors and have a look:

name <- c(“Mario”, “Luigi”, “Link”, “Zelda”)
height <- c(155, 160, 180.3, 180.3)
age <- c(26, 24, 17, 19)

df <- data.frame(name, height, age)

Note that the dataframe must have named columns! You can look at the first few rows of your data with head(df), and take note of the structure of it with str(df). Now, everything you’ve just learned about accessing data inside of a matrix stands true for dataframes also - they work in a very similar fashion with the rows and columns format. There is, however, another way to access data from your dataframe that I find more intuitive than using column indicies, which is referring to the column by its name (hence the need for named columns!). Try this:

# Accessing data as if it were a matrix
df[, 1]
df[3, ]
df[4, 3]

# Using column names as references

df[“name”]
df[, “name”]
df$name

When you extract a column in this way, it becomes a vector! Note that in df$name, the $ essentially just means “look inside” - so you’re telling R to look inside df to find the names column.

Accessing example data

Using the toy datasets as we just have is all well and good when you’re learning, and is a fun way to experiment and figure out how things work! But, what if we want to get hold of some actual data? There are loads of pre-loaded real life datasets that come with R, so let’s have a look at arguably the most famous of these, the iris dataset.

If we type data() into our R console/script and run it, R will load these datasets for us. We can then use the head() function to look at the iris dataset…

data()

head(iris)

?iris

Note that we can get more information about the dataset by running the help ? function. We will revisit these dataset in a minute, but first, what if you want to import your own data?!

The easy way: you can use RStudio to import data via the GUI, which is a good way to learn at first, but isn’t as flexible as learning functions to read data…

The (arguably) better way is to use the read.csv() function. I will use it here to upload a .csv file I have in my project directory which contains data from Netflix titles over the years. Try with your own data!

netflix <- read.csv("./netflix_titles.csv")
head(netflix)

You may also need to write data out of R, which can be good for saving your progress or saving filtered datasets. Here, we will write out a file of comma-separated variables (a .csv file).

df <- data.frame(name = c(“Mario”, “Luigi”, “Link”, “Zelda”),
            height = c(155, 160, 180.3, 180.3),
            age = c(26, 24, 17, 19))

write.csv(df, “./nintendo.csv”) 

Note: this is the nintendo dataframe we made earlier, so you may not need to remake it!

Extending beyond base R:

Packages, which are analagous to modules in Python, are a great way of extending your R universe. They can be installed in a multitude of ways, but perhaps the most common is installing them directly through the Comprehensive R Network - CRAN. There are currently over 18500 packages listed on CRAN, so it’s likely that if you’re trying to do something specific in R, there is already a package! Other repositories include GitHub and BioConductor.

Installing and loading R packages:

Installnig packages is usually straight forward… You also only need to do it once on each computer you use! We will install ggplot2 now, a package we will use lots in other sessions. Once installed, you must load your package into R with the library() function.

install.packages("ggplot2")
library(ggplot2)

Back to plots!

Visualising data is a fundementally important tool in R - think of it as a way to understand and properly explore your data. We wont use ggplot2 for this for now, although this is a fabulous plotting tool. We can use R to make a simple scatter plot, as we did before:

x <- seq(from = 1, to = 100, by = 5)
y <- x^2

plot(x, y)

We can customise almost anything on this plot, and we add to it iteratively as we go. You’ll see what I mean in the following examples. First, we’ll change the orientation of the y axis labels with the las = 1 argument in the plot() function:

plot(x, y, las = 1)

We can change the colour of the points, and then add a line:

plot(x, y, las = 1, col = “red”)
lines(x,y)

We can add a title:

plot(x, y, las = 1, col = “red”,
     main = “relationship between x & y”)
lines(x,y)

The possibilities are endless!

Right, lets make a basic histogram and a box and whisker, then we’ll call it a day.

Plotting the distribution of data with a histogram can be useful to identify outliers or have a look at the shape of your data. We can plot the normal distribution as an example - the following code will generate a series of numbers that follow a normal distribution and then plot it:

x <- rnorm(n = 1000, mean = 25.5, sd = 3)

hist(x)

Boxplots are useful to have a look at potential differences between groups of data - let’s plot the iris data and see how petal width might differ among species:

head(iris)

boxplot(iris$Petal.Width ~ iris$Species,
      las = 1, ylab = “Petal width”,
      xlab = “Species”)

A quick note about tilde (~)

In R, a tilde denotes the relatinship between two variables, and is commonly used in statistical functions. It’s slightly confusing, as it appears to be the wrong way around - you code the dependent variable and then the independent. So, Petal width ~ Species means how does petal width vary among species?!

Top tips for learning R:

• Experiment! Not much can go horribly wrong…
• Practice, practice, practice!
• There is no single right way - if it works, it works.
• Use resources available online - StackOverflow, Twitter, R forums (with caution!)
• Take a break. A walk and a brew does wonders.