RStudio is hosting Hadley Wickham’s two day, R Master Development course:
Sept. 8, 2014 – Advanced R programming
Sept. 9, 2014 – R package development
Course Instructor: Hadley Wickham – RStudio Chief Scientist
This is a two-day workshop, but each day can also be taking independently. To save on registration fees, sign up for both now. All participants will receive a copy of all slides, exercises, data sets, and R scripts used in the course.
What should I bring?
Be ready to learn. You need your laptop and the latest version of R. Obviously we recommend the RStudio IDE, but it’s not required: bring the R environment that makes you the most productive.
Day 1 – Advanced R programming
Learn to write better R code by using the advanced features of the R programming language. Based on the programming experience of Hadley Wickham (author of over 30 R packages) and the RStudio team, this course will teach you how to use R to solve harder problems with fewer lines of code.
- Main concepts:
• Become a skilled R programmer who knows the best ways to craft R functions and to use R’s object oriented programming (OOP) features
• Learn advanced R techniques to compute on the language, control object evaluation within R functions, and apply R’s scoping rules
• Write correct, fast, and maintainable R code built around the mantra, “Don’t repeat yourself!”
- What will you learn?
How to write R programs like an expert. Through a series of demonstrations and hands on exercises, you will learn about advanced R features to write fast and maintainable code.
Controlling evaluations – Unlike most languages, R provides powerful tools for controlling when and where evaluation occurs. This lets you create functions tailored for interactive use that minimize typing with a little magic.
• Mastering base functions such as with, subset and transform
• Capture user input without evaluating it
• Control when and where R evaluates expressions and calls
• R’s rules for dynamic and lexical scoping
• Writing code that modifies code
First class functions – At heart, R is a functional programming language, and functions can be used in many more ways than most R users assume. R has first class functions which means you can write functions that return functions, take functions as input, and save function in lists. This gives you a powerful set of tools for dealing with a broad class of problems.
• Create anonymous functions
• Write closures – functions that return functions
• Build higher-order functions – functions that take other functions as input
• Work with lists of functions
Object oriented programming – Though a functional language, R contains three systems of object oriented programming (OOP) features. These features revolve around the concepts of classes and methods and can dramatically simplify code. We’ll focus on S3, the oldest and simplest form of OOP, but will also touch on S4 and R5 (reference classes).
• How to interpret base R functions that use OOP techniques
• The details of S3 generic functions, methods, and classes
• The differences between R’s three OOP classes: S3, S4, and R5
Best practices in R – Even advanced techniques can be ruined by poor planning. When you use advanced techniques, you must be especially careful to make your code clear and lucid. Throughout this course you’ll learn practical coding tips and techniques.
• Create correct, maintainable, and fast R code
• Create understandable code that communicates
• Organize R programs around the “DRY” principle – “Don’t repeat yourself!”
Day 2 – Software development with R
- Who should take this course?
This class will be a good fit for you if you’ve developed a number of R scripts, and now you want to learn:
• a more efficient workflow, iterating between writing code and checking that it works
• how to document your code so others (including future you!) can understand what’s going on
• automated testing principles, so that if you accidentally break something in your code you find out right away
• how to package and distribute your code to others, whether it’s inside your research group, your company, or to the whole world.
The key to well-documented, well-tested and easily-distributed R code is the package. In this course you’ll learn that creating packages is actually really easy. The key to making packages so easy that they become your default way of organizing code are the R packages devtools, roxygen2 and testthat, all of which you’ll learn about in this class.
• Transform existing R code into packages that others can easily download and use.
• Learn a fluid development process facilitated by the devtools package.
• Write inline documentation with roxygen2.
• Develop automated tests with the testthat package to ensure that your code is correct today, and continues to be correct in the future.
• Recognize common errors detected by the strict R CMD check.
• Release your package into the wild, through the official CRAN repository or to github.
- What will you learn?
How to develop an idea into a published, stable R package. Through a series of demonstrations and hands on exercises, you will learn to use advanced R features to quickly build, document, test, and publish R packages.
Introduction to R packages – Packages are one of the most useful tools in the R programming language. Packages make it easy to share your code with friends, coworkers, or even the global R community by building.
• What is a package?
• Working with libraries and installing packages
• The development cycle
Documentation and namespaces – For your code to be useful, it must be both well-documented, and it must work regardless of what other packages are currently loaded. We will show you how to take solve these problems using roxygen2 to generate both documentation and a namespace.
• Documenting functions, objects, methods and datasets
• Formatting text in help pages
• Exporting functions to a package namespace
• Using functions from other packages in your package
Automated testing – Maintaining R code requires advanced planning. You can simplify debugging, quickly spot unintended consequences, and generally ensure that your package is stable by creating thoughtful unit tests.
• Transition from the informal interactive tests you’re currently doing to formal automated tests
• Make code maintenance easier with unit tests
• Seamlessly integrate unit testing into your workflow with devtools
• Use travis-CI to automatically run all tests every time you push a change to github
Releasing your package – If you want others to use your package, you need to be aware of the options for distributing it from the very informal (email), to the more formal (github) to the most strict and rigorous (CRAN). You’ll learn about R Core’s strict standards for inclusion in CRAN (which are worthwhile understanding even if you don’t want to submit) and how to market your package after it has been released.
• Using and passing R CMD check
• Submitting a package to CRAN
• Distributing a package via github
• Marketing your package after its release
• Simplifying package development with source code control