RStudio Education

Beginners

Mon, 01 Jan 0001 00:00:00 +0000

No one starting point will serve all beginners, but here are 6 ways to begin learning R.

Install , RStudio, and R packages like the tidyverse. These three installation steps are often confusing to first-time users. For beginner-friendly installation instructions, we recommend the free online ModernDive chapter Getting Started with R and RStudio. You may also enjoy the Basic Basics lesson unit from R-Ladies Sydney, which provides an opinionated tour of RStudio for new users and a step-by-step guide to installing and using R packages.
Spend an hour with A Gentle Introduction to Tidy Statistics In R. If you are coming to R from a traditional point-and-click statistics package such as SPSS or SAS, RStudio’s Thomas Mock has created a free video webinar titled A Gentle Introduction to Tidy Statistics In R. This one-hour introduction covers how to get started quickly with the basics of research statistics in R, providing an emphasis on reading data into R, exploratory data analysis with the tidyverse, statistical testing with ANOVAs, and finally producing a publication-ready plot in ggplot2. Plus, you’ll find a host of other RStudio webinars and videos to explore via the topic menus on the left side of that page.
Read R for Data Science. While videos are great for some, others of us learn best by curling up with a good book. If that describes you, pick up a copy of R For Data Science by Wickham and Grolemund (2016) from your friendly local bookseller. R For Data Science is available in paper and electronic forms and has been translated into multiple languages including Spanish, so choose the version that’s easiest for you. R For Data Science is also available for free as a online book at https://r4ds.had.co.nz. If you don’t yet know enough about R to commit to R for Data Science, you may find Garrett Grolemund’s Hands On Programming with R (2014) a quicker way to get started. It’s also available in paper, electronic, and free online versions.
Start coding using RStudio.cloud Primers. One of the most effective ways to get started learning R is to start using it. RStudio.cloud Primers offer a cloud-based learning environment that will teach you the basics of R all from the comfort of your browser. RStudio.cloud doesn’t require you to install any software on your computer, making it easy to dip your toe into data science with R with a minimum of fuss. And best of all, rstudio.cloud accounts are free for personal use.
Publish your work with R Markdown. R is a terrific tool for telling stories with graphics and data, but sometimes you need words too. R Markdown weaves together narrative text and code to produce elegantly formatted reports, papers, books, slides and more. Garrett Grolemund will give you a personal R Markdown tour with his Get Started With R Markdown video, or you can choose your own path through the wonders of R Markdown at rmarkdown.rstudio.com. Bookmark R Markdown: The Definitive Guide (2018) as you work too; it provides a great overview of what is possible within the R Markdown family of packages.
Learn about some power tools for development. RStudio offers 6 videos called the RStudio Essentials Series that help you learn how to program and manage R projects using RStudio’s tools including the RStudio Integrated Development Environment (IDE). These videos will also help you learn good development practices that make collaboration within a team safe and easy.

Books & packages referenced

Allaire, JJ, Yihui Xie, Jonathan McPherson, Javier Luraschi, Kevin Ushey, Aron Atkins, Hadley Wickham, Joe Cheng, Winston Chang, and Richard Iannone. 2020. Rmarkdown: Dynamic Documents for R. https://CRAN.R-project.org/package=rmarkdown.

Grolemund, Garrett. 2014. Hands-on Programming with R: Write Your Own Functions and Simulations. O’Reilly Media, Inc. https://rstudio-education.github.io/hopr/.

Wickham, Hadley. 2019. Tidyverse: Easily Install and Load the ’Tidyverse’. https://CRAN.R-project.org/package=tidyverse.

Wickham, Hadley, Winston Chang, Lionel Henry, Thomas Lin Pedersen, Kohske Takahashi, Claus Wilke, Kara Woo, Hiroaki Yutani, and Dewey Dunnington. 2020. Ggplot2: Create Elegant Data Visualisations Using the Grammar of Graphics.

Wickham, Hadley, and Garrett Grolemund. 2016. R for Data Science: Import, Tidy, Transform, Visualize, and Model Data. O’Reilly Media, Inc. https://r4ds.had.co.nz/.

Xie, Yihui, Joseph J Allaire, and Garrett Grolemund. 2018. R Markdown: The Definitive Guide. Chapman; Hall/CRC. https://bookdown.org/yihui/rmarkdown/.

Learn to teach

Mon, 01 Jan 0001 00:00:00 +0000

While it might seem like teaching data science is a new activity, educational professionals have studied teaching techniques for decades. Today’s teaching techniques are based not only on the personal experiences of classroom teachers, but also on neuroscience and cognitive psychology. While we can’t replicate the thoroughness of the National Academies’s How People Learn, we can recommend a couple of starting points for learning how to teach technology:

Read Teaching Tech Together. RStudio’s Greg Wilson penned (actually, he typed it) this book based on his work for the Carpentries, and it will help you create and deliver lessons that work for technical and non-technical audiences alike and to build a teaching community around them. Greg also created a free online webinar titled What Every Data Scientist Should Know About Education. This one-hour introduction presents a handful of evidence-based practices you can use right now, explains why we believe they are true, and points you at other resources that will help you go further.
Get involved in the Carpentries, a volunteer organization that teaches foundational coding and data science skills to researchers worldwide (they’ve even run a workshop in Antarctica). Their lessons on data wrangling, programming, and for librarians are all open access and classroom-tested.
Become a certified trainer. In 2019, RStudio has launched an instructor training and certification program that aims to help people apply modern evidence-based teaching practices to teach data science using R and RStudio’s products, and to help people who need such training find the trainers they need. You can meet our Certified Trainers and find out more about the program and the application process here, and access our Instructor Training Materials here.
Connect with the #rstats education community. The RStudio Community is a warm and welcoming online discussion forum to ask (and answer!) any questions about using R. But you may not know that the site has a dedicated category for all things related to teaching. There, you’ll find lively discussions between first-time instructors and seasoned educators about topics like how to introduce functions in R, ideas for datasets to use, or how to pronounce an R package name. To meet other R educators in person, we host a yearly rstudio::conf that always features talks about teaching; you can browse past videos of talks in this track here. If you do attend our conference, keep an eye on Community before you go for announcements about the Birds of a Feather meetup for educators — this is an informal get together of like-minded R educators to talk shop and connect in person while you’re all in the same place at the same time.

Intermediates

Mon, 01 Jan 0001 00:00:00 +0000

Once you’ve gotten started learning R, you can expand your skills by exploring many of the specialized capabilities of R. Here are 6 of the most common areas that people who already have some experience in R find particularly rewarding to learn.

Grab some cheat sheets. No one can possibly remember all the functions and arguments for every R package, which is why cheat sheets were invented. RStudio publishes a free collection of cheat sheets for the most popular R features and packages to help jog your memory. If you decide you’d like to collect them all, you may clone the cheat sheet github repository.
Learn to get help. Everyone gets stuck. Learning where and how to ask for R help is a powerful skill to hone. The Tidyverse site offers some expert advice for how to help others help you. One package you’ll grow to love is the reprex package for creating reproducible R code examples. Read through the reprex articles, which feature loads of animated gifs to illustrate the steps like Magic reprex and Using datapasta with reprex. Where to ask for help? The RStudio Community is a warm and welcoming online discussion forum to ask (and answer!) any questions about using R.
Improve your visualizations. You may already know how to create a basic plot using ggplot2, but can you build one that makes your audience go “Wow?” You can start by expanding your knowledge of the Grammar of Graphics and ggplot2 by reading Hadley Wickham’s (2016) book, ggplot2: Elegant Graphics for Data Analysis. Paper and Kindle versions are available on Amazon for the second edition of the book. The third edition is in-progress and can be viewed for free online, with the source files on GitHub. If you’d like Hadley to personally explain his philosophy of using ggplot2 in his data science work, check out Hadley’s talk from OpenVisConf 2017, The Role of Visualiation in Exploratory Data Analysis. Bookmark the updated R Graphics Cookbook by Winston Chang (2018) too; it is filled with recipes that tackle specific ggplot2 problems.
Develop interactive applications with htmlwidgets and Shiny. One concrete way to communicate your analyses better is to make your visualizations interactive. You can learn how to add browser-based interactivity to your graphics with just a few lines of code at www.htmlwidgets.org. If your interactive needs demand help from R code that needs to run on a server, learn how to write Shiny applications at shiny.rstudio.com, or follow along as Wickham (2020) writes the new Mastering Shiny book. Both approaches can be integrated with R Markdown to create polished interactive dashboards using the flexdashboard package.
Simplify your model explorations with tidymodels. Much of data science involves modeling, but each modeling package seems to invent its own interface and arguments. Enter tidymodels, a meta-package for modeling and analysis that shares the underlying design philosophy, grammar, and data structures of the tidyverse. If you previously have used caret for a uniform modeling interface, the tidymodels package parsnip is its more up-to-date child. While this project is still under development, it promises to dramatically simplify model exploration. RStudio’s Edgar Ruiz wrote up A Gentle Introduction to tidymodels to get you started.
Explore other specialized packages. R attracts data scientists because of its more than 13,000 packages that address nearly every use case. If you’re interested in genomics, you’ll want to spend some time learning the bioconductor collection of packages. If you’re working with Big Data on Spark clusters, check out sparklyr. If you want to dive into finance, you’ll probably want to start with quantmod. To find out what packages you should explore, we recommend some of the topic-based package catalogs such as Awesome R or the CRAN task views.

Books & packages referenced

Bryan, Jennifer, Jim Hester, David Robinson, and Hadley Wickham. 2019. Reprex: Prepare Reproducible Example Code via the Clipboard. https://CRAN.R-project.org/package=reprex.

Chang, Winston. 2018. R Graphics Cookbook: Practical Recipes for Visualizing Data. O’Reilly Media. https://r-graphics.org/.

Chang, Winston, Joe Cheng, JJ Allaire, Yihui Xie, and Jonathan McPherson. 2019. Shiny: Web Application Framework for R. https://CRAN.R-project.org/package=shiny.

Iannone, Richard, JJ Allaire, and Barbara Borges. 2018. Flexdashboard: R Markdown Format for Flexible Dashboards. https://CRAN.R-project.org/package=flexdashboard.

Kuhn, Max, and Davis Vaughan. 2018. Parsnip: A Common Api to Modeling and Analysis Functions. https://CRAN.R-project.org/package=parsnip.

Max, Kuhn, and Hadley Wickham. 2018. Tidymodels: Easily Install and Load the ’Tidymodels’ Packages. https://CRAN.R-project.org/package=tidymodels.

Ryan, Jeffrey A., and Joshua M. Ulrich. 2018. Quantmod: Quantitative Financial Modelling Framework. https://CRAN.R-project.org/package=quantmod.

Wickham, Hadley. 2016. Ggplot2: Elegant Graphics for Data Analysis. Springer. https://ggplot2-book.org/.

———. 2020. Mastering Shiny. O’Reilly Media. https://mastering-shiny.org/.

Wickham, Hadley, Winston Chang, Lionel Henry, Thomas Lin Pedersen, Kohske Takahashi, Claus Wilke, Kara Woo, and Hiroaki Yutani. 2019. Ggplot2: Create Elegant Data Visualisations Using the Grammar of Graphics.

Materials for teaching

Mon, 01 Jan 0001 00:00:00 +0000

RStudio offers several resources to make it easier for you to teach R, ranging from semester-long courses to more intense (but much shorter) workshops.

All of these materials can be reused and remixed freely under Creative Commons licenses. If you do so, please include a link to the original in your content saying, "Portions of this material are derived from RStudio's '[lesson title]'." Only one such link is needed: you do not need to link from or to specific slides and do not need to include our logo.

Courses

Most teachers enjoy developing their own instruction materials, but the need for exercises, homework, exams, slides, and other supporting materials make this a big job. Below are some open source materials developed at RStudio and elsewhere that you can freely adapt and use for your R teaching.

Get a complete data science course in a box. Data Science in a Box contains the complete materials for teaching a semester-long introductory data science course. The “box” contains materials for an undergraduate level introductory data science course, such as slide decks, homework assignments, guided labs, sample exams, a final project assignment, as well as materials for instructors such as pedagogical tips, information on computing infrastructure, technology stack, and course logistics. The website exposes the source materials that live in a GitHub repository and use datasets from the dsbox package.
Teach with STAT 545. STAT 545 is a course in data wrangling, analysis, and exploration in R with RStudio. Although the course was designed as a graduate-level, semester-long introduction to data science by Dr. Jennifer (Jenny) Bryan, the free online materials Jenny developed have been a valuable resource for self-directed learners and other educators. In Jenny’s own words, STAT 545 was designed to teach “everything that comes up during data analysis except for statistical modelling and inference." The education team at RStudio has recently ported the original materials into a modern and more maintainable bookdown website.
Use R for Data Science in the classroom. Many educators use the free online book R for Data Science as a course textbook. There is also an R for Data Science Instructor’s Guide, which contains notes for people teaching R for Data Science with each chapter’s learning objectives and key points. The “unofficial” R4DS Solutions Manual, a community resource developed by and for educators, is also helpful if you want to use R4DS in the classroom.

Workshops

Many of you may have taken workshops from the RStudio team, but did you know that all of RStudio’s workshop materials are available for you to use in your own workshops? Below are a few of the more popular workshop respositories proven popular with teachers:

Teach the Tidyverse. Master the Tidyverse is an award-winning two-day introduction to doing data science with the Tidyverse. This repository contains instructor materials (Keynote slides and exercises) for teaching this workshop. You can teach the workshop as is, adapt it to your needs, or divide it into two one day workshops: Welcome to the Tidyverse, which covers Exploratory Data Analysis, and Data Wrangling with the Tidyverse. See the README for teaching tips.
Teach Shiny. This workshop is designed for those who want to up their teaching Shiny game, and is particularly aimed at training partners who want to qualify as an RStudio Certified Shiny Instructor and at those who are R and Shiny advocates in their organizations.
Teach R Markdown. If you want to teach R Markdown, we have designed several workshops for teaching the basics to the more advanced topics. You can find the materials for a full two-day workshop on Advanced R Markdown ( source), a four-hour introductory workshop on R Markdown for Medicine ( source) aimed at clinical researchers, and a full-day workshop on Communicating with R Markdown ( source).
Teach everything else! At the RStudio Education GitHub Organization instructors can find the materials for all workshops taught by the RStudio Education team. All of these workshop materials are openly-licensed and freely-available for reuse. Please follow the reuse guidelines outlined in the licenses in the specific repositories, and enjoy leveraging quality teaching materials designed and developed by our team!

Experts

Mon, 01 Jan 0001 00:00:00 +0000

Even once you are an expert at R code development, learning some topics in depth will both help you develop better code and share it more effectively with others.

Dive into the foundations of R. Most R users are not programmers, and therefore much of their R code is not as readable, fast, or efficient as it could be. The second edition of Hadley Wickham’s book, Advanced R (2019) (available for free online and as an O’Reilly paperback from Amazon), unlocks many of the secrets behind how R works the way it does, and gives you new strategies for solving diverse problems. You may also want to bookmark Advanced R Solutions, which provides worked solutions to the exercises in this book.
Learn how to extend R. While its content sometime overlaps with Hadley’s Advanced R, the R Core Team offers Writing R Extensions (electronic version) on CRAN. This book is particularly useful if you wish to add your own C and C++ routines to R, but also has unique information on debugging, the R API, and runtime profiling that is difficult to find anywhere else.
Build your own packages. R packages allow you to share your functions with other R programmers in a modular and easy-to-integrate way. The above-mentioned Writing R Extensions documents how to write packages, but you may find Hadley Wickham’s R Packages book (2015) (electronic here (1st edition) and an O’Reilly paperback (1st edition) from Amazon here) a bit easier to read and more step-by-step. The second edition of the R Packages book is currently in progress, written by Hadley and co-author Jenny Bryan. You can read the in-progress book for free online. If you want your R code to reach the widest possible population of developers, you’ll want to know how to build packages.
Use Python in your analyses. Anyone who insists you must choose between R and Python for doing data science is creating a false choice. R offers an easy way to incorporate Python code in the reticulate package. Sean Lopp’s webinar, R, RStudio 1.2 & Python—a love story, demonstrates how easily developers can integrate Python code into their R workflows and walks through the development of a reticulated Shiny app.
Try your hand at Tensorflow for deep learning. RStudio hosts a web site dedicated to R and Tensorflow at tensorflow.rstudio.com, where you can learn how to use deep learning in your analyses. J.J. Allaire and Francois Chollet have published a Deep Learning with R book (2018). You can hear J.J. describe the philosophy behind the system in his rstudio::conf 2019 video. For an quick overview of resources for how to get started with deep learning in R, read Sigrid Keydana’s article and subscribe to the Tensorflow for R blog.
Communicate with R Markdown. The R Markdown family of packages enables you to create and share beautiful data science products like books, blogs, websites, and presentations. Experiment with packages like bookdown, distill, and blogdown; each extends R Markdown to help you publish polished websites for sharing your work. If you want to present analyses or visualizations made with R code, consider making your slides with R Markdown using the xaringan package. If you’ve built an R package, the pkgdown package makes it quick and relatively painless to build a website for your package, using all the work you’ve already done to write and document your functions.

Books & packages referenced

Allaire, JJ, Rich Iannone, and Yihui Xie. 2019. Distill: ’R Markdown’ Format for Scientific and Technical Writing. https://github.com/rstudio/distill.

Chollet, François, and J. J. Allaire. 2018. Deep Learning with R. Manning Publications.

Ushey, Kevin, JJ Allaire, and Yuan Tang. 2019. Reticulate: Interface to ’Python’. https://CRAN.R-project.org/package=reticulate.

Wickham, Hadley. 2015. R Packages: Organize, Test, Document, and Share Your Code. O’Reilly Media, Inc. https://r-pkgs.org/.

———. 2019. Advanced R, Second Edition. Chapman; Hall/CRC. https://adv-r.hadley.nz/.

Wickham, Hadley, and Jay Hesselberth. 2018. Pkgdown: Make Static Html Documentation for a Package. https://CRAN.R-project.org/package=pkgdown.

Xie, Yihui. 2019a. Blogdown: Create Blogs and Websites with R Markdown. https://github.com/rstudio/blogdown.

———. 2019b. Bookdown: Authoring Books and Technical Documents with R Markdown. https://github.com/rstudio/bookdown.

———. 2019c. Xaringan: Presentation Ninja. https://github.com/yihui/xaringan.

Tools for teaching

Mon, 01 Jan 0001 00:00:00 +0000

Whether you are teaching for the first time or you are a seasoned educator, you know that finding the right tools can make or break any learning experience. As professional data science educators, we offer some opinionated advice about how to choose your computing infrastructure, and which packages are worth your time for adding value to your teaching.

Computing infrastructure

A common friction point for getting students (and faculty) started with computing is installation and setup. Having the right computing infrastructure in place can make life easier for you as an educator, and can help put your learners on the happy path early. We have found that paying careful attention to your technical stack before you start teaching can minimize frustration and improve buy in for both students and instructors.

Sign up for RStudio Academic pricing. RStudio offers special academic pricing discounts for our professional products to qualified academic institutions. This includes RStudio Server Pro, Connect, and Package Manager. To find out if you qualify, please read more here. To get academic pricing, contact the RStudio Sales team.
Use RStudio Cloud in the Classroom. RStudio Cloud is a managed cloud instance of the RStudio IDE. This means you and your learners can use the RStudio IDE directly from your browser - there is no software to install and nothing to configure on your computer. Using RStudio Cloud early in a workshop or course allows you to circumvent the installation step and skip right to the good stuff. This webinar walks you through the steps of setting up your course on RStudio Cloud, highlighting the various functionalities for teachers and students.
Craft your course infrastructure. The article Infrastructure and tools for teaching computing throughout the statistical curriculum discusses computational infrastructure and toolkit choices for modern educators using RStudio Server and RStudio Server Pro. The authors provide links to technical notes on setting up these systems for teaching, intended for both academics and IT professionals. (Note: A peer reviewed, but pay-walled version of the article can be found here.)
Use version control. Our team uses GitHub. A lot. We use it for version control, but also for its side benefits: GitHub makes it easier to collaborate with others and share content with learners. If you aren’t using version control yet, take a few minutes to read the article “Excuse me, do you have a moment to talk about version control?" Now that you are convinced, bookmark Happy Git with R also by Jenny Bryan. This free online book contains battle-tested instructions for setting up Git, GitHub, and RStudio across all operating systems. Use it yourself, and send your learners there too.

Packages

After you get your tech stack set up, you’ll want to think about packages that can help you create and deliver your content better. Several of RStudio’s open source R packages can be very helpful when creating, organizing, and delivering your educational content.

Create interactive tutorials with the learnr package. The learnr package is designed to turn any R Markdown document into an interactive tutorial. The final product can be published all of the same ways that Shiny applications can, including running locally on an end-user’s machine or running on a Shiny Server or hosting service like shinyapps.io. All of the RStudio.cloud Primers are written with learnr — you can see the source code in this GitHub repository.
Grade learnr tutorials with the gradethis package. Once you’ve created a tutorial, you’ll probably want to evaluate learners’ solutions, and provide targeted feedback based on their input. Gradethis is a package that grades code and provides meaningful feedback in learnr interactive tutorials, or as a standalone code grader. It gives instructors the ability to capture code submitted by a student and checks it by comparing the final result, the actual code, or against a set of test conditions. When gradethis is used to compare a learner’s code against solution code, it can report how the answer differs.
Give your teaching materials a place to live. Many educators who teach R (or teach with R) have embraced the bookdown package, which helps you take a collection of R Markdown documents and knit them together into a polished website that engages learners. You can see some example books by browsing bookdown.org. But you don’t have to write a whole book — some of the best bookdown examples are from course or workshop notes like Columbia University’s Exploratory Data Analysis & Visualization (edav.info), R Markdown for Scientists by Nick Tierney, and What They Forgot to Teach You About R. And once you’ve been bitten by the *down bug, you may not ever recover — you may start making websites for all your workshops with blogdown and making all your slides with R Markdown.
Get serious about using GitHub in your classroom. The ghclass package provides a suite of functions to manage courses via GitHub repositories for as few as two and as many as 400 learners. This package will help you if your aim is to teach learners how to use version control with R as part of a modern data science workflow, and you want to reduce your own and their Git pains. This vignette lays out the nitty-gritty of setting your class up in GitHub with ghclass.

Reflecting on Mentorship Experience

Wed, 17 Feb 2021 00:00:00 +0000

My name is Christian Okoth and I am a senior at NC State studying statistics and English. This past semester, I participated in a mentorship collaboration between the NC State statistics department and Dr. Julia Silge from RStudio. This project used data from the paper “Persuasion for Good”, which includes a large set of quantitative data as well as free text. The original paper attempted to collect samples for speech to teach AIs and chatbots how to better persuade people using personalized information to target their bots more efficiently. Our approach was more to understand the participants through examining the words they said and see if there were any significant or interesting relationships between word use and group qualities.

Debugging and reproducibility

I had not worked formally with a mentor up until this point, but working with Dr. Silge was incredible. Her mentoring style was highly interactive. Imagine a mix between live coding and dialogue back and forth, debug in real time (that was very cool, something you don’t realize you need to know) and I could learn from asking questions about the process of exploring tools, options, manuals, and error messages alongside her. Exploration was a key part of learning; I had just enough guidance to point me in the right direction to solve my own problems.

All of this is before I learned about text processing. My R journey was largely self taught, and I hadn’t realized how much I was missing from my process. I generally don’t like to ask questions but asking questions in this environment was empowering. Working with text data was important to me, as computer text processing needs grow every day.

tf-idf and repositioning

I think my favorite part of the experience is when we explored the term frequency and inverse document frequency. I had just finished making several dynamic plots of the participant variables and the frequency plots all looked very good. Then Dr. Silge brought up some information about the topic and showed me how to do some analysis with tf-idf. So I spent the week looking over it, trying to make some more plots using pieces of her code, however I could not get a lot of the plots to make much sense. The next week, we realized that it wasn’t going to work.

The combination of knowledge and ability it requires to change strategies is immense. First you have to try and fix what is wrong. Then if that doesn’t work, you have to understand why it’s wrong. Once you do that, you pull on knowledge from experience, knowing where to look and how to find what you need. Then you can pivot to a new strategy that will accommodate the failings of the former approach. For tf-idf, we tried everything: regrouping the variables, completing any incomplete lines, adjusting the code approach (percent vs. absolute). That work only returned more garbled answers. Turn to the documentation: how does the tf-idf function work in R? How does it work outside of R? What are the principal assumptions and requirements of the tf-idf approach?

As it turns out, tf-idf wasn’t broken, it was simply an inappropriate solution to our data. Rather than discerning which conversations centered around disaster relief or religion, tf-idf discerned which words were the most or least unique for any conversation, and “rupees” is pretty uncommon in the dataset. But even between thousands of conversations, search engine level tf-idf couldn’t identify patterns within each group of conversations, so the issue was with the relative raw counts. Dr. Silge immediately thought to another technique she was familiar with, log-odds, frequently used in logistic regression. The specific tool was a Bayesian log-odds. This strategy was able to accommodate the raw counts by weighting the likelihood of finding a word in a document adjusted for document size rather than a cross document unweighted comparison, and it managed to reveal some interesting relationships within the data.

What I learned

Over the course of the semester, I learned about text processing and analysis, but I learned even more about R. There are workflows and alternative approaches, so many ways to use R that you just can’t know about without a guide through it all. This experience was unique, an approach that could not be replicated as a class. Mentoring in the R community is a pillar of what brings everyone together, and I am grateful for my opportunity to participate in it. If you would like to know more about what we did and our conclusions, you can check out the project webpage I created and published.

Online Educational Content Development: Pain Points & the Future

Mon, 15 Feb 2021 00:00:00 +0000

This is a story about one of my favorite topics: Cloud-Based Data Science. We’ll talk about what it is, its development history, and a few associated pain points. Ultimately, I’m writing this so that I can propose a dream platform for online educational content that learns from our mistakes/ experience, in not-so-secret hopes that someone else builds it.

Background

I’m now an Assistant Teaching Professor at UC San Diego. This means that I get to spend my days teaching, working with students and instructional staff members and thinking about how to do all of that better. It’s pretty awesome. Okay, I also have to do all that less-than-fun administrative stuff that goes along with teaching really large undergraduate course, but naturally using R makes even most of that a bit easier. That’s probably a different blog post though.

Anyway, before I started at UC San Diego, I was in Baltimore at Johns Hopkins Bloomberg School of Public Health working with the Leek Group and a team of incredible people to make Cloud-Based Data Science (CBDS) a thing. You see, we had this dream of getting people who typically had limited to no access to data science education an education in data science for free, in a short period of time, and without any requirements for previous programming or advanced math training.

With the benefit of hindsight, this was kind of a wild dream. Regardless, I was all in. I spent a year solely focused on getting CBDS off the ground. Naturally, there was a whole team of people focused on making this happen, and our roles were distributed across the many moving pieces.¹ Given my interest in education, it was a very natural fit that I (with others!) would focus on developing the content for the courses that would become the online program.

CBDS: Goals

From the first discussions of this project we had a few non-negotiables. The content had to:

be completeable on a Chromebook
be plain-text
have videos that were actually updateable

We wanted this content to be as accessible as possible. Chromebooks are available at most libraries and are way more affordable than typical laptops. Jeff carried out a proof of concept experiment, working exclusively on a Chromebook for months to ensure that doing data science is possible on a Chromebook. With positive results, we were committed. So committed in fact, we initially named the program Chromebook Data Science, which was later changed to Cloud-Based Data Science ². Regardless, it was settled: anyone with an Internet connection would be able to complete this program.

For the second two non-negotiables, these were largely informed by our previous development of the Data Science Specialization – a popular MOOC hosted on the Coursera Platform.

Jeff Leek tells a great story about how the Data Science Specialization team released their MOOC, only for Hadley Wickham to release dplyr right after their initial launch. This meant that a lot of the code and examples presented in the MOOC were (almost instantly) out-of-date.

This happens frequently with online courses because to update MOOCs, you typically have to not only interact with a proprietary platform to update content but you also have to spend hours in front of the camera to re-record and edit videos.

We wanted those issues to be things of the past.

For this CBDS endeavor, we planned to develop the content on a platform that allowed all of the content to be plain text. This would thus enable us to generate automated videos that would be re-compileable in an instant, rather than re-recorded in a painful and time-consuming manner.

For the plain text, we turned to Leanpub. While their experience has historically been as an online publisher of books, they were developing their courses platform at the same time we were developing CBDS. Their platform allowed everything to be written in Markua, which is a slightly-specialized Markdown syntax.

As for the videos, that didn’t exist yet. Pain point number 1.

Pain Points

With eye on our goal (make the thing!) and our non-negotiables determined (plain text, no recording videos, and could be completed on a Chromebook), we were ready to start building. And, that’s really what this blog post sets out to discuss. For some context, this post is largely borne out of a conversation that Alison Hill and I had a few months back where we discussed the pains of developing and maintaining online educational content. We both love teaching and have both, on completely separate platforms for completely different projects, run into very similar issues.

This post aims to discuss those issues, explaining all the moving pieces and pain points that surround developing the educational content we’re most interested in developing. After discussing and explaining these pain points, I’ll lay out what my dream for educational content development would be. (Y’all I’m not-so-secretly laying out these pain points along with my dream in hopes that someone who is a better engineer than I am reads this and builds my dream. If you do, I ask for no credit, but I want a heads up, so I can start using/testing it. As they say, if you dream it, they will build it. That’s the saying, right?)

Pain Point #1 - Automated videos: `ari`

The first pain point was solved fairly early in the process by Sean Kross when he developed ari.

We knew we didn’t want to stand in front of a camera and record videos. We knew we wanted them to be generated computationally. That just wasn’t actually possible.

Then, in what seemed like a weekend, we went from musing about being able to take images and text that automatically generate a video to Sean developing ari, which did precisely that.

While discussing this solution, I’ll note however that working with a new technology is never without hurdles of its own. A dependency on ffmpeg led to John Muschelli and I (okay, mostly John) staring at errors and reading documentation to figure out what was going on and how ffmpeg had to be installed to actually work on my machine. Something about an autoencoder. Or a compiler. I can’t remember. I saw a lot of error messages, and John worked his magic to fix them.

Pain Point #2 - Plain-text compilation

In realizing our plain-text educational content development dream, we worked with Leanpub, which was wonderful. I don’t know a team of more helpful and responsive ³. Despite their awesomeness, as noted above, when things are new, they’re new.

For us, this meant that everything worked well, as long as I didn’t make any mistakes. If I missed a ? in quiz development or a { somewhere to specify the course settings, compilation of the course would fail. Leanpub would let me know that it failed, but their error messages were not always the most helpful. I wouldn’t always know in which file the error was encountered, let alone the line. So, it involved a lot of me staring at files until I figured out which one was causing the problem.

For sure in time (and much already has) Leanpub will improve these error messages, but it was early on. We wanted to use a new platform. With this, we gained a ton of flexibility but also a few bumps in the road. While plain-text development became a reality (yay!), we had to work through some compilation headaches (worth it.).

Pain Point #3 - Tracking all the things

I’ll note that issues with the Markua syntax during development were not the only compilation issues. Our compilation issues were by no means only on Leanpub. I haven’t quite made clear yet just how many pieces there were for each course.

For each course, there are approximately 12 lessons.

Each lesson contains:

the text that becomes the lesson on Leanpub
the text that becomes the words in the video
the images that are used in the video and the lesson on Leanpub
the compiled video

Assuming that there are 15 images in a lesson (a conservative estimate for sure), for each course there would be ~24 different text files, 180 images, and 12 videos.

And there were 12 courses. So, 288 text files, 2,000+ images, and 144 videos.

Every time we found a typo, text was edited, videos were recompiled and re-uploaded to YouTube, and the lessons were recompiled on Leanpub.

There were a lot of moving parts, and we needed a way to keep track of everything.

For example, let’s think about the videos. If the text in a video file has been updated since the last time the video was compiled, then the video needs to be recompiled. If the video has been recompiled since the last time it was uploaded to YouTube, it has to be re-uploaded to YouTube. Then, once that happens, we need to be sure the URL for the YouTube video in the lesson is updated, so that the right video shows up in the lesson, which means, we need to recompile on Leanpub.

And, that’s just the videos.

There was a lot to keep track of.

Enter: John Muschelli (again) and didactr.

John Muschelli developed didactr after I had been building content for three months, so I know just how helpful didactr was. didactr was initially developed to help track all the pieces of a course. This means it was used to:

determine if all images mentioned in a lesson actually exist
check to see if the images and text for a video line up
use images from Google Slides⁴ for videos
generate videos if needed
upload videos to YouTube
update YouTube links in lessons
etc.

The pain point was tracking all the pieces. John addressed that with didactr. Then, YouTube gave us the big ole’ no ma’am when it capped the amount of videos that can be uploaded in a day. Whenever we do a large update now, using YouTube’s API is not an option. We’ll call that pain point #3.5. It’s still a pain point. I manually updated all the videos for our last large update. And, because I’m human, I’m sure I made some mistakes. I trust the Internet will let me know. The Internet always lets you know.

Pain Point #4 - Delivering on non-negotiable #1

Remember that theme of using new things? Well, what made CBDS possible at all, was RStudio’s release of RStudio Cloud, which was in alpha when we started CBDS development. Like Leanpub, the RStudio Cloud team was amazing. They were totally on board when we pitched CBDS to them, in which we said something along the lines of: “Well, we don’t really have any idea of how many users we’ll have. Could be 10. Could be 10,000.”

RStudio Cloud was not a pain point in and of itself. I think RStudio Cloud is a game changer. But, while cloud-based products get rid of the need to deal with software installations and general command line bullshittery, you’re at the mercy of the application. When RStudio Cloud is down, it’s down. There’s no getting around it. This happens less and less over time as the product gains stability, but early on, this was a pain point.

It was particularly problematic when we were doing in-person tutoring for our adjacent CBDS+ program. For these, we provided scholars with Chromebooks to complete the program. When RStudio Cloud was down, work was down.

Pain Point #5 - Bug Fixes

Let’s just continue with my new thing theme. CBDS is still new. This means we, like all the new technologies mentioned so far, have bugs too. I’ve done my very best to keep up with them (as the whole team has). I’ve fixed typos (including my infuriating inability to correctly type the word individual more times than I can count). I’ve fixed quiz errors. I’ve removed content. I’ve added content.

And, maybe most frustratingly, I fixed the bug caused when the new version of R’s sample() function was not backward-compatible. With a single update, ~80% of our quizzes were rendered unable to be completed, as they would mark the correct answer as incorrect every time. Cloud-based products are awesome, but you don’t get to necessarily control when updates occur. Nor, do you always remember to test things immediately after updates. Come to think of this, I should have way more tests in place than I actually do…

Pain Point #6 - Assessment

I mentioned the breaking sample() change that occurred with the R update. The reason this was so problematic is because we have a sub-optimal approach to assessing learning.

We originally used a third-party company for extra programming practice. This means that learners would answer quiz questions on Leanpub and would have the option to get outside practice on a different (paid) platform. It was free to participants in our CBDS+ program, but not to the rest of the world.

This means you could (initially) complete the program without really getting true practice with the hands-on portion of the curriculum. Certainly less than ideal.

We scrapped the outside company in favor of a system where learners get practice using swirl on RStudio Cloud. This involves learners completing a swirl module and then, upon completion, receiving a code. This code is then the “answer” to the quiz on Leanpub.

While this has been a huge improvement to our initial approach, it’s still not seamless. Learners have to leave the course material, go to RStudio Cloud, complete the practice, copy the code, and get the credit. Not. Ideal.

The Dream

Y’all I’m writing all of this down to spell out the fact that I absolutely still love this project in spite of these hurdles. I think we’ve built something really special. I think the speed at which we were able to develop it all is impressive ⁵. All that said, it is so far from perfect, but it is special. CBDS is doing something hard. Teaching programming online is tough. Teaching data science to people with no background is important. And, we’re doing that.

But…BUT…we can do it better. Here’s my dream of what that would look like from the development side.

My dream platform would be a platform with which I’m already familiar (::cough:: RStudio ::cough::) because who wants to learn another NEW platform? Developing in RStudio is my happy place, and this is my dream. So, I’d want this to be developed within RStudio.

Within this dream platform, there would be a way to develop adaptive content for lessons. For example, for people struggling with a certain concept, they would get additional detail and extra practice questions before moving on to the next section. People who have got the concept down pat would move on directly. This would be specified within a text-based format.

This platform would allow code to be run and tested (think quiz questions) directly within the lesson on the platform as learners are taking it. No separate platform. Code would be written and feedback provided right then and there.

It would also allow larger projects to happen as they would in the wild. For example, projects would be completed in a separate RStudio Cloud Workspace to ensure learners were getting comfortable outside of the educational platform in what they’ll be using after they complete the course. These projects would also provide learners with magical feedback that helps them improve going forward.

Videos of production-quality would be created and edited in some magically short period of time. Okay, maybe that’s gone too far. Maybe we would just be able to include ari videos. That would be acceptable in my dream.

Images would be able to be inserted with each and maybe even dragged and dropped into place. (Yeah. I said it.) In this dream world, they would magically self-organize.

During development, there would be a Viewer preview of what the compiled course would look like. This would allow for interaction and testing directly within RStudio (have I convinced you future developer that this platform has to be RStudio yet?). Error messages during compilation would be brilliantly precise, pointing me directly to where my fingers led me astray during development. (It’s probably got something to do with my inability to type individual.)

Beyond development (because this is my dream), this platform would track user habits and pain points, to make bug fixes and educational improvement more seamless. Right now, I’m pretty limited to quiz scores and bug reports. Granted, Leanpub has more, but I don’t have access to that. As an educator, I want to improve my stuff, so having access to this information would be super helpful. (And maybe a dashboard per course summarizing user information would be great….that may be going too far?) I’ve gone too far. I’ll stop my dreaming there.

So…if we could make this dream into a reality, I would happily test it out and find all the pain points to write about in a future dream-realized blog post.

Note that this blog post focuses on the education technology aspect of this project and doesn’t even touch on the incredible work being carried out by Ashley Johnson (Program Administrator) and Simone Sawyer (Scholar Advocate), who deserve so much credit for managing and supporting the program and scholars since its launch, nor does it highlight the importance of HEBCAC (The Historic East Baltimore Community Action Coalition) and Edward Sabatino (Executive Director, HEBCAC), whose collaboration and insight have been critical for its success. For those interested, more has been write about the program implementation side here. ↩︎
We’re not marketers. We didn’t really consider the fact that Chromebook Data Science makes it sound like you need a Chromebook, not just that it’s possible to complete a Chromebook. This probably should have been more obvious to us. ↩︎
On a train ride from Baltimore to Boston I found a bug that caused our lesson on how to write functions to show code for precisely zero functions. I reported this bug on our slack channel with our awesome Leanpub people, not realizing it was Thanksgiving in Canada, where the Leanpub team lives and works. Upon realizing that, I asked the team not to worry about the bug, but they assured me that they were done with their family time and had finished their celebrations. The bug was fixed that day. ↩︎
Did I not mention we used Google Slides for our images? It was the best way we knew how to keep images in order, and it allowed us to link to the images directly rather than hosting all our bazillion images on GitHub. ↩︎
This is me bragging on the rest of the team, not on myself. ↩︎

Distill it down

Mon, 08 Feb 2021 00:00:00 +0000

Introduction

This post describes my journey to creating a personal website using the distill package. Along the way, I took some detours using R Markdown to create webpages and a website for a course I teach. This is not a how-to tutorial (although I will provide links to resources I used to help me along the way) but rather a reflection on why I made the choices I made. I hope this might help some of you decide which tools you might use in creating your own website.

My blogdown fail

My journey with using the distill package to make a website began back in March of 2019 with the fancier, more customizable blogdown package. I had just gone through the R Studio instructor training and was about to be on spring break from my job teaching at Macalester College. The instructor training had me motivated to finally build a website and that break seemed like a perfect time to do it. At the time, the only tool I had heard of for doing such a thing was blogdown

Then, like many in the US and other parts of the world experienced, the news came that I would be teaching online for the rest of the semester, my husband would be working from home, and we’d have our elementary school kids home learning, too. So, creating my website took a backseat. I gave myself about 2 hours one afternoon to try to get a blogdown site up and running, but I kept getting bogged down in the details and quickly gave up.

I just looked back at my attempt and it’s not as terrible as I initially thought. But, for me, the blogdown site was more than I needed. Ideally, I wanted something simpler, but what else was there?

Hello R Markdown and Netlify!

Around that same time, I saw an advertisement for an R Studio webinar by Alison Hill and Desirée De Leon titled Sharing on Short Notice: How to Get Your Materials Online With R Markdown. Wow! The description sounded like just what I needed both for getting my personal website up and running and to help put R-related materials on the web in an easy way for my students. At the time, I was feeling overwhelmed with life (who wasn’t?), so I didn’t watch the webinar right away. Instead, I kept it open on a tab and tweeted out a reminder to myself:

I want to use this now but just can't find the time. But thanks for sharing. I've added it to the summer to-do list. https://t.co/aDfLkivOkr
— Dr. Lisa Lendway (@lisalendway) April 1, 2020

Fast forward to mid-May 2020. My summer break had started, and one of the first things I did was finally watch the Sharing on Short Notice webinar. I loved their analogy of “Climbing R Markdown Mountain” and was surprised to learn that the two tools I had heard of, bookdown and blogdown, were two of the more complex tools. This webinar was also where I heard of Netlify (a platform for easily deploying a website) for the first time.

It wasn’t until August when I finally put the tools to action. I was in the thick of prepping course materials for my Introductory Data Science course. I knew I wanted to put them online both to make them easier for my students to access and to make them accessible to people other than my students. In the past, I had just uploaded either R Markdown files or knitted html files (with the Download Rmd option) to the course moodle site (moodle is a course management system).

After watching the Sharing on Short Notice webinar a few more times, I decided to start at the base of the mountain, not even entering the website realm, by creating a single webpage from an R Markdown document. I did this for each topic in the course, ending up with five separate webpages for the course.You can see an example of my first site here. This is NOT fancy, but it worked well for me for a couple reasons:

It was EASY! The only new skill I had to learn was how to deploy to Netlify. The process goes like this: Create an R Project (I also put it on GitHub) –> make the R Markdown document –> knit to html –> drop the project folder on Netlify (or, link to GitHub repo). It was very similar to what I had already been doing - uploading the files to moodle. To be honest, it was even easier! I only had to put a link to the Netlify webpage on the moodle page. And, because the Netlify page was deployed through my GitHub repository, changes to the document were automatically updated on the webpage when I pushed them out.
I didn’t need to think a lot about website design because each topic was just a single webpage. I did make sure to use the same theme throughout, but that was about as much as I thought about web design. This keeps the YAML simple, which I like for my intro students since many of them download the R Markdown code for the files.
I could easily compartmentalize the different course topics because they were their own projects (separate folders) and their own webpages. After the first few weeks of the quarter, I was prepping course material in a just-in-time fashion, usually finishing the same day the students needed to use it. Having separate projects made it easy to forget about an old topic and move onto a new one.

This list of pros for using R Markdown webpages has many similarities to the corresponding list of cons:

Being able to easily compartmentalize topics meant making 5 (actually 6, if I include an R Basics page I use for multiple courses) different webpages! Yikes, that’s a lot of webpages to manage and still required me to use the course management system to unite all the material together. Although I have folders organized fairly well, there are six smaller projects rather than one large project.
The webpages feel a little “plain”. This was purposeful because I wanted a simple YAML but perhaps a bit sad :(

An R Markdown site

By the end of my first quarter of teaching, I was happy with the material I had produced and glad it was online where I could share it with a larger group, but I wanted to better unite the material. To do this, I started climbing “R Markdown Mountain”. I chose the easiest hike and created an R Markdown website: my course website.

Although I was again tempted by some of the other options, I decided against them for the following reasons:

Both blogdown and distill were going to require more thought than I had time for, including potentially making changes to the R Markdown file. I also wanted to keep the same theme (albeit a bit plain) for anyone who was already using the webpages, especially my students, which might require changing some CSS - I wasn’t ready to delve into that yet, either.
Using the bookdown package seemed like a good option, but it would also require some changes to the R Markdown files and I could not figure out how to nicely add the code download button at the top of each chapter so students (and others) could download the R Markdown file for each topic.

Truthfully, I also did quite a bit of “cheating” in my R Markdown website. One of the bad parts of an R Markdown website is that you can’t have subfolders. Since my individual topic webpage projects each already had many files in them, this would have led to a very messy folder full of files. So, I just used the R Markdown site to unite all my individual webpages. Each topic still has its own webpage that is linked in the R Markdown website. I was able to create this site in well under an hour (yay!) and it serves its purpose for now.

I’ve finally put all my Intro Data Science materials in one place! It may not be the cutest website but it was quick to make. I hope the material might be useful to new #RStats users or people using R to teach data science. https://t.co/JkJMti8AEi
— Dr. Lisa Lendway (@lisalendway) November 23, 2020

When time allows, I will reinvestigate the organization of this website to try to make it more cohesive.

Distill it down

Remember, this journey began with me wanting to create a personal website. I felt a little overwhelmed with a blogdown site when I first tried it but also felt like that was the route I needed to go since many of the R blogs I visited were built using blogdown. A couple of things changed my mind:

Watching the distill portion of Sharing on Short Notice a couple more times illustrated how simple it was to create a site.
Reading some of the distill documentation confirmed that it was fairly easy to do.
Other distill sites I perused looked really nice! Two of my favorites are by Ijeamaka Anyene and Shannon Pileggi, aka Piping Hot Data. Shannon even tweeted about using distill!

I love the distill package! 🙌 🎊Distill empowered me to start sharing #rstats content 💪without the learning curve of blogdown/hugo 🗻. You can check out my distill backed blog at https://t.co/dLa6zI1iSb. https://t.co/Q0CzNl6oEm
— Shannon Pileggi (@PipingHotData) December 8, 2020

There was enough I could change about the website to make it look unique, but the defaults were a good start. My procrastination also seemed to pay off because new updates to the distill package made theming (customization, ie. font/title/background/navbar/etc. colors, sizes, styles, etc.) even easier with the create_theme() function. This function creates a CSS file with commonly used CSS selectors that you can easily change. You can change other CSS selectors, too, but you may need to know a little more about CSS to do that. If you’re like me and are very unfamiliar with CSS, I would recommend only changing the defined ones first - there is plenty there!

After making the decision to go with distill to build my website, it was time to visit more resources. These are the ones I used most:

Alison Hill and Desirée De Leon’s Sharing on Short Notice. I’ve probably talked about this enough, but it is an amazing resource.
The distill documentation, which also happens to be a … distill website!
Thomas Mock’s distill how-to, which I wish I would have seen before starting to build my site rather than in the middle of it.
Alison Hill’s recent updates on theming, if you want to change the default theme. And read it thoroughly (I may not have done that the first time)!
Other people’s GitHub repos for their distill sites. The two I visited a lot were the corresponding repos for the sites I pointed out earlier: Ijeamaka Anyene and Shannon Pileggi, aka Piping Hot Data. This was a good way for me to dig into the code in more detail, and I could often copy, paste, and modify slightly to fit my needs.

With these resources at hand and open in my web browser, I was able to get started on buildng the site. The first time I tried, I got stuck on the CSS theming (hence the recommendation to only modify the easy-to-modify selectors at first). Then, I re-read the Create theme documentation (remember when I said to read that carefully the first time?), got a little help from @spcanelon on Twitter, and made a step-by-step guide for myself. The next day, I tried again, and had the website up and running within an hour! I documented this in detail on my first blog post on my distill website. The post also has embedded screencasts of me creating the site.

I took some time after the video to further play around with customization, especially colors, most of which are inspired by William Morris’s Strawberry Thief textile. I’m happy with the website’s unique look combined with the simplicity. Each blog post has its own folder of files, so it is easy to stay organized. I like that blog posts are not re-rendered when the website is built. So, you need to knit each blog post and build the site in order for that blog to be updated, but you don’t have to worry about code in an old blog post breaking the website. I am starting to think that distill may be the tool I use for future course websites for all these reasons.

In conclusion, I hope I have given you some reason to check out distill for creating a website. Or maybe I’ve even helped you decide to use some of the simpler tools available. Either way, I wish you luck on your journey.

Learning R Coding by Building Something Cool

Thu, 28 Jan 2021 00:00:00 +0000

In the fall semester of 2020, RStudio piloted a program to provide mentorship to Black, Latinx, and Indigenous students in data science. I had the opportunity to participate in this program, and used it to focus on learning and developing my skills with R. Over the course of three months I worked closely with Janeka Handford of RStudio, who went the extra mile ensuring that I not only reached the goals outlined via the mentorship but also gained a much deeper understanding of R coding processes in general. Through our combined efforts, I was able to build a small interactive shiny app that explored the geographic data of wildlife-vehicle collisions in North Carolina between 2014 - 2018. With the shiny app dashboard, we were able to sort our data by county and year allowing for specificity. Shiny has really shown me how vast amounts of data can be easily filtered and used in geographic visualizations, and how much fun it can be to learn by building.

Newly certified instructors in December 2020

Tue, 22 Dec 2020 00:00:00 +0000

We welcomed 10 new instructors to our community in December 2020:

This brings the total number of certified Tidyverse instructors to 186 (including our first in Uganda), and the number certified for Shiny to 33. If you would like to speak with any of them about your training needs, their contact information is on the trainers’ roster and they would be happy to hear from you.

It has been a difficult year, and as it ends, many of us will be thinking of family, friends, and colleagues who are no longer with us. We hope you and yours are safe and well, and we wish you the best for 2021.

Building capacities to teach data science in Latin America

Fri, 18 Dec 2020 00:00:00 +0000

What?

On March 16th, 2020, all in-person classes and training opportunities were canceled in Argentina due to the pandemic with no clear indication on when they will resume. Hence a group of academics, researchers, and teachers with deep ties to the Latin American research and teaching community that have been working in the R community together co-founded MetaDocencia.

MetaDocencia means MetaTeaching in Spanish. Our mission is to nurture a community of Spanish-speaking educators by teaching concrete, evidence-based, and student-centered educational methods.

We collaboratively develop open, reusable, and accessible resources to foster effective training practices.

You can read more about our mission and materials (in both Spanish and English) on our website https://www.metadocencia.org/:

Why?

Despite the existence of open educational communities throughout the world, they are mostly English-speaking and language is an enormous barrier in Latin America. Translations of contents are necessary but not enough for culturally-responsible teaching. Meeting our learners where they are in Latin America means to not make assumptions about the knowledge of technologies such as Zoom, Slack, or Google docs and being conscious about internet access and accessibility differences.

There is a ton of terrain leveling work needed before meaningful international integration is feasible. Communities of practice are still a new concept in our region and tools like active classrooms powered by minimal technology such as peer instruction, shared note-taking, or a code of conduct, are far from being standard in online classrooms throughout Latin America. Nor are tools such as licenses for sharing educational material known. We work at MetaDocencia to help bridge this gap by empowering educators from underserved countries.

How?

We have largely focused on a 3-hour workshop called Introduction to Online Teaching Essentials. This hands-on workshop builds on open educational resources to teach how to run a synchronous classroom and includes practical evidence-based tips for delivering an engaging online class that we learn from The Carpentries and RStudio Instructor training. This is a first-steps workshop where we introduce the key aspects from our teaching philosophy (e.g., code of conduct, open licensing, community building, active teaching). Participants experience each of our tips and advices starting at pre-registration and stay in touch afterwards through our Slack. Since March 27th, 2020, we taught this workshop 38 times to a large fraction of the 1,250+ Spanish speaking teachers from 19 countries, who registered their interest, with over 90% completion rate.

We are piloting a 2-hour hands-on workshop about how to use Zoom to teach online, which is the most common request from our participants. We are also creating a 3-hour workshop for creating interactive tutorials to teach to code with R using the R package learnr that will be part of a longer track on how to teach programming.

We foster a community through a 100% Spanish-speaking Slack workspace, where the 350+ members are encourage to share their material, resources and experiences. We are also active tweeps and asynchronous content creators.

With whom?

We also build community by working together with other communities and institutions at local, regional, and international levels. For example, our current materials have been repurposed to suit audiences of early career researchers at the National Agricultural Technology Institute in Argentina.

We taught tutorials for LatinR, a Latin American conference for the use of R in research and development. We also repurposed our materials to encourage the Spanish-speaking R-Ladies community worldwide to continue having events, gatherings, and teaching online through pandemic times.

We also translate to Spanish educational and technical material like the book Teaching Teach Together by Greg Wilson.

Finally, thanks to the generous support of the Carpentries, we hosted an à la carte instructor training workshop in Spanish that had a 95% checkout rate.

Who?

We achieve our mission with the work of a fast-growing group of volunteers with experience in teaching technical skills, delivering online classes, and working remotely, both locally and globally. Our team now includes 11 collaborators in 3 countries and 6 different cities in Argentina. They are RStudio Certified instructors, Carpentries instructors, and/or regionally-knowledgeable accessibility experts.

All MetaDocencia’s activities are free and open and are carried out through 100% volunteer work, with a small grant by Open Bioinformatics Foundation to cover infrastructure costs.

We are also blessed by an international advisory team that is guiding us in our goal of thinking globally while acting locally.

What we learn?

Teach with the example: use in your courses and in your community all the tools and advice that you teach.

Excelente el curso de hoy, súper claro, didáctico, aplicable, una recomendación buena tras otra, cierra por todos lados. Recomendable 100%. Y además, grátis! Infinitas gracias por tanta dedicación, empatía, y compromiso

— Fernando Torres (@torresf1973) April 11, 2020

Tweet translation: Excellent today’s course, super clear, didactic, applicable, one good recommendation after another, everything so usefull. 100% recommendable. And also, free! Infinite thanks for so much dedication, empathy, and commitment.

Remix, reuse, reshare: materials with licenses that allow derivative works, such as translations and remixing of courses, reduce the time to generate content, increase quality resources and ensure a successful teaching-learning experience, because are proven materials.

Compartir material y mantener la autoria. Todos se ven beneficiados! Buenisima la iniciativa y los consejos de @metadocencia https://t.co/tGyMSEOhJ4

— Virginia García Alonso (@VA_GarciaAlonso) October 13, 2020

Tweet translation: Share material and maintain authorship. Everyone benefits! Very good initiative and advice from @metadocencia

Every crisis brings an oportunity: the pandemic and the concern of its students forced many teachers to teach online. The tools we teach are also useful for in person classes and more learners will experience an active and interactive education: a better way to learn and teach.

@metadocencia @mariela_rajng @yabellini En relación a “Intro al ABC para enseñar on-line”
Les quiero felicitar, una maravilla tode, excelente lo q hacen x todes
En estos momentos de crisis, su ayuda es el camino para salir adelante
No bajen los brazos. Este mundo necesita d uds!

— Cristian Rodriguez (@Cristia42038941) October 2, 2020

Tweet translation: In relation to “Intro to ABC to teach on-line” I want to congratulate you, everything is wonderful, excellent what you do for everyone. In these moments of crisis, your help is the way forward. Do not give up. This world needs you.

Shared pain is lessened, shared joy increased: our most important capital: the community, the support of fellow teachers in our language through sharing advices, experiences, materials, frustrations and successes build a strong community that make everything less hard.

Recién terminado! Espectacular, sumamente interesante y constructivo. Muchas gracias por compartir su experiencia y conocimiento, en esto que para muchos es nuevo y que ademas de todo requiere de creatividad, humildad y generosidad (las 3 estuvieron en el taller). https://t.co/V3bBSXGV71

— Lorena Laffitte (@lorelaffitte) April 11, 2020

Tweet translation: Just finished! Spectacular, extremely interesting and constructive. Thank you very much for sharing your experience and knowledge, in this [situation] that is new for many of us, and in addition to everything else, requires creativity, humility and generosity (3 things that were present in the workshop).

Stay in touch

If you like this initiative, if you want to take one of the courses, if you want to help, or even you want to replicate this experience in your country, we are always happy to welcome more people in MetaDocencia. There are many ways to participate, drop us a line and follow us.

Supporting the Carpentries

Mon, 07 Dec 2020 00:00:00 +0000

The Carpentries is a volunteer organization dedicated to teaching foundational coding and data science skills to researchers. Over 73,000 people have attended Carpentries workshops since 2012, and despite the disruption caused by COVID-19, they taught over 200 workshops in 2020 alone. They have helped a lot of people get more done in less time and with less pain, and RStudio is proud to support their work through a donation to their fundraising campaign.

Newly certified instructors in November 2020

Thu, 03 Dec 2020 00:00:00 +0000

We welcomed 6 new instructors to our ranks in November 2020:

This brings the total number of certified Tidyverse instructors to 179, and the number certified for Shiny to 32. If you would like to speak with any of them about your training needs, their contact information is on the trainers’ roster and they would be happy to hear from you.

Our classes are now full for the time being, but if you would like to join our waiting list, please fill in this form.

#BlackInDataWeek 2020

Mon, 16 Nov 2020 00:00:00 +0000

Today marks the first day of a week-long celebration called #BlackinDataWeek. Its aim is to amplify Black voices in #informatics, #datascience, and #coding around the world. The goals are to:

Providing community and a support system for Black people in data across the Black diaspora.
Encouraging growth in our professional and academic learning paths.
Elevating the voices and experiences of Black people working in data fields.

Read on to find out more about what events are planned, and how you can engage with #BlackinDataWeek.

Events

date	hashtag	purpose
2020-11-16	#BlackInDataRollCall	Giving Black people in data a space to introduce themselves and their work. Introducing and valuing intersecting parts of their identities. We welcome contributions from a wide spectrum of Data Fields including but not limited to Informatics, Technology, Data Science, Coding, Social Science and Data Analytics.
2020-11-17	#BlackInDataJourney	Further fostering community for Black people in data, by encouraging them to share their varied journeys in data.
2020-11-18	#BlackInDataSkills	Discussing the skills Black people in data have learned, communal sharing of resources and advice for skills development.
2020-11-19	#BlackInDataViz	Creating space for Black people in data to share their work in the form of favourite data visualisation images.
2020-11-20	#BlackInDataJustice	Hosting forums for learning and discussion of bias in the data field (and possible paths to address biases in data).
2020-11-21	#BlackInDataMentorship	Join us for career development and mentorship events!

How to engage in `#BlackInDataWeek`

Day 1, Monday: `#BlackInDataRollCall`

If you identify as Black, join in the roll call today by introducing yourself and sharing what you do in data. Include the hashtag #BlackInDataRollCall and tag @BlkInData.
If you do not, use today to amplify the voices in the #BlackInDataRollCall hashtag by following and retweeting!
If you haven’t already, follow the @WeAreRLadies rotating curator account. This week, Markia Smith will take over (Nov 16-20th) and Damilola Alex will be taking over next week (Nov 23-27).
You can also follow the @miR_community account. MiR is a community for underrepresented minority users of R, founded by Dorris Scott and Danielle Smalls-Perkins.

Day 2, Tuesday: `#BlackInDataJourney`

There are three events on this day, check them out here. Note that there will not be a #TidyTuesday this week in order to create space and engage with the #BlackInDataViz hashtag on Twitter.

Day 3, Wednesday: `#BlackInDataSkills`

A great day filled with learning-oriented events, and don’t miss the 1-hour Introduction to R with Dr. A Nayena Blankson.

If you want to dive deeper into the tidyverse, the MiR Community recently hosted an hour-long introduction to the dplyr package by Daryn Ramsden. You can view the webinar on YouTube, and view his slides here ( source files here).

Day 4, Thursday: `#BlackInDataViz`

Again, several great events and talks, as well as a Black In Data Visualisation Challenge. The challenge, presented in collaboration with the Data Visualization Society, will “highlight data that shows Black people in a positive light.”

Day 5, Friday: `#BlackInDataJustice`

Webinars feature timely topics around algorithmic fairness and bias. The last event is a live viewing/tweeting of #CodedBias in honour of #BlackinDataJustice hosted by Anna Gifty, @itsafronomics, a researcher interested in data bias and algorithmic fairness.

You can access the screening here: https://www.saltlakefilmsociety.org/comingsoon/coded-bias

(Note: tickets are not free, but you can follow along with the live tweeting without watching.)

Day 6, Saturday: `#BlackInDataMentorship`

The final day is all about careers and mentorship. Read more about the events here.

To sign up for events, click here! To learn more about #BlackInDataWeek, please see their website, twitter account, and follow along via the #BlackInDataWeek hashtag.

Newly certified instructors in October 2020

Fri, 30 Oct 2020 00:00:00 +0000

We welcomed 17 new instructors to our ranks in October 2020:

This brings the total number of certified Tidyverse instructors to 173, and the number certified for Shiny to 27, including our first instructors in Nigeria and Russia. If you would like to speak with any of them about your training needs, their contact information is on the trainers’ roster and they would be happy to hear from you.

Our classes are now full for the time being, but if you would like to join our waiting list, please fill in this form.

Learner Personas

Wed, 07 Oct 2020 00:00:00 +0000

A learner persona is a short description of a typical learner that helps instructors figure out who they’re trying to teach and communicate that understanding to each other and to learners. Like the personas used in user experience design, each one includes:

the learner’s general background,
their relevant prior knowledge or experience,
what they think they want to learn (as opposed to what the instructor thinks they ought to), and
any special considerations such as accessibility needs.

Last year the Education team at RStudio drafted nine personas to capture key characteristics of the people we’d like to help with our classes and materials. If you regularly teach someone who doesn’t fit one of these, please let us know.

All images © anarres.

Anya Academic

Anya, a professor of neuropsychology, studies color perception in infants. She is also responsible for teaching an introduction to statistics to 1100 first-year students every year. (Students complain that the Stats department’s introductory course is too theoretical and requires more programming knowledge than they have.)
Anya runs several experiments on 50–100 infant subjects each year. She used to analyze the results with SPSS, but is switching to R (which she taught herself during a sabbatical). She has never taken a programming course, and suffers from impostor syndrome in discussions about things like GitHub and R Markdown.
Anya would like to learn more about time series analysis to support her research, and about tools like Git and R Markdown. She also wants guidance using R to teach her intro stats course, which currently uses a mixture of Excel and SPSS.
Anya is juggling half a dozen responsibilities at work, and doesn’t want to look uninformed in front of her colleagues and students.

Anya needs workshops (so that she can allocate focused time) and how-to guides (for her research). She would like ready-to-use lesson material she could remix for her students and some orientation material to demystify jargon (what the hell is a “pull request”?). Finally, it’s important that she be able to use the same tools in her research as in her teaching in order to amortize learning costs and stay in practice.

Celine Certified

Celine has an MBA in finance and is now a certified RStudio instructor working for a full service solution provider. She spends her time developing new training material in airports and delivering them between flights.
R is the only language Celine has ever learned well, but she has learned it very well. She is proficient with a variety of packages for modeling and time series analysis, and knows more than any sane person should about extracting data from Excel. She regularly contributes small fixes to a dozen of the packages she teaches most often, and tries to answer one Stack Overflow question every working day.
Celine is always interested in seeing other people’s teaching material, but what she appreciates most is up-to-date examples she can recycle and build her own lessons around.
Celine is sometimes frustrated by how little developers think about the learnability or usability of their packages, and wishes she had more control over what she’s going to be asked to teach.

Celine needs vignettes, worked examples, and cookbooks that she can mine to create training to meet her audience’s needs. She would also like pointers to material on better teaching practices.

Exton Excel

Exton taught business at a community college for several years, and now does community management for an event management company. He still teaches Marketing 101 every year to help people with backgrounds like his.
Exton uses Excel to keep track of who is registered for webinars, workshops, and training sessions. He doesn’t think of himself as a programmer, but spends hours creating complicated lookup tables to figure out how many webinar attendees turn into community contributors, who answers forum posts most frequently, and so on.
Exton knows there are better ways to do what he’s doing, but feels overwhelmed by the blog posts, tweets, and “helpful” recommendations from the company’s engineering team.
Exton is a single parent; the one evening a week he spends teaching is the only out-of-work time he’s able to take away from family responsibilities.

Exton wants an overview that will tell him what laptop-scale data science is all about, what tools to learn first, how they’re going to help him, and where he should look for introductory tutorials. He doesn’t care if these are the best answers so long as they are clear, concise, and consistent. He would also benefit from side-by-side comparisons of Excel and R.

Jacqui Ofalltrades

Jacqui works for a three-person consulting company that does everything from training to installation and administration to building dashboards for clients. She is fluent in Spanish and Portuguese as well as English, and much of her business is with Latin American firms.
Jacqui has been using Python and Pandas for several years, and just finished working through R for Data Science for the second time in preparation for teaching the tidyverse. She has built a couple of Shiny dashboards for clients, and hopes to get a package accepted by CRAN some day.
Jacqui wants updates on what’s new in RStudio products and related data science packages and tools, and advanced guides for making Shiny faster, integrated with no-SQL databases, and other high-value topics. She finds most self-paced tutorials frustrating because they’re answering questions she doesn’t have today.
Jacqui believes that time is money: every minute she spends learning something new has to pay off sooner rather than later.

Jacqui wants how-to guides and reference material for her day-to-day work, webinars to give her a sense of where the industry is going, and short, intensive online training for very specific topics.

Katrin Keener

Katrin did a Master’s in neuropsychology and a 12-week data science bootcamp before getting a job analyzing logistics for a health care services company. She has a wide range of interests and loves learning new things.
Katrin uses R, Python, and SQL daily, and recently talked one of the IT staff into teaching her Docker. She has done several online mini-courses in machine learning.
Katrin wants to level up her understanding of just about everything. She needs cookbooks and worked examples to show her how to accomplish specific tasks or to fill in specific gaps in her knowledge.
While she is enjoying her new job, Katrin misses the camaraderie of grad school and her Insight fellowship: she prefers learning with others to studying on her own. She recently found out about R-Ladies and has enjoyed the two meetups she has been to.

Katrin wants workshops (as an opportunity to meet people) and self-paced lessons (so that she can learn new things on her own). She has a complete set of cheatsheets taped up on her wall, but usually checks Stack Overflow before looking at reference manuals.

Larry Legacy

Larry got a job with a pharmaceutical company the day after he graduated and has been with them through two mergers and an acquisition. He refers to company officers by their first names, and is always happy to explain what they’re doing wrong. He was offered the chance to go to rstudio::conf last year, but gave the spot to one of his younger colleagues because “they’d probably enjoy it more”.
Larry has been using SAS for 25 years and regards it as a perfectly fine tool, thank you very much.
Larry has never used R, but has decades of experience with statistics, messy data, and reporting. He prefers very structured learning environments and clear objectives, and his most common question, “How would I…” followed by a summary of something he has been doing for years in SAS.
Larry is a reluctant learner: he recognizes that he has to learn R now that management has decided to adopt Shiny for all its reporting tools, but with just eight years to go until early retirement, the thought makes him weary. He is very uncomfortable with anything outside his normal working environment: he needs to see how to use an IDE step by step (preferably in a one-on-one tutorial) to get over his paralysis.

Larry finds tutorials long-winded (“Just show me what function I need to call!") or confusing (“Why would they do it that way?"). Cheatsheets showing him how to map his understanding of SAS to equivalent code in R would be his preferred starting point.

M’shelle Manager

A programmer who moved into customer support and then into product management, M’shelle is now in charge of a ten-person analytics group. She is responsible for getting her team trained and purchasing the tools they need to do their work.
M’shelle thinks in Java; she used base R to develop models and generate reports several years ago, but was promoted before the tidyverse became popular.
M’shelle wants to improve her team’s processes, particularly around packaging code and making work more reproducible. The new VP of engineering has also asked her to turn everything into a web service. While all of this is going on, she needs to decide how much budget she needs for new software that she will personally never use.
M’shelle has to work within a strict training budget, and it can sometimes take months to get approval for off-site training (and even longer for on-site).

M’shelle needs tutorials, reference material, and how-to guides for everything that isn’t data science, including testing, packaging, and Shiny. (Her team is satisfied with the existing tutorials on data manipulation and modeling.)

Nang Newbie

Nang is 18 years old and in the first year of an undergraduate degree in urban planning. He’s read lots of gushing articles about data science, and was excited by the prospect of learning how to do it, but dropped his CS 101 course after six weeks because nothing made sense. He’s doing better in Anya Academic’s course (which he is taking as an elective), but still spends most of his time copying, pasting, and swearing.
Nang did well in his high school math classes, and built himself a home page with HTML and CSS in a weekend workshop in grade 11. He has accounts on nine different social media site, and attends all of his morning classes online.
Nang wants self-paced tutorials with practice exercises, plus forums where he can ask for help.
Nang is reluctant to reveal his ignorance—he would rather get a low grade and blame it on partying than let his classmates see that he’s floundering.

Nang needs short overviews to orient him and introductory tutorials that include videos or animated GIFs showing exactly how to drive the tools, and that use datasets he can relate to.

Toshi Techsupport

Toshi does internal tech support in a company with 500 staff. While others on their team take care of resetting passwords, they debug setup issues and figures out why the dashboard is displaying nonsense. (It’s usually something to do with date formatting.) They often wind up writing bits of code from Stack Overflow to glue things together.
Toshi speaks Perl, Python, and JavaScript, but hardly any R. They switch back and forth between Linux, Windows, and Mac every day. They often finds themself running hour-long internal training seminars, and would now like to learn some data science to support their users and out of personal interest. They wish people would take a few hours and learn more about the software they are using, but in practice, they often only have a 30-minute call in which to diagnose the problem and explain a solution.
A growing number of analysts inside Toshi’s company use R Markdown to prepare parameterized reports. Some are also using flexdashboard and Shiny, so they would like to learn enough about them to be useful.
Toshi lives in Hawaii, so most of their work is done remotely.

Toshi needs examples and reference material for themself that they can paraphrase for the people they are supporting—they know most of what they need, but requires something bite-sized for others to consume. They also need tutorials they can remix for hour-long internal training webinars.

Glosario Sprint

Mon, 05 Oct 2020 00:00:00 +0000

In July we announced Glosario, an open source, multilingual glossary of data science terms that now contains more than 500 terms in multiple languages. We hope it will help lesson developers and maintainers make their materials more findable as well as helping learners directly.

This month, as part of Hacktoberfest, we’re encouraging all members of our community to help expand Glosario. So far, it includes definitions in English, French, Portuguese, and Spanish, but it has been designed to include definitions in any language. We’d love to see our international community come together to provide definitions and translations to increase the value of this resource for everyone.

You don’t need to know any particular programming language to contribute to Glosario: anyone who is familiar with the GitHub web interface can get involved. There is a detailed contributors’ guide in the repo, and contributions are welcome in any language, not only those we already have. To ensure that your contributions are included in Hacktoberfest and count towards you planting a tree or receiving a free t-shirt, remember to register on the Hacktoberfest website.

This article is cross-published on the Carpentries blog.

Writing Data Science in Education Using R in the Open

Mon, 05 Oct 2020 00:00:00 +0000

Introduction

When we wrote Data Science in Education Using R (DSIEUR), we knew it would be easy to assume that new learners would have more prior knowledge about R than they actually did–a phenomenon called “ the curse of knowledge". We knew this intuitively as more experienced R users because we only vaguely associated feelings of triumph and frustration with the memory of running that first chunk of R code. The details of where we got stuck in our learning were harder to remember.

Over time, we traded in fresh memories of these learning pain points for experience and ease of use. That led to a design problem we had to solve while writing DSIEUR: How do we write with empathy for new learners when our own memories of learning R have gotten foggier?

To better identify with the learning experiences of others, we needed to identify where our blind spots were. To identify our blind spots, we needed strategies to empower others to give us feedback by sharing. Bringing our strengths to this collaboration but checking that we understand one another’s work, writing in the open, and using a project workflow to support creativity were our strategies to do just this.

As we neared the end of writing the DSIEUR manuscript, we set out to review each chapter and edit it for readability. To create an opportunity for fresh eyes to read our work, we each reviewed a chapter we hadn’t written. Ryan picked chapter 13, which is on using multilevel models to analyze student survey responses about their online classes. Having a new perspective on experiencing the chapter—particularly when the chapter includes lots of technical explanations—turned out to be a great way to discover blind spots in our work.

Here were Ryan’s thoughts after reviewing chapter 13:

“I don’t use multilevel models regularly in my work, so I could tell right away I was going to learn something new. I read through the sections to make small edits, but also took breaks every so often to check my comprehension of the concepts.”

About halfway through the chapter review, we started a great, back-and-forth conversation and brainstorm about conveying how standardizing coefficients works in multilevel models. Thinking back, we see that our different experiences with multilevel models were critical for accomplishing two things: identifying areas where the writing could be clearer and more accessible and also staying true to the technical parts of the topic.

We read through the chapter and picked out sections that didn’t seem clear. Then, we had conversations to clarify how standardizing coefficients work in multilevel models. We wrote out some initial thoughts to convey where we-together-ended up in our conversation. Then, we read the section again. And round and round we went, until finally we arrived at an execution we were happy with.

In this way, we supercharged the iterative writing process with two elements of collaboration. First, differing backgrounds gave us an opportunity to find blind spots. Josh has used, taught, and written about multilevel models regularly for years. Ryan had a basic understanding of the concepts, but less experience using them. And second, a collective goal—in this case, writing a book together—motivated us to communicate openly and experiment with different ways to create a great experience for our readers.

Write and revise in the open to get feedback from readers

There are all kinds of ways to build empathy for new learners, like “listening” on social media, interviewing members of the R community, and regularly trying to learn new things ourselves. Creating in the open is another approach—one that the R community and others have embraced. Open source educational resources, software, and science make code available to readers to encourage collaboration and accountability. But can open source writing also help us check our biases about what learners need by including the learners themselves in the development of the content?

When data scientists share their writing and code through sites like GitHub and Kaggle, that sharing comes with an unspoken invitation to communicate with the creators. Most of the time, that communication is about improving code. When the open source project is designed to teach something new, the communication can also be about improving the learning experience.

Consider a scenario where a classroom teacher asks their students to complete worksheets—an example of (tacitly) closed source education materials. Not only do worksheets hide the underlying thinking behind their creation: they also invite compliance more than they invite conversation about what the learner needs.

On the other hand, providing the code for our book at every stage of writing empowered us to share how we thought through an analysis. It also set the tone for conversation on social media platforms and GitHub about how we can improve the book. For example, in Chapter 8 we created a visualization to explore scores from student classwork assignments. For this post, we added reorder() to change the order of values in the x-axis:

# Scatterplot of continuous variable
classwork_df %>%
  ggplot(aes(x = reorder(classwork_number, -score, median),
             y = score,
             fill = classwork_number)) +
  geom_boxplot() +
  labs(title = "Distribution of Classwork Scores",
       x = "Classwork",
       y = "Scores") +
  scale_fill_dataedu() +
  theme_dataedu() +
  theme(
    # removes legend
    legend.position = "none",
    # angles the x axis labels
    axis.text.x = element_text(angle = 45, hjust = 1)
    )

By making the code for this plot available, we invited readers (implicitly by being openly available but also explicitly by requesting feedback on Twitter) to tell us where we could do more to scaffold the lesson. For example, a reader might tell us they need more explanation of how reorder() is used to arrange the boxplots by median scores.

In other cases, readers let us know when the writing itself didn’t make sense. For example, one community member read the online version of DSIEUR and emailed to tell us a plot that showed the importance of different variables for predicting a student’s final grade didn’t match the interpretation we wrote. It turns out we made revisions to the analysis that changed the plot, but we hadn’t updated the plot’s interpretation. We tracked this feedback and others in a GitHub issue and corrected it.

Indeed, while writing DSIEUR, sharing the book and its code led to conversations and opportunities for improvement we might not have had if we didn’t write in the open.

When we structure our creative endeavors like a formal project—including setting a deadline and working toward a product—we create many opportunities to encounter our oversights and blind spots.

One way to do this is to write for an audience (of any size). If you’ve written a blog or social media post before, you might recognize the experience of doing so: As soon as you publish the post, you find gaps (or typos!) in your writing you feel motivated to fix. Moreover, if you write a blog post in R Markdown, the process of publishing the post will expose issues, warnings, or messages related to the code—issues you may wish to address before (or after) publishing the post. Knowing someone will read your work gives that extra bit of productive pressure to offer value to your readers. Indeed, the audience has a role to pay in the creative process because they aren’t just reading, they’re participating. Conversations can start in the comment section or on social media. These conversations help you learn how well you’ve connected with the audience and help you uncover what’s important to your readers.

Another part of structuring creative endeavors is creating opportunities to have your work reviewed, either by you or by someone else. In the context of book writing, working through the copy-edits with our publisher helped (or forced!) us to encounter other parts of our writing we hadn’t considered: We realized late in the process that we used both the singular and plural form of ‘data’ throughout the manuscript (without expressed reasons for doing so!). Even an early GitHub issue about this very topic hadn’t prompted the same level of urgency as the copy-edits did. While more particular than the broader blind spots discovered through collaboration and writing in the open, these blind spots are critical for creating a clear, professional, and readable book for the audience. Whether reviewing your own work or having others review for you, an intentional revision process can uncover missed opportunities for improvements.

Finally, deadlines can help. The due date for the manuscript motivated us to improve how we communicated with each other. In Change By Design, Tim Brown writes:

“Curse deadlines all you want, but remember that time can be our most creative constraint.”

Indeed, the frequency of team calls and the commitment to revising and finalizing our manuscript together grew as our deadline approached. Thus, our publisher’s deadline provided a structure that encouraged organization, efficient decision-making, problem-solving, and collaboration. With the deadline looming, we got to the essential question as quickly as possible: Does what we wrote connect meaningfully with the audience and if not, how can we speak to them better?

Conclusion

In the end, the solution for writing the best book we could for new R users in the education field was to empower the community with tools to look at our work and share their reactions with us. Writing Data Science in Education Using R in the open was a way for us to express what we’ve learned, but also a way for us to keep learning.

You can reach us and our co-authors on Twitter: Emily @ebovee09, Jesse @kierisi, Joshua @jrosenberg6432, Isabella @ivelasq3, Ryan @RyanEs.

Sample Shiny exam

Fri, 02 Oct 2020 00:00:00 +0000

To help everyone who is preparing to certify as a Shiny instructor, here are examples of the kinds of questions we have used in the past. Candidates can use any reference material they want (books, online resources, old code, or YouTube videos), but may not ask another person for help, and must complete the exams in 90 minutes each.

Question 1

In this question you will be asked to debug and improve an app that uses a subset of the diamonds dataset from the ggplot2 package. While familiarity with the variables in the dataset is not required for successfully completing this question, the help file for this dataset contains a codebook that might be helpful.

The app code is provided in an RStudio Cloud project.

There is one bug in the app: The summary under the “Overall” heading should be a full sentence that reads There are ___ diamonds that match your selection criteria. Instead it just reads nrow. Debug the app to correct this mistake.
Improve the code in the server function by removing repeated instances of the following lines of code and making use of reactive expressions:
```
diamonds %>%
  filter(
    cut %in% input$selected_cut,
    color %in% input$selected_color
  )
```
Then, describe in 1-2 sentences how the reactive graph with the improvements you implemented will change.
Revamp the app by replacing the standard HTML table under the “Data” heading with shiny::dataTableOutput() which uses the DataTables Javascript library to create an interactive table with more features.
Refactor the app so that the three outputs (Overall, Variable Summary, and Data) are in separate tabs.

Question 2

The ui.R, server.R, and global.R files shown on the next page are used to build an app. Answer the following questions without actually running the app.

What error will running the app using the “Run app” button or with the runApp() function yield? How would you resolve this error?
Suppose you resolve the error in part (a). Now that the app is running successfully, you deploy the app. The four timestamps are printed in order from Time 1 to Time 4, but the times displayed are as followed:
- Time 4 is always the earliest time
- Time 1 is always next
- Time 2 is always next after that
- Time 3 is always the latest time
Explain why these timestamps show up in exactly this order.
You then share the URL of your deployed app with your friend, who immediately visits the app as well on their own computer. The two of you compare what you’re seeing on your screens. Which of the four time stamps will be the same across your screens? Which will be different? Explain why.
You take a screenshot of your app and save it. Then, you reload the deployed app (without redeploying it) by hitting the refresh button on your browser, and compare the app you’re viewing in your browser to the screenshot you took before you reloaded. Which of the four time stamps will be the same between the app in your browser and the screenshot? Which will be different? Explain why.

# ui.R
library(shiny)
library(magrittr)

time_1 <- Sys.time() %>% format_custom()
Sys.sleep(10)

ui <- fluidPage(  
    h4(paste("Time 1:", time_1)), 
    h4(paste("Time 2:", Sys.time() %>% format_custom())),
    h4(textOutput(paste("Time 3:", time_3))),
    h4(paste("Time 4:", time_4))
)

# server.R
server <- function(input, output) {   
    # Time 3 ----
    output$time_3 <- renderText({
        paste("Time 3:", Sys.time() %>% format_custom())
    }) 
}

# global.R
format_custom <- function(x){
  format(x, "%d %b %Y %H:%M:%S")
}

time_4 <- Sys.time() %>% format_custom()
Sys.sleep(10)

Question 3

The following are conceptual questions that come up often when teaching Shiny. Please respond to each in two or three sentences as if you were responding to an email from a student.

The Reactivity overview article on the Shiny Dev Center states “observers […] don’t return a value; they are used for their side effects.” Explain what a side effect means in this context and how this relates to the differences between reactives and observers.
In what context should one use eventReactive() vs. observeEvent()?
Suppose you have written an app that is slow to launch and slow to react to user actions. What are the first three things you would check to find the cause, and how would you do this?
Why does each Shiny module need to start with the statement ns <- NS(id), and what purpose does this statement serve in Shiny modules?

Question 4

In this question you are asked to re-create a Shiny app based on the deployed app as well as a verbal description. The deployed app can be found online, and is described below. You can use the CSV sent to you before this exam file (which contains data from the mtcars data frame) to test the app, and are welcome to view online examples and re-use code from them.

The app is comprised of three columns with the titles “Data upload”, “Data viewer”, and “Data download”. The middle column is twice as wide as the columns in the left and right.
The app’s title is “Upload / Download” however note that the name shown in the browser tab where you view the deployed app is different than the title shown in the app.
On the left hand side the user can upload a CSV file, and has the option to randomly sample observations from the data file you uploaded. If the user checks this option, a new widget where the sample size can be set pops up. The minimum allowed sample size is 1 and the maximum allowed is 32.
Data should be displayed in the middle column with a DataTables style table output immediately after the upload is complete. The displayed data should be updated if the user selects to take a random sample.
On the right hand side the user can download a CSV file. This is either the same file they uploaded, or a random sample from it. The name of the downloaded file should be identical to the name of the uploaded file.

Newly certified instructors in September 2020

Wed, 30 Sep 2020 00:00:00 +0000

We welcomed 12 new instructors to our ranks in September 2020:

This brings the total number of certified Tidyverse instructors to 157, and the number certified for Shiny to 23. If you would like to speak with any of them about your training needs, their contact information is on the trainers’ roster and they would be happy to hear from you.

Our classes are now full for the remainder of 2020, but if you would like to join our waiting list, please fill in this form.

How to deliver learnr tutorials in a package

Mon, 28 Sep 2020 00:00:00 +0000

Packages are not just for functions and data – you can create a package to deliver interactive tutorials to an audience, too.

If you want to share your learnr tutorial with a large group of users (e.g. large courses where many students will likely run the same tutorials simultaneously), putting your tutorial inside of a package may actually be one of the best ways to get your content to your audience. Why? Because after the package has been installed, users can run your tutorial locally– which means that you don’t have to worry about potential bandwidth limits and issues that might otherwise arise when learnr tutorials are hosted on external servers.

Putting your learnr tutorial in a package is also free– and always will be, which means you can also sidestep costs associated with hosting services! Your package doesn’t have to be on CRAN, and it doesn’t have to contain functions or data (but it can if you want).

Never made a package before? No sweat! In this post, we’ll guide you through the process.

tl;dr

Here’s how you put an interactive learnr tutorial in a package:

In a GitHub-connected RStudio project, run usethis::create_package("<path_to_folder/name_of_package>") to make a basic package.
Run usethis::use_tutorial("<name-of-learnr-file>", "<Title You'd Like the User to See>") to create the learnr tutorial. Customize with your content. Repeat for additional tutorials.
Go to Build > Install and Restart.
Optionally, run usethis::use_dev_package("gradethis") to add package dependencies for in-development packages, like gradethis.
Optionally, run usethis::use_package("palmerpenguins") to add package dependencies for packages that are on CRAN, like palmerpenguins.
Optionally, edit the DESCRIPTION file.
Run usethis::use_readme_rmd() to add a README. Knit when you’re done.
Push to GitHub and have folks install with devtools::install_github("<your-repo>/<package-name>")
Go to Tutorial pane of IDE to run the tutorial.
Repeat steps 2, 3, and 7 anytime you update your tutorial package.

Figure 1: Creating a tutorial package in a nutshell

How to make a package for a learnr tutorial

We will walk through the steps for creating the bare-minimum package that you can use to house and deliver your interactive learnr tutorials to your users. This post is not meant to be a comprehensive guide for creating a package nor a guide for creating a tutorial package that is CRAN-ready. However, it is meant to get you up and running with a working tutorial package in a fuss-free way, so that you can share your package now and fine tune later.

Our final goal is to create a package that is “downloadable” by users. The most straightforward way to do this is to host the package in a GitHub repository; however, it is also possible to achieve the same outcome using other hosting services like GitLab or by distributing the package source code via other means. One caveat is that if students wanted to, they’d be able to find the source code and solutions in your repository (or, with some spelunking, in the folder that houses all their R packages locally). But this would take some extra effort on the part of students.

If a solution like this works for your purposes, then read onwards!

Pre-requisites

We assume the following:

You have a GitHub account and are comfortable using GitHub from within RStudio (but you don’t need to be more than a GitHub novice)
You are comfortable with the basics of using R and RStudio
You understand how R projects work
You are already familiar with creating learnr tutorials

Now let’s get set up all to create a learnr tutorial package!

Packages

Make sure you’ve installed and loaded the following packages:

#install.packages(c("devtools", "roxygen2", "learnr"))
library(devtools)
library(usethis)
library(roxygen2)
library(learnr)

Create a GitHub repository

If you’re already familiar with the ins and outs of connecting an R Project to a GitHub repository, you can skip this section.

There are two workflows to choose from for getting started:

Workflow 1

We recommend following the tips on Happy Git with R and starting in GitHub before switching to RStudio.

Create a new repository on GitHub for your work.
- The repository name you choose will also end up being the name of your package, so choose wisely! For the examples in this guide, we’ll go with “tutorialpackage”.
Copy the repository URL to your clipboard.
- Do this by clicking the green Clone or Download button.
- Copy the HTTPS URL (looks like: https://github.com/{yourname}/{yourrepo}.git).
Open RStudio and create a new RStudio Project via git clone.
- Do this by clicking File > New Project > Version Control > Git.
- Paste the copied URL.
- Be intentional about where you tell RStudio to create this new Project.
Click Create Project.
- Your R Project is now connected to GitHub!

Workflow 2

It is possible to first make a package project in RStudio and then connect it to GitHub afterwards. This workflow requires that you have a Git Personal Access Token (PAT) established:

Click File > New Project > New Directory
Scroll down and select R Package
Select a package name and click Create Project

Then run:

usethis::use_git()
usethis::use_github() # you have to have a PAT setup

The files and directories necessary for a package are now in place, and you’ve connected your project with GitHub. You can skip the next section of this post and go directly to “Add files and directories for a tutorial”.

Add files and directories for a package

Now we’ll create the infrastructure to turn this R project into a package. A handful of new files need to be created, but luckily we can outsource this heavy lifting to the create_package() function from the usethis package.

Figure 2: Illustration by Allison Horst

Create the necessary package infrastructure when you run the following code to make a basic package in your current working directory:
```
usethis::create_package("<path_to_folder/name_of_package>")
```
- Not sure what your current working directory is? You can always run getwd() to check.
The console output will ask if you’d like to overwrite the pre-existing R project. Select No.
A second session of RStudio will open – this session has a Build tab in the pane which also has the tabs Environment, History, etc. This tab is specific for building packages, and we will use it later. You can close the first RStudio instance.
- Your project directory should end up looking something like this:

Add files and directories for a tutorial

Now that the package structure is in place, it’s time to add tutorial content. Again, the usethis package will do the dirty work for us to create the folders and files we need for a learnr tutorial within our package.

Create the learnr tutorial and open it for editing when you run usethis::use_tutorial("<tutorial-name>", "<Tutorial Title>"):
```
usethis::use_tutorial("lesson1", "Your First Lesson", open = interactive())
```
- The first argument is the filename for the learnr R Markdown file you are creating without the .Rmd extension.
- The second argument is what you want the user-facing title of the tutorial to be.
- This creates an inst/ directory with some subfolders. If you’re not new to creating learnr tutorials, the folder structure here will look familiar to you – there’s nothing different about learnr tutorial directories inside and outside of packages.
  
  You can open up inst/ and its subsequent subfolders until you reach the .Rmd file you created:
```
/inst/tutorials/<tutorial-name>/<tutorial-name.Rmd>
```
Edit the open .Rmd file and write your tutorial as you normally would.
Repeat for each additional tutorial you want to include in this package.

Build, install, and use your tutorial package

Time to build the package and install it in your R system library.

Navigate to the Build pane of your RStudio IDE. Then click Install and Restart.
- Alternatively, run:
```
devtools::install()
```
- Believe it or not, you’ve now made a package with a learnr tutorial inside of it!
- You should test that your package has been properly created by loading your tutorial from your installed package:
Navigate to the Tutorial pane of your RStudio IDE. All installed learnr tutorials in your R Library will be automatically indexed and displayed here.
Click Start Tutorial to open the tutorial from inside the tutorial pane (which can then be made bigger or popped out to a browser window) – 🎉 woot!
- Alternatively, you can run your tutorial by using learnr::run_tutorial("<tutorial-name>", "<package-name>").
```
learnr::run_tutorial("lesson1", "tutorialpackage")
```
- The tutorial name here refers to the name of the .Rmd file, not the user-facing title.
- The live tutorial will open up in a local browser window.

(Optionally) Add dependencies

If your tutorial uses external packages (for example, packages for exercise-checking like gradethis), or external packages that need to be made available to learners as they complete exercises (for example, data packages like palmerpenguins), you’ll need to make sure this package gets installed along with your custom package.

External packages in development

If the package you want to use is not on CRAN (as gradethis currently is not), the development version of the package will need to be included as a Remotes dependency in the DESCRIPTION file. (Note: Including external packages that are still in development does complicate matters if you plan on submitting your tutorial package to CRAN.)

Once again, the usethis package will make this easier for us to do:

Run usethis::use_dev_package("<external-package>")
```
usethis::use_dev_package("gradethis")
```
This function is even smart enough to figure out the OWNER/REPO of the GitHub remote that the external package comes from if you have it install locally. See the usethis pkgdown site for optional arguments.
You can confirm the package has been added under Remotes when you open the DESCRIPTION file in your project root.

External packages on CRAN

If you’re using other packages in your tutorial that are on CRAN (e.g. tidyverse or palmerpenguins), these must also added to the DESCRIPTION file, but they need only be listed under Imports:

Run usethis::use_package("<external-package>")
```
usethis::use_dev_package("palmerpenguins")
```
You can confirm the package has been added under Imports when you open the DESCRIPTION file in your project root.

(Optionally) Edit your package metadata

This step is not necessary to have a working, usable package, but it creates a nicer experience for users interested in learning more about the contents of your package and how to use them.

Open the DESCRIPTION file in your project root.
Edit the file with your own information. Not sure what to write for each field? See this resource for suggestions.
Finally, make sure to Build > Install and Restart your package again to include these changes.

Getting your tutorial to your audience

Your tutorial package has (finally!) been built, now it’s time to get it out there!

Commit and push to GitHub to share your tutorial package with the world.
Have users install your package from GitHub with: devtools::install_github(“<your-repo>/<package-name>"). (They will also need to install the learnr package.)
```
devtools::install_github("dcossyleon/tutorialpackage")
```
Have users run your tutorial by navigating to the Tutorial pane of their RStudio IDE and clicking Start Tutorial.
- Alternatively, users could also run the following code to open the tutorial: learnr::run_tutorial("<tutorial-name>", "<package-name>")
```
learnr::run_tutorial("lesson1", "tutorialpackage")
```

We recommend including these latter two instructions in a README file, which we introduce below.

Create a README file

You can include additional information in a README.Rmd file for your package. At a minimum, we recommend you include a line about how users can install and load the tutorials.

Run use_readme_rmd() to create and open a README file.
```
use_readme_rmd()
```
Edit the README to meet your needs. Need ideas of what to include? Check out this resource.
Click Knit so that it creates a corresponding README.md file.
- Or, alternatively, run:
```
usethis::build_readme()
```
Commit and push your changes to GitHub.

Updating your package

After your package has been installed by your users, you can continue to update or add tutorials. Each time you make changes to the contents of your package, you must Build then Install and Restart the package locally before pushing your changes to GitHub.

Users can then access the updated content by simply re-installing your package.

That’s a wrap!

Congratulations, you’ve created a tutorial package!

From here, there are many ways to extend what you’ve done. For example, you could decide to bundle up custom data sets in your package, as explained in the R Packages book. And you might consider adding package documentation. It’s also worth mentioning that if you are teaching using RStudio Cloud or RStudio Server, you can install the tutorial package in your workspace or project as the instructor, and make the student experience even simpler – all students would need to do is go to the website, push a button, and start the tutorial.

If you’d like to see an example of a tutorial package “in the wild”, check out the GitHub repository for the learntidymodels package or the companion R package for the Data Science Course in a Box.

Finally, you may also be interested in exploring mybinder.org as a platform for delivering interactive learnr tutorials to users, which you can learn more about with this helpful post by Ted Laderas, PhD.

Happy tutorial-ing!

Data Latam: A community of data practitioners

Mon, 21 Sep 2020 00:00:00 +0000

When we started with the first Data Latam Podcast in May 2016 we thought that it would be a great idea to have a source of information about data science in Spanish. Our goal was to make available not only a source of information, but also of inspiration. We believe that having role models is important in a field where so many of us are self-taught, and all of us need to learn continuously to stay abreast of advances in each of our fields.

This is why we always ask our interviewees: “How did you get where you are?", and the diversity of stories has been enormous. The podcast has documented role models for those members of the audience who want to start or continue their own career in data science. We have been amazed and happy with the reach that the podcasts have had: to date we have published 53 podcasts with more than 3000 people listening in each month in different countries in Latin America.

Data Latam Events

Soon after the podcasts we started organizing in-person training events, always followed by a lunch. In this way we highlighted the importance of creating an opportunity for networking in a group that shares an interest in data science with R. We have also organized the following courses:

Automated tests in R (2018)
Data pipelines in R with dplyr (2018)
Deploy data products with Docker (2018)
Interactive Dashboards in R with Shiny (2019)
Visualizing data in R (2019)

One of the nice things that happened with the in-person events is that more people got involved in the execution of the training sessions and came up with their own ideas. This month we will do the first remote training about migrating to R from Excel.

Data Latam Webinars

Around the same time as the training events we started the Data Latam online webinars on the last Thursday of every month. In fact, we inherited these events from the San Carlos R User Group, who were being threatened by Meetup.com with deletion from their platform if they continued posting online events. This brought a new group of people into the Data Latam community and for the first year we always began with a round of introductions: where are you, how do you use R?

Starting the webinars with a full round of introductions has become more difficult with the numbers of people currently assisting. We regularly get 200-300 inscriptions for each webinar, and have started to max out our Zoom capacity of 100 (so get there early!). We publish a recording of each monthly webinar on YouTube where we have more than 26,000 views of the content.

Data Latam Future

Thanks to the participation and effort of many people, Data Latam is a Latin American community of professionals and academics who apply data science in their day to day work. In our events, training sessions, and extension programs we will continue to explore technologies, learn about data science, talk about trends and relevant events in industry and share new developments in the field. We are thrilled that the community is still growing and that more people using it as a platform to organize community activities they have thought of. So if you speak Spanish and you have an interest in R and data science please know that you are welcome to participate! We look forward to meeting you in one of the next events.

Concept Maps

Fri, 11 Sep 2020 00:00:00 +0000

We introduce concept maps as a tool to help people figure out what they’re trying to teach early in the instructor training course. Over the past few months, a group of certified instructors have been creating concept maps for re-use and to serve as examples for people who are trying to draw their own. We have collected some of these in https://github.com/rstudio/concept-maps/ under a Creative Commons license; we hope you’ll find them useful, and we welcome comments, improvements, and additions.

Shiny Solutions

Thu, 10 Sep 2020 00:00:00 +0000

We are collaborating on creating a solutions manual to accompany Hadley Wickham’s new book Mastering Shiny. It’s still in development and we welcome contributions to the repo—check it out at http://mastering-shiny-solutions.org.

Newly certified instructors in August 2020

Mon, 31 Aug 2020 00:00:00 +0000

We welcomed ten new instructors to our ranks in August 2020, including our first in Oman and South Africa:

This brings the total number of certified Tidyverse instructors to 147, and the number certified for Shiny to 21. If you would like to speak with any of them about your training needs, their contact information is on the trainers’ roster and they would be happy to hear from you.

Our classes in September and October are now full, but if you would like to join our waiting list, please fill in this form.

More sample exams

Tue, 18 Aug 2020 00:00:00 +0000

To help everyone who is preparing to certify as an RStudio instructor, here are examples of the kinds of questions we have been using recently. Candidates can use any reference material they want (books, online resources, old code, or YouTube videos), but may not ask another person for help, and must complete the exams in 90 minutes each. (Most people schedule them at least a couple of weeks apart rather than back to back.)

Tidyverse Exam

Brendan Cullen has posted a solution guide with source available on GitHub.

Basic Operations

Read the file person.csv and store the result in a tibble called person.
Create a tibble containing only family and personal names, in that order. You do not need to assign this tibble or any others to variables unless explicitly asked to do so. However, as noted in the introduction, you must use the pipe operator %>% and code that follows the tidyverse style guide.
Create a new tibble containing only the rows in which family names come before the letter M. Your solution should work for tables with more rows than the example, i.e., you cannot rely on row numbers or select specific names.
Display all the rows in person sorted by family name length with the longest name first.

Cleaning and Counting

Read the file measurements.csv to create a tibble called measurements. (The strings "rad", "sal", and "temp" in the quantity column stand for “radiation”, “salinity”, and “temperature” respectively.)
Create a tibble containing only rows where none of the values are NA and save in a tibble called cleaned.
Count the number of measurements of each type of quantity in cleaned. Your result should have one row for each quantity "rad", "sal", and "temp".
Display the minimum and maximum value of reading separately for each quantity in cleaned. Your result should have one row for each quantity "rad", "sal", and "temp".
Create a tibble in which all salinity ("sal") readings greater than 1 are divided by 100. (This is needed because some people wrote percentages as numbers from 0.0 to 1.0, but others wrote them as 0.0 to 100.0.)

Combining Data

Read visited.csv and drop rows containing any NAs, assigning the result to a new tibble called visited.
Use an inner join to combine visited with cleaned using the visit_id column for matches.
Find the highest radiation ("rad") reading at each site. (Sites are identified by values in the site_id column.)
Find the date of the highest radiation reading at each site.

Plotting

The code below is supposed to read the file home-range-database.csv to create a tibble called hra_raw, but contains a bug. Describe and fix the problem. (There are several ways to fix it: please use whichever you prefer.)
```
hra_raw <- read_csv(here::here("data", "home-range-database.csv"))
```
Convert the class column (which is text) to create a factor column class_fct and assign the result to a tibble hra. Use forcats to order the factor levels as:
1. mammalia
2. reptilia
3. aves
4. actinopterygii
Create a scatterplot showing the relationship between log10.mass and log10.hra in hra.
Colorize the points in the scatterplot by class_fct.
Display a scatterplot showing only data for birds (class aves) and fit a linear regression to that data using the lm function.

Functional Programming

Write a function called summarize_table that takes a title string and a tibble as input and returns a string that says something like, “title has # rows and # columns”. For example, summarize_table('our table', person) should return the string "our table has 5 rows and 3 columns".
Write another function called show_columns that takes a string and a tibble as input and returns a string that says something like, “table has columns name, name, name". For example, show_columns('person', person) should return the string "person has columns person_id, personal_name, family_name".
The function rows_from_file returns the first N rows from a table in a CSV file given the file’s name and the number of rows desired. Modify it so that if no value is specified for the number of rows, a default of 3 is used.
```
rows_from_file <- function(filename, num_rows) {
  readr::read_csv(filename) %>% head(n = num_rows)
}

rows_from_file("measurements.csv") # should show 3 rows
```
The function long_name checks whether a string is longer than 4 characters. Use this function and a function from purrr to create a logical vector that contains the value TRUE where family names in the tibble person are longer than 4 characters, and FALSE where they are 4 characters or less.
```
long_name <- function(name) {
  stringr::str_length(name) > 4
}
```

Wrapping Up

Modify the YAML header of this file so that a table of contents is automatically created each time this document is knit, and fix any errors that are preventing the document from knitting cleanly.
```
---
title: "Tidyverse Exam Version 2.0"
output:
html_document:
    theme: flatly
---
```

Teaching Exam

Demonstration Lesson

Present the demonstration lesson you have developed for this examination.

Formative Assessment

You are teaching a one-day introductory workshop on the tidyverse to learners with little or no previous programming experience. You have shown them how to create a dplyr pipeline and how to use the basic verbs select, filter, and mutate, as well as how to create simple plots using ggplot. The next step in your lesson shows them group_by and summarize.

Create a multiple choice question to test their understanding of these two functions. Include one right answer and at least two wrong answers, and explain clearly what misconceptions the wrong answers are intended to diagnose.
Create a short fill-in-the-blanks coding exercise to test their ability to use these two functions in a dplyr pipeline. Provide the explanatory text you would give the learners and the template code they would fill in, and explain what answers you expect and what errors you expect learners to make.

Teaching Methods

To support a popular online class for people who are learning how to use regular expressions in R, your colleague has suggested having the learners grade each other’s exercises.

Each learner submits their code by pasting it into an online system.
They are then shown the submissions of 3 other learners, one at a time.
For each submission, they are able to put a + or - beside each line of code to indicate whether they like it or don’t like it. (They don’t have to mark or comment on lines, but are not able to submit their review unless they have marked at least 5 lines.)
They are also able to add an overall paragraph-length comment on each submission.

Please describe two strengths and two weaknesses of this tool from the point of view of the learner and from the point of view of the teacher. Please connect your points to specific aspects of educational theory where you can.

Mental Models

You are preparing a lesson on handling missing values in data science. Draw a concept map with 4-5 concepts and 6-8 links.

Being an Ally

For each of the scenarios below, describe three things you would do in escalation order (i.e., the first thing you would try, then what you would do if that didn’t work, and then your final option).

Scenario 1

You have been sent to a company to deliver a week-long introduction to R and the tidyverse to a team of 8 statisticians who have been using SAS for many years. Most of them seem interested, but one is obviously not: they are answering email during lessons, not bothering to do exercises, shrugging off questions, etc.

You spoke with them at the end of the first day to say that their behavior is demotivating other learners. After telling you that they don’t think the class is worthwhile—they can do everything they need to in SAS and they don’t see why the company is forcing them to switch—they promised to do better. However, it is now mid-morning on day 2 and if anything their behavior is worse. What are the next three steps you would take, assuming that they continue to promise to make changes but actually don’t?

Scenario 2

You are co-teaching a workshop at a conference with a senior (relatively famous) data scientist you have never met in person before. After an hour, you notice that they only ever ask male students to share their work with the class. You have pointed this out as gently as you can and they have become very defensive. What are the next steps you would take, assuming that each step makes them even more defensive or argumentative?

Feedback

Watch 4 minutes of the video embedded below and list feedback you would give the presenter about what they’re doing well and what they could improve.

https://youtu.be/whmLRd5nibc?t=1265

	Content	Presentation
Positive
Negative

Spreadsheet workflows in R

Mon, 17 Aug 2020 00:00:00 +0000

There’s so much to discover and learn when working with spreadsheets. As a summer intern at RStudio my project has focused on creating a resource that lies at the intersection between spreadsheets and R, aimed at users who either exclusively use one or the other or whose work lives in the intersection of the two. This project has focused on a plethora of topics from comparing numerous R package functionalities that work with spreadsheets, to writing about tips and tricks on best practices for working in both a spreadsheet software and in R.

In this post I’d like to share a part of this work, specifically focused on the R versions of common spreadsheet workflows. To do that we’ll assume the role of a data analyst in two hypothetical scenarios and walk through the tidyverse equivalent of common analyses and tasks one is likely to come across when working with data stored in spreadsheets.

For our first story, it’s day one as a new data analyst and our boss has asked us to take a look at the company’s finances. They send you a spreadsheet, available in an Excel workbook, and ask you to analyze spending patterns over the current year and give your assessment into where spending is going overboard.

We’ve decided to run our analysis in R to take advantage of data wrangling and visualization functions from the tidyverse as well as to create a reproducible workflow in case we want to revisit this analysis later. First, let’s load in our data and take a look at it in R

If you would like to follow along, you can download the Excel file called spending.xlsx here by clicking on the Download icon (arrow pointing down) on the top right corner. Note that in the code chunk below we are reading this file from a folder called data so we recommend you create such a folder in your working directory and place the file you downloaded there. You can also follow along with the analysis on RStudio Cloud here.

library(tidyverse)
library(readxl)

spending <- read_excel("data/spending.xlsx")
spending

## # A tibble: 48 x 5
##    month expense  amount num_of_expenses budget
##    <chr> <chr>     <dbl>           <dbl>  <dbl>
##  1 Jan   lawsuits   9916              17   6422
##  2 Feb   lawsuits   9575              16   3125
##  3 Mar   lawsuits   5760              33   3913
##  4 Apr   lawsuits   3828              36   4062
##  5 May   lawsuits   5322              25   6347
##  6 Jun   lawsuits   6809              32    643
##  7 Jul   lawsuits   8568              37   5985
##  8 Aug   lawsuits   7562              34  10709
##  9 Sep   lawsuits   5682              26   9719
## 10 Oct   lawsuits   3689              16   7887
## # … with 38 more rows

We take note of the month column as well as amount spent, budget, and, expense type. We’ll hold off on looking at the column num_of_expenses, it may prove useful down the line but not pressing for a quick look into the data.

IF statements with nested logic

One advantage of spreadsheets is that we can use formulas to dictate what should happen in a specific cell and, in a broader application of this, apply them to an entire column. Back to our spending sheet, while data for all 12 months is useful for our summary we want to take a look at spending by quarter, something not provided in the initial data set, so we’ll need to make our own quarter variable. We can see how this process works in spreadsheets, manipulating our data in an Excel workbook.

It’s a bit difficult to see the formula bar in the image above, so the formula to create used for creating the quarter column is provided below.

=IF(OR(A2="Jan",A2="Feb",A2="Mar"),"Q1",IF(OR(A2="Apr",A2="May",A2="Jun"),"Q2",IF(OR(A2="Jul",A2="Aug",A2="Sep"),"Q3",IF(OR(A2="Oct",A2="Nov",A2="Dec"),"Q4","NA"))))

For our tidyverse comparison, When creating a column that requires multiple or nested logical conditions, we can take advantage of the case_when() function from dplyr. Similar to a CASE statement in SQL, we can set parameters for what a given value should be based on conditions from other rows or columns in our data. To do this we can create a new column using the mutate() function and apply case_when() within that call.

spending_quarter <- spending %>%
  mutate(quarter = case_when(
    month %in% c("Jan", "Feb", "Mar") ~ "Q1",
    month %in% c("Apr", "May", "Jun") ~ "Q2",
    month %in% c("Jul", "Aug", "Sep") ~ "Q3",
    month %in% c("Oct", "Nov", "Dec") ~ "Q4",
    TRUE ~ "NA"
  ))

spending_quarter

## # A tibble: 48 x 6
##    month expense  amount num_of_expenses budget quarter
##    <chr> <chr>     <dbl>           <dbl>  <dbl> <chr>  
##  1 Jan   lawsuits   9916              17   6422 Q1     
##  2 Feb   lawsuits   9575              16   3125 Q1     
##  3 Mar   lawsuits   5760              33   3913 Q1     
##  4 Apr   lawsuits   3828              36   4062 Q2     
##  5 May   lawsuits   5322              25   6347 Q2     
##  6 Jun   lawsuits   6809              32    643 Q2     
##  7 Jul   lawsuits   8568              37   5985 Q3     
##  8 Aug   lawsuits   7562              34  10709 Q3     
##  9 Sep   lawsuits   5682              26   9719 Q3     
## 10 Oct   lawsuits   3689              16   7887 Q4     
## # … with 38 more rows

Excellent! We’ve got our new quarter column set up. Here we specified which months make up each quarter and as in our spreadsheet formula for good measure added an NA condition in the event we’ve missed something. We can do a quick sanity check for our case_when() statement by examining our data and seeing if any NA values show up in the new column we generated, which would indicate if a month is spelled differently than what’s listed in our conditions or if there’s an error in our code.

Pivot tables

Pivot tables are a powerful tool spreadsheets offer, allowing us to generate summaries of large quantities of data. Let’s take a look at how we create our basic Pivot table in spreadsheets and then see how we can create summary tables using functions from the tidyverse

First we’ll create a separate sheet for our pivot table, specifying the range of the data we want it to be based on.

And then, it’s as simple as dragging and dropping our variables of interest into specific order with expense and quarter in rows and budget and amount in values, specifying a sum calculation.

For our tidyverse comparison, we can create summary tables as well. Let’s take a look total expenses and budget by expense type and quarter.

spending_table <- spending_quarter %>%
  group_by(expense, quarter) %>%
  summarise(
    total_expenses = sum(num_of_expenses),
    total_expense_amt = sum(amount),
    total_budget_amt = sum(budget),
    .groups = "drop"
    )

spending_table

## # A tibble: 16 x 5
##    expense           quarter total_expenses total_expense_amt total_budget_amt
##    <chr>             <chr>            <dbl>             <dbl>            <dbl>
##  1 consulting        Q1                  70             16266            17949
##  2 consulting        Q2                  33             11329            22345
##  3 consulting        Q3                  93             17997            17460
##  4 consulting        Q4                  82             16622            17358
##  5 lawsuits          Q1                  66             25251            13460
##  6 lawsuits          Q2                  93             15959            11052
##  7 lawsuits          Q3                  97             21812            26413
##  8 lawsuits          Q4                  56             14829            17939
##  9 office happy hour Q1                  32             17749            18688
## 10 office happy hour Q2                  56              7879            17658
## 11 office happy hour Q3                  39             16876            12384
## 12 office happy hour Q4                  38             14752            18058
## 13 office supplies   Q1                  83             13460            25251
## 14 office supplies   Q2                  45             12517            19140
## 15 office supplies   Q3                  67              7527            21819
## 16 office supplies   Q4                  91              9401            14342

New variables

Sometimes we make a table and realize we can use the summary data to create new variables that can better answer our question. Coming back to our finance example, let’s say we want to examine how much money is left over from each quarter based off of budget and amount spent. A quick work around could be to manually add in a formula in a cell adjacent to our table and drag it down to each respective row, a process depicted below.

Alternatively, using the mutate() function from dplyr, we can create a new column in our summary table and save that as a new data frame.

left_over <- spending_table %>%
  mutate(left_over = total_budget_amt - total_expense_amt) %>%
  arrange(left_over)

left_over

## # A tibble: 16 x 6
##    expense    quarter total_expenses total_expense_a… total_budget_amt left_over
##    <chr>      <chr>            <dbl>            <dbl>            <dbl>     <dbl>
##  1 lawsuits   Q1                  66            25251            13460    -11791
##  2 lawsuits   Q2                  93            15959            11052     -4907
##  3 office ha… Q3                  39            16876            12384     -4492
##  4 consulting Q3                  93            17997            17460      -537
##  5 consulting Q4                  82            16622            17358       736
##  6 office ha… Q1                  32            17749            18688       939
##  7 consulting Q1                  70            16266            17949      1683
##  8 lawsuits   Q4                  56            14829            17939      3110
##  9 office ha… Q4                  38            14752            18058      3306
## 10 lawsuits   Q3                  97            21812            26413      4601
## 11 office su… Q4                  91             9401            14342      4941
## 12 office su… Q2                  45            12517            19140      6623
## 13 office ha… Q2                  56             7879            17658      9779
## 14 consulting Q2                  33            11329            22345     11016
## 15 office su… Q1                  83            13460            25251     11791
## 16 office su… Q3                  67             7527            21819     14292

Great! Using the arrange() function we can also bring the largest instances of overspending to the top of our table to focus our attention. In Excel, this is something you’d normally do via Data > Sort.

We can also filter our table if we’re interested in a specific expense type. In Excel, you could to this via Data > Filter. Let’s hone in on spending for office happy hours.

left_over %>%
  filter(expense == "office happy hour")

## # A tibble: 4 x 6
##   expense     quarter total_expenses total_expense_a… total_budget_amt left_over
##   <chr>       <chr>            <dbl>            <dbl>            <dbl>     <dbl>
## 1 office hap… Q3                  39            16876            12384     -4492
## 2 office hap… Q1                  32            17749            18688       939
## 3 office hap… Q4                  38            14752            18058      3306
## 4 office hap… Q2                  56             7879            17658      9779

Hmm, a lot of overspending in Quarter 3, which might make sense as these are the summer months. Alternatively, we can take advantage of Sort and Filter in spreadsheets to accomplish the same thing.

VLOOKUPs and joins

We don’t always have all of the information we need in a single data file and many times we need to bring in data from other sources to supplement and augment our existing data in the course of an analysis.

For our second scenario, we’ll leave the finance world and move on to something that is perhaps a little more exciting: superheroes!

Below is a data set containing information on various comic book characters with our first sheet providing some basic information on each character.

And a second sheet containing information on each character’s alter ego.

Over time this data set has been expanded on with multiple sheets including new information. Before we start exploring, we’ll need to join the relevant data from the two sheets so we can conduct some fun analyses.

Let’s first walk through the spreadsheet approach and utilize a VLOOKUP to bring together these data. In each sheet, we notice there is a hero column that allows us to match data from one sheet to the other. The example below shows the process of pulling the alter_ego column from our alter egos sheet into our initial heroes data set.

Starting our tidyverse comparison, we’ll first load our data. Our data set contains two sheets so we’ll load them in separately as two distinct data frames.

If you would like to follow along, you can download the Excel file called superheroes.xlsx here and remember that you can also follow along with the analysis on RStudio Cloud here.

superheroes <- read_excel("data/superheroes.xlsx", sheet = "heroes")
identities <- read_excel("data/superheroes.xlsx", sheet = "alter_egos")

Let’s take a look at the sheet with data on superheroes.

superheroes

## # A tibble: 26 x 4
##    hero            universe has_powers first_appearance   
##    <chr>           <chr>    <chr>      <dttm>             
##  1 Superman        DC       yes        1938-04-18 00:00:00
##  2 Batman          DC       no         1939-03-30 00:00:00
##  3 Spider-Man      Marvel   yes        1962-08-01 00:00:00
##  4 Green Lantern   DC       yes        1971-12-01 00:00:00
##  5 Daredevil       Marvel   no         1964-04-01 00:00:00
##  6 Wonder Woman    DC       yes        1941-10-01 00:00:00
##  7 Black Widow     Marvel   no         1964-04-01 00:00:00
##  8 Captain America Marvel   yes        1941-03-01 00:00:00
##  9 Hulk            Marvel   yes        1962-05-01 00:00:00
## 10 Thor            Marvel   yes        1962-08-01 00:00:00
## # … with 16 more rows

And now let’s take a look at the sheet listing the alter ego of each character.

identities

## # A tibble: 26 x 3
##    hero            alter_ego        is_secret
##    <chr>           <chr>            <chr>    
##  1 Superman        Clark Kent       yes      
##  2 Batman          Bruce Wayne      yes      
##  3 Spider-Man      Peter Parker     yes      
##  4 Green Lantern   John Stewart     yes      
##  5 Daredevil       Matt Murdock     yes      
##  6 Wonder Woman    Diana Prince     yes      
##  7 Black Widow     Natasha Romanova no       
##  8 Captain America Steve Rogers     no       
##  9 Hulk            Bruce Banner     no       
## 10 Thor            Donald Blake     yes      
## # … with 16 more rows

Using left_join() from the dplyr package, we can bring in the data from the identities data frame into our superheroes data frame.

To do this we’ll call left_join() on superheroes, putting the identities data set as our first argument and specify our common variable with the by argument.

superhero_identities <- superheroes %>%
  left_join(identities, by = "hero")

superhero_identities

## # A tibble: 26 x 6
##    hero          universe has_powers first_appearance    alter_ego     is_secret
##    <chr>         <chr>    <chr>      <dttm>              <chr>         <chr>    
##  1 Superman      DC       yes        1938-04-18 00:00:00 Clark Kent    yes      
##  2 Batman        DC       no         1939-03-30 00:00:00 Bruce Wayne   yes      
##  3 Spider-Man    Marvel   yes        1962-08-01 00:00:00 Peter Parker  yes      
##  4 Green Lantern DC       yes        1971-12-01 00:00:00 John Stewart  yes      
##  5 Daredevil     Marvel   no         1964-04-01 00:00:00 Matt Murdock  yes      
##  6 Wonder Woman  DC       yes        1941-10-01 00:00:00 Diana Prince  yes      
##  7 Black Widow   Marvel   no         1964-04-01 00:00:00 Natasha Roma… no       
##  8 Captain Amer… Marvel   yes        1941-03-01 00:00:00 Steve Rogers  no       
##  9 Hulk          Marvel   yes        1962-05-01 00:00:00 Bruce Banner  no       
## 10 Thor          Marvel   yes        1962-08-01 00:00:00 Donald Blake  yes      
## # … with 16 more rows

Great, we’ve joined the data frames with no problem!

There are, of course, instances in which we’ll need to pull in data from multiple sheets, and the superheroes data set is no exception. We’ve been informed there are an additional two sheets that have recently been added. One containing information on the main power or skill of each character,

powers <- read_excel("data/superheroes.xlsx", sheet = "powers")
powers

## # A tibble: 26 x 2
##    hero            main_power           
##    <chr>           <chr>                
##  1 Superman        flight               
##  2 Batman          inexhaustable wealth 
##  3 Spider-Man      wall-crawling        
##  4 Green Lantern   power ring           
##  5 Daredevil       echo-location        
##  6 Wonder Woman    super strength       
##  7 Black Widow     training             
##  8 Captain America peak physical fitness
##  9 Hulk            super strength       
## 10 Thor            magic hammer         
## # … with 16 more rows

and the other containing the occupation of the alter ego of each superhero.

occupation <- read_excel("data/superheroes.xlsx", sheet = "occupation")
occupation

## # A tibble: 26 x 2
##    name             occupation          
##    <chr>            <chr>               
##  1 Clark Kent       Reporter            
##  2 Bruce Wayne      CEO                 
##  3 Peter Parker     Photogragpher       
##  4 John Stewart     U.S. Marine         
##  5 Matt Murdock     Lawyer              
##  6 Diana Prince     Intelligence Officer
##  7 Natasha Romanova Spy/Assassin        
##  8 Steve Rogers     Solider             
##  9 Bruce Banner     Scientist           
## 10 Donald Blake     Doctor              
## # … with 16 more rows

We see that the powers sheet has a hero column allowing for another simple left join. However, the occupation sheet doesn’t have a common column by that specific name, but we do recognize that the information in the name column is the same for the alter_ego column from our identities spreadsheet. We can take advantage of this relationship to bring these data frames together as shown in the code below.

heroes_full <- superhero_identities %>%
  left_join(powers, by = "hero") %>%
  left_join(occupation, by = c("alter_ego" = "name"))

Here we conduct a simple left join bringing in the data from the powers data set, and then another left join to bring in the data from the occupation spreadsheet. In the by argument we specify that the column alter_ego should be matched to the name column from the occupation data frame.

We’ve expanded our dataset quite a bit. Let’s take an alternative approach to view it using the glimpse() function from dplyr.

glimpse(heroes_full)

## Rows: 26
## Columns: 8
## $ hero             <chr> "Superman", "Batman", "Spider-Man", "Green Lantern",…
## $ universe         <chr> "DC", "DC", "Marvel", "DC", "Marvel", "DC", "Marvel"…
## $ has_powers       <chr> "yes", "no", "yes", "yes", "no", "yes", "no", "yes",…
## $ first_appearance <dttm> 1938-04-18, 1939-03-30, 1962-08-01, 1971-12-01, 196…
## $ alter_ego        <chr> "Clark Kent", "Bruce Wayne", "Peter Parker", "John S…
## $ is_secret        <chr> "yes", "yes", "yes", "yes", "yes", "yes", "no", "no"…
## $ main_power       <chr> "flight", "inexhaustable wealth", "wall-crawling", "…
## $ occupation       <chr> "Reporter", "CEO", "Photogragpher", "U.S. Marine", "…

For doing this same task in Excel, we can continue to utilize VLOOKUPS for each additional column of data we want to pull into our main sheet. To bring in our occupation data we simply adjust the initial reference point in our formula from column A2 which houses hero name to E2 which houses alter egos which was also added via a VLOOKUP.

There we have it, a fully combined data set ready for analysis! Hmmm, now that we think about it, let’s hope we aren’t sharing this data with any super villains. We may be an ace at working with spreadsheet data but we’re also an ethical data analyst!

I hope you’ve found this blog post useful and enjoyed reading through each example. It’s been such a pleasure working with Jenny Bryan and Mine Çetinkaya-Rundel on this project and we’re excited to share more of the Spreadsheets Using R resource with readers in the future. Until then, no matter what tools you’re using to work with your data, happy analyzing!

Newly certified instructors in July 2020

Wed, 05 Aug 2020 00:00:00 +0000

July was a slow month for instructor certification thanks to some much-needed holiday time, but we still managed to add six new names to our roster, including our first instructor in Finland and our first Telugu speaker:

This brings the total number of certified Tidyverse instructors to 136. If you would like to speak with any of them about your training needs, their contact information is on the trainers’ roster and they would be happy to hear from you.

Our classes in August and September are now full, but if you would like to join our waiting list, please fill in this form.

The Hippocratic License

Mon, 03 Aug 2020 00:00:00 +0000

Over the past few years, more and more people have become concerned with the ethical implications of work in data science and machine learning. From algorithmic bias to facial recognition, the tools we teach people to build and use have the potential to do great harm; as teachers, we have a responsibility to make our students aware of the issues in the same way that the medical profession teaches nurses and doctors to think about the human implications of what they do.

One example of how we can do this comes up when we discuss software licensing and intellectual property. Until recently, researchers had three principal options:

Make their work closed source, so that others could not use it without permission.
Use the MIT License or something equivalent, which allows users to do whatever they want.
Use the GNU Public License (GPL), which allows users to do what they want but also requires them to share the source of any project that modifies or incorporates GPL’d software.

A fourth option has recently been developed by Coraline Ada Ehmke (best known until now for creating the Contributor Covenant used by many open source projects). Like other open licenses, the Hippocratic License allows people to use and share the software, but where the GPL requires them to share their own work, the Hippocratic License prevents anyone from using the software to do harm. To avoid wrangling over what exactly that means, the license specifically forbids anyone from using software in ways that violate the United Nations Universal Declaration of Human Rights and the United Nations Global Compact. These are regarded as landmarks in the history of human rights, and more practically, have been ratified by many countries and argued over by lawyers and scholars so that their scope and meaning is clear.

Making students aware of the Hippocratic License and adopting it for our own projects is a small step toward a better world, but it is a step. From a teaching point of view, discussing it and its implications can turn an otherwise abstract lecture on ethics into a lively debate, and can give students practice discussing what they should do rather than what they could do.

If you’d like to read more, Dr. Nick Horton wrote a post about this license on the “Teach Data Science” blog. And here is a list of adopters as of the time of this post, with links to their projects:

Project	URL
Animus	https://github.com/SplittyDev/Animus
cachish	https://github.com/thusoy/cachish
DCAN	https://github.com/DecentralizedCAN/CAN
DimeNet	https://github.com/klicperajo/dimenet
FODA Card Game	https://github.com/rafaelcastrocouto/foda
format_parser	https://rubygems.org/gems/format_parser
Functional Programming for Mortals with Cats in Scala (book)	https://leanpub.com/fpmortals-cats
Gryphon	https://github.com/vinivendra/Gryphon
Honeycomb Serilog Sink	https://github.com/evilpilaf/HoneycombSerilogSink
Kommit	https://github.com/kommitapp/kom-web
Launchlet	https://github.com/launchlet/launchlet
leisure	https://leisure.tdreyno.com
libhoney-kotlin	https://github.com/imavroukakis/libhoney-kotlin
NLPIA-bot Chatbot	https://github.com/nlpia/nlpia-bot
postgres-mitm	https://github.com/thusoy/postgres-mitm
rack-read_only	https://rubygems.org/gems/rack-read_only
suo	https://github.com/dieseltravis/suo
TidyBlocks	http://tidyblocks.tech
VCR	https://github.com/vcr/vcr
zip_tricks	https://github.com/wetransfer/zip_tricks
logitechd	https://github.com/FFY00/logitechd
dbus-objects	https://github.com/FFY00/dbus-objects
python-install	https://github.com/FFY00/python-install

Announcing Glosario

Tue, 28 Jul 2020 00:00:00 +0000

glosario is an open source glossary of terms used in data science that is available online and also as a library in both R and Python. Authors can add glossary keys to a lesson’s metadata to indicate what the lesson teaches, what learners ought to know before they start, and where they can go to find that knowledge. Authors can also use the library’s functions to insert consistent hyperlinks for terms in their lessons in any of several (human) languages, and anyone who has installed the library can use it interactively to look things up while they’re programming.

Defining Terms

The main glosario repository has a file called glossary.yml that contains entries like this:

- slug: plus_one
  ref:
    - upvote
  en:
    term: "+1"
    def: >
      A vote in favor of something.
  fr:
    term: "+1"
    def: >
      Un vote en faveur de quelque chose.
  es:
    term: "+1"
    def: >
      Un voto a favor de alguna cosa.

The value of the slug key gives the entry a unique identifier, while the values under ref create “see also” cross-references and the other top-level keys give the term and its definition in various languages.

Use Cases

We envision that glosario will be used in several ways.

Finding lessons

Amari is writing a lesson in R Markdown. She adds glossary data to its YAML header as shown below to indicate that the lesson introduces the idea of least squares, but requires learners to already know about correlation and linear models. Those terms will be added to the head of the HTML page for her lesson, and other instructors can use tools provided with glosario to search for lessons that define the concepts this one requires.

glossary:
  sources:
  - http://carpentries.org/glosario/
  language: fr
  requires:
  - correlation
  - linear_model
  defines:
  - least_squares

Summarizing a lesson

Amari can also add a code chunk to the end of her lesson that includes a call to glosario::summarize_terms(). When she knits the document to HTML, this code chunk inserts a definition list dl at that point. Its entries are the definitions of all of the terms listed under the glossary/defines key in the page’s YAML header in alphabetical order by term according to the rules for glossary/language.

Linking to definitions

Amari adds an inline code block `r gdef('linear_model', 'modéle linéaire')` to her lesson. When she knits her document the code block produces the HTML:

<a href="http://carpentries.org/glosario/fr/#linear-model" class="glossary-definition">modéle linéaire</a>

Checking a lesson

Beatriz has made some changes to a lesson she inherited from Amari and wants to check that it is still consistent. She runs a tool provided with glosario that:

Reads the R Markdown file.
Extracts the terms under the glossary/defines key.
Searches the body of the document for calls to gdef(...).
Checks that every term listed in glossary/defines is referenced in the document body, and that every term referenced in the document body is mentioned in glossary/defines.

How to Contribute

There are lots of way to contribute:

Add definitions or translate and fix the ones already there. If you are comfortable editing YAML and using Git, you can send us a pull request. If you’re not, please file an issue that includes the key of the term and the change you want to make. (Please don’t include multiple changes in a single issue: they’re a lot easier to manage if they aren’t bundled together.)
Work on the supporting tools in the glosario, R, or Python repositories.
Add glossary metadata and definitions to your favorite lessons.

FAQ

Why not just use Wikipedia? We expect that many glossary definitions will link to Wikipedia, but its articles are explanations, not definitions. (This is why we don’t support diagrams in glossary entries.)
YAML is hard for people to edit—why not use something else for the glossary file? Because other formats are just as hard to edit (e.g., JSON) or make one-to-many relationships hard to express (e.g., CSV).

This article is cross-published on the Carpentries blog.

Release the penguins

Mon, 27 Jul 2020 00:00:00 +0000

We are thrilled to share that the palmerpenguins package is now available on CRAN!

The palmerpenguins R package contains two datasets that we believe are a viable alternative to Anderson’s Iris data (via datasets::iris). And just in time for fall, the penguins have landed on CRAN 🎉 They are pretty excited about this (as you can tell). Now, it will be easier for you and your students to get to know them. We also hope it makes it easier for educators and software developers to move on from iris. Here is just one example, plotting the lengths of penguin flippers versus their bills:

You can install the released version of palmerpenguins from CRAN with:

install.packages("palmerpenguins")

In this post, we’ll share some highlights that we think make palmerpenguins fun for teaching data science and statistics. We’ll use functions from the tidyverse to demonstrate:

library(tidyverse)
library(palmerpenguins)

Note: these are not Antarctic penguins; these are Magellanic penguins from the Monterey Bay Aquarium 🐧 But we love them anyway. And these South African penguins want to see what all the fuss about too.

Meet the penguins

The palmerpenguins data contains size measurements, clutch observations, and blood isotope ratios for three penguin species observed on three islands in the Palmer Archipelago, Antarctica over a study period of three years.

These data were collected from 2007 - 2009 by Dr. Kristen Gorman with the Palmer Station Long Term Ecological Research Program, part of the US Long Term Ecological Research Network. The data were imported directly from the Environmental Data Initiative (EDI) Data Portal, and are available for use by CC0 license (“No Rights Reserved”) in accordance with the Palmer Station Data Policy. We gratefully acknowledge Palmer Station LTER and the US LTER Network. Special thanks to Marty Downs (Director, LTER Network Office) for help regarding the data license & use. Here is our intrepid package co-author, Dr. Gorman, in action collecting some penguin data:

You can find this photo and others in a shared Google slideshow, meant to help you teach with this data.

Here is a map of the study site:

The palmerpenguins package

This package contains two datasets:

The raw data is available as penguins_raw.
A curated subset of the raw data in the package named penguins, which can serve as an out-of-the-box alternative to datasets::iris.

When you first call either of these datasets, what you see depends on whether or not you have the tibble package installed on your local workstation. If you do have the tibble package installed, then you will see the first 10 rows of data print as a nice tidy tibble. If not, you’ll see the full dataset print to your console, just as iris does. This allowed us to keep palmerpenguins as lightweight as possible for all users, and yet still user-friendly for tidyverse beginners. A big thank you to Hadley Wickham for contributing this creative solution!

The curated palmerpenguins::penguins dataset contains 8 variables (n = 344 penguins). You can read more about the variables by typing ?penguins.

penguins
#> # A tibble: 344 x 8
#>    species island bill_length_mm bill_depth_mm flipper_length_… body_mass_g
#>    <fct>   <fct>           <dbl>         <dbl>            <int>       <int>
#>  1 Adelie  Torge…           39.1          18.7              181        3750
#>  2 Adelie  Torge…           39.5          17.4              186        3800
#>  3 Adelie  Torge…           40.3          18                195        3250
#>  4 Adelie  Torge…           NA            NA                 NA          NA
#>  5 Adelie  Torge…           36.7          19.3              193        3450
#>  6 Adelie  Torge…           39.3          20.6              190        3650
#>  7 Adelie  Torge…           38.9          17.8              181        3625
#>  8 Adelie  Torge…           39.2          19.6              195        4675
#>  9 Adelie  Torge…           34.1          18.1              193        3475
#> 10 Adelie  Torge…           42            20.2              190        4250
#> # … with 334 more rows, and 2 more variables: sex <fct>, year <int>

Highlights

We don’t want to ruin all the fun exploration, visualization, and potential analyses, so below are just a few examples to get you quickly waddling along with penguins. You can check out more in the “Get started” and the “Examples” vignettes.

If you are teaching correlation and simple linear regression, penguin flipper length and body mass show a positive association for each of the 3 species:

# Scatterplot example 1: penguin flipper length versus body mass
ggplot(data = penguins, aes(x = flipper_length_mm, y = body_mass_g)) +
  geom_point(aes(color = species, 
                 shape = species),
             size = 2) +
  scale_color_manual(values = c("darkorange","darkorchid","cyan4"))

Penguin bill length and depth also show some interesting patterns. If you ignore species, you might think there is a negative correlation:

# Scatterplot example 2: penguin bill length versus bill depth
ggplot(data = penguins, aes(x = bill_length_mm, y = bill_depth_mm)) +
  geom_point(size = 2) +
  geom_smooth(method = "lm", se = FALSE)

But, if you look at the correlations within species, bill length and depth are actually positive correlated. This is a nice “in the wild” example of Simpson’s paradox.

# Scatterplot example 3: penguin bill length versus bill depth
ggplot(data = penguins, aes(x = bill_length_mm, y = bill_depth_mm)) +
  geom_point(aes(color = species, 
                 shape = species),
             size = 2) + 
  geom_smooth(method = "lm", se = FALSE, aes(color = species)) +
  scale_color_manual(values = c("darkorange","darkorchid","cyan4"))

At this point, you may be also want to know how bill length and depth were actually measured. Luckily, Allison Horst drew up some illustrations to help explain this. Here is one for bill measurement:

You can download this and other palmerpenguins art (useful for teaching with the data) directly from the package website. If you use this artwork, please cite with: “Artwork by @allison_horst".

Finally, you can get a pretty clear separation between all three species by looking at flipper length versus bill length:

ggplot(penguins, aes(x = flipper_length_mm, y = bill_length_mm, colour = species, shape = species)) +
  geom_point() +
  scale_colour_manual(values = c("darkorange","purple","cyan4"))

This ends up leading to some nice results using principal components analysis, which is commonly done with iris as a “hello world” PCA example. We provide code to do a simple PCA using tidymodels in the “PCA with penguins and recipes” vignette.

We are also pleased to report that the penguins enjoy clustering as well. Here is an example using K-means clustering with two tidymodels packages, broom and recipes.

One more thing! If you want to give your students experience importing and wrangling data, we made a function that allows you to access the .csv files from within the package. Here is an example of how you use it:

raw_csv <- readr::read_csv(path_to_file("penguins_raw.csv"))
raw_csv
#> # A tibble: 344 x 17
#>    studyName `Sample Number` Species Region Island Stage `Individual ID`
#>    <chr>               <dbl> <chr>   <chr>  <chr>  <chr> <chr>          
#>  1 PAL0708                 1 Adelie… Anvers Torge… Adul… N1A1           
#>  2 PAL0708                 2 Adelie… Anvers Torge… Adul… N1A2           
#>  3 PAL0708                 3 Adelie… Anvers Torge… Adul… N2A1           
#>  4 PAL0708                 4 Adelie… Anvers Torge… Adul… N2A2           
#>  5 PAL0708                 5 Adelie… Anvers Torge… Adul… N3A1           
#>  6 PAL0708                 6 Adelie… Anvers Torge… Adul… N3A2           
#>  7 PAL0708                 7 Adelie… Anvers Torge… Adul… N4A1           
#>  8 PAL0708                 8 Adelie… Anvers Torge… Adul… N4A2           
#>  9 PAL0708                 9 Adelie… Anvers Torge… Adul… N5A1           
#> 10 PAL0708                10 Adelie… Anvers Torge… Adul… N5A2           
#> # … with 334 more rows, and 10 more variables: `Clutch Completion` <chr>, `Date
#> #   Egg` <date>, `Culmen Length (mm)` <dbl>, `Culmen Depth (mm)` <dbl>,
#> #   `Flipper Length (mm)` <dbl>, `Body Mass (g)` <dbl>, Sex <chr>, `Delta 15 N
#> #   (o/oo)` <dbl>, `Delta 13 C (o/oo)` <dbl>, Comments <chr>

You can see the files available by using the path_to_file() function without any arguments:

path_to_file()
#> [1] "penguins_raw.csv" "penguins.csv"

Credit goes to Jenny Bryan for this function, inspired by a similar function in the readxl package.

And as a reminder, you can always read the data in from a url as well:

peng_url <- readr::read_csv("https://raw.githubusercontent.com/allisonhorst/palmerpenguins/master/inst/extdata/penguins.csv")
peng_url
#> # A tibble: 344 x 8
#>    species island bill_length_mm bill_depth_mm flipper_length_… body_mass_g
#>    <chr>   <chr>           <dbl>         <dbl>            <dbl>       <dbl>
#>  1 Adelie  Torge…           39.1          18.7              181        3750
#>  2 Adelie  Torge…           39.5          17.4              186        3800
#>  3 Adelie  Torge…           40.3          18                195        3250
#>  4 Adelie  Torge…           NA            NA                 NA          NA
#>  5 Adelie  Torge…           36.7          19.3              193        3450
#>  6 Adelie  Torge…           39.3          20.6              190        3650
#>  7 Adelie  Torge…           38.9          17.8              181        3625
#>  8 Adelie  Torge…           39.2          19.6              195        4675
#>  9 Adelie  Torge…           34.1          18.1              193        3475
#> 10 Adelie  Torge…           42            20.2              190        4250
#> # … with 334 more rows, and 2 more variables: sex <chr>, year <dbl>

The .csv files are located in the package GitHub repository in the inst/extdata/ folder.

Penguin sightings

You can access the palmerpenguins data outside of R too! Our sincere thanks to all the contributors who made the penguins popular. Here are some other places you might spot the palmerpenguins:

Python

Python users can access the penguins data in the seaborn data visualization library. Example code to load the data in Python:

import seaborn as sns
df = sns.load_dataset(‘penguins’)

Julia

Julia users can access the penguins data in the PalmerPenguins.jl package. Example code to import the penguins data through PalmerPenguins.jl:

julia> using PalmerPenguins
julia> table = PalmerPenguins.load()

OpenML

openml.org is a public repository for machine learning data and experiments. Find the penguins here:

https://www.openml.org/d/42585

You can also download the penguins from the openml.org repository with Python using scikit-learn:

from sklearn.datasets import fetch_openml
penguins = fetch_openml(name='penguins', version=1)

Tidy Tuesday

The penguins are chuffed to be the dataset this week! Check out the announcement here: https://github.com/rfordatascience/tidytuesday/blob/master/data/2020/2020-07-28/readme.md

Kaggle

https://www.kaggle.com/parulpandey/palmer-archipelago-antarctica-penguin-data

Makeover Monday

Makeover Monday featured the penguins on 2020/07/13.

Meetups & talks

Here are recent highlights on our penguin radar!

Di Cook: Going beyond 2D and 3D to visualise higher dimensions, for ordination, clustering and other models
Samantha Toet: Building dashboards with flexdashboard and Shiny

Contribute your own examples

If you use palmerpenguins, please consider sharing with us and add it to our user-contributed examples. And don’t forget about the photos and art to help you teach with the palmerpenguins!

Penguin citation

Please cite the palmerpenguins R package using:

citation("palmerpenguins")
#> 
#> To cite palmerpenguins in publications use:
#> 
#>   Horst AM, Hill AP, Gorman KB (2020). palmerpenguins: Palmer
#>   Archipelago (Antarctica) penguin data. R package version 0.1.0.
#>   https://allisonhorst.github.io/palmerpenguins/. doi:
#>   10.5281/zenodo.3960218.
#> 
#> A BibTeX entry for LaTeX users is
#> 
#>   @Manual{,
#>     title = {palmerpenguins: Palmer Archipelago (Antarctica) penguin data},
#>     author = {Allison Marie Horst and Alison Presmanes Hill and Kristen B Gorman},
#>     year = {2020},
#>     note = {R package version 0.1.0},
#>     doi = {10.5281/zenodo.3960218},
#>     url = {https://allisonhorst.github.io/palmerpenguins/},
#>   }

Have fun with the Palmer Archipelago penguins!

References

Data originally published in:

Gorman KB, Williams TD, Fraser WR (2014). Ecological sexual dimorphism and environmental variability within a community of Antarctic penguins (genus Pygoscelis). PLoS ONE 9(3):e90081. https://doi.org/10.1371/journal.pone.0090081

Individual datasets:

Individual data can be accessed directly via the Environmental Data Initiative:

Palmer Station Antarctica LTER and K. Gorman, 2020. Structural size measurements and isotopic signatures of foraging among adult male and female Adélie penguins (Pygoscelis adeliae) nesting along the Palmer Archipelago near Palmer Station, 2007-2009 ver 5. Environmental Data Initiative. https://doi.org/10.6073/pasta/98b16d7d563f265cb52372c8ca99e60f (Accessed 2020-06-08).
Palmer Station Antarctica LTER and K. Gorman, 2020. Structural size measurements and isotopic signatures of foraging among adult male and female Gentoo penguin (Pygoscelis papua) nesting along the Palmer Archipelago near Palmer Station, 2007-2009 ver 5. Environmental Data Initiative. https://doi.org/10.6073/pasta/7fca67fb28d56ee2ffa3d9370ebda689 (Accessed 2020-06-08).
Palmer Station Antarctica LTER and K. Gorman, 2020. Structural size measurements and isotopic signatures of foraging among adult male and female Chinstrap penguin (Pygoscelis antarcticus) nesting along the Palmer Archipelago near Palmer Station, 2007-2009 ver 6. Environmental Data Initiative. https://doi.org/10.6073/pasta/c14dfcfada8ea13a17536e73eb6fbe9e (Accessed 2020-06-08).

Acknowledgements

A big thank you to all palmerpenguins contributors: @allisonhorst, @amrrs, @apreshill, @brunj7, @devmotion, @eddelbuettel, @friendly, @hadley, @jannikbuhr, @jhk0530, @john-sandall, @karaesmen, @markvanderloo, @trang1618, and @ttimbers

Presentation-Ready Summary Tables with gtsummary

Mon, 20 Jul 2020 00:00:00 +0000

We are thrilled to introduce you to the gtsummary package!

The gtsummary package provides an elegant and flexible way to create publication-ready analytical and summary tables in R.

The motivation behind the package stems from our work as statisticians, where every day we summarize datasets and regression models in R, share these results with collaborators, and eventually include them in published manuscripts. Many of our colleagues had our own scripts to create the tables we needed, and even then would often need to modify the formatting in a document editor later, which did not lead to reproducible results.

At the time we created the package, we had several ideas in mind for our ideal table summary package. We also wanted our tables to be able to take advantage of all the features in RStudio’s newly released gt package, which offers a variety of table customization options like spanning column headers, table footnotes, stubhead label, row group labels and more. So, gtsummary was born!

Here’s what you can do with gtsummary:

Summarize data frames or tibbles to present descriptive statistics, compare group demographics (e.g creating a Table 1 for medical journals), and more!
Summarize regression models. Using broom::tidy() in the background, gtsummary plays nicely with many model types (lm, glm, coxph, glmer etc.). You may also use custom functions to summarize regression models that do not currently have broom tidiers.
Customize gtsummary tables using a growing list of formatting/styling functions: everything from which statistics and tests to use to how many decimal places to round to, bolding labels, indenting categories and more!
Report statistics inline from summary tables and regression summary tables in R markdown. Make your reports completely reproducible!
Leverage compatibility with multiple R Markdown outputs to create beautiful, reproducible reports in a variety of formats (HTML, PDF, Word, RTF)

Install gtsummary from CRAN with the following code:

install.packages("gtsummary")

Summarize descriptive statistics

Throughout the post we will use an example dataset of 200 subjects treated with either Drug A or Drug B, with a mix of categorical, dichotomous, and continuous demographic and response data. The dataset has label attributes (using the labelled package) for column names.

sm_trial <- trial %>% select(trt, age, response, grade)

head(sm_trial)
#> # A tibble: 6 x 4
#>   trt      age response grade
#>   <chr>  <dbl>    <int> <fct>
#> 1 Drug A    23        0 II   
#> 2 Drug B     9        1 I    
#> 3 Drug A    31        0 II   
#> 4 Drug A    NA        1 III  
#> 5 Drug A    51        1 III  
#> 6 Drug B    39        0 I

In one line of code we can summarize the overall demographics of the dataset!

Notice some nice default behaviors:
💜 Detects variable types of input data and calculates descriptive statistics
💜 Variables coded as 0/1, TRUE/FALSE, and Yes/No are presented dichotomously
💜 Recognizes NA values as “missing” and lists them as unknown
💜 Label attributes automatically printed
💜 Variable levels indented and footnotes added

tbl_summary_1 <- tbl_summary(sm_trial)

Start customizing by adding arguments and functions

Next you can start to customize the table by using arguments of the tbl_summary() function, as well as pipe the table through additional gtsummary functions to add more information, like p-value to compare across groups and overall demographic column.

tbl_summary_2 <- sm_trial %>%
  tbl_summary(by = trt) %>%
  add_p() %>%
  add_overall() %>% 
  bold_labels()

Customize further using formula syntax and tidy selectors

Most arguments to tbl_summary() and tbl_regression() require formula syntax:

select variables ~ specify what you want to do

To select, use quoted or unquoted variables, or minus sign to negate (e.g. age or "age" to select, -age to deselect)
Or use any {tidyselect} functions, e.g. contains("stage") ~ ..., including type selectors
To specify what you want to do, some arguments use {glue} syntax where whatever is in the curly brackets gets evaluated and passed directly into the string. e.g statistic = ... ~ "{mean} ({sd})"

tbl_summary_3 <- sm_trial %>%
  tbl_summary(
    by = trt,
    statistic = list(
      all_continuous() ~ "{mean} ({sd})",
      all_categorical() ~ "{n} / {N} ({p}%)"), 
    label = age ~ "Patient Age") %>%
  add_p(test = all_continuous() ~ "t.test",
        pvalue_fun = function(x) style_pvalue(x, digits = 2))

Summarize regression models

First, create a logistic regression model to use in examples.

m1 <- glm(response ~ trt + grade + age, 
          data = trial,
          family = binomial)

tbl_regression() accepts regression model object as input. Uses {broom} in the background, outputs table with nice defaults:

💜 Reference groups added to the table
💜 Sensible default number rounding and formatting
💜 Label attributes printed
💜 Common model types detected and appropriate header added with footnote

tbl_reg_1 <- tbl_regression(m1, exponentiate = TRUE)

We have a growing list of vetted models that can be passed to tbl_regression(). You may also pass a custom tidier for model types that are not yet officially supported!

Join two or more tables

Oftentimes we must present results for multiple outcomes of interest, and there are many other reasons you might want to join two summary tables together. We’ve got you covered!

In this example we can use tbl_merge() to merge two gtsummary objects side-by-side. There is also a tbl_stack() function to place tables on top of each other.

library(survival)

tbl_reg_3 <- 
  coxph(Surv(ttdeath, death) ~ trt + grade + age, 
        data = trial) %>%
  tbl_regression(exponentiate = TRUE)

tbl_reg_4 <-
  tbl_merge(
    tbls = list(tbl_reg_1, tbl_reg_3), 
    tab_spanner = c("**Tumor Response**", "**Time to Death**") 
  )

Report results inline

Tables are important, but we often need to report results in-line in a report. Any statistic reported in a gtsummary table can be extracted and reported in-line in a R Markdown document with the inline_text() function.

inline_text(tbl_reg_1, variable = trt, level = "Drug B")

1.13 (95% CI 0.60, 2.13; p=0.7)

The pattern of what is reported can be modified with the pattern = argument.
Default is pattern = "{estimate} ({conf.level*100}% CI {conf.low}, {conf.high}; {p.value})".

gtsummary + R Markdown

The gtsummary package was written to be a companion to the gt package from RStudio. But not all output types are supported by the gt package (yet!). Therefore, we have made it possible to print gtsummary tables with various engines.

Review the gtsummary + R Markdown vignette for details.

Using external customization functions

It’s natural a gtsummary package user would want to customize the aesthetics of the table with some of the many functions available in the print engines listed above.

Once you convert a gtsummary object to another kind of object (e.g. gt), every function compatible that object will be available to use!

Example workflow and code using gt customization:

Create a gtsummary table.
Convert the table to a gt object with the as_gt() function. (Also available: as_flextable(), as_kable_extra()…
Continue formatting as a gt table with any gt function.

tbl_summary_5 <- sm_trial %>%
  # create a gtsummary table
  tbl_summary(by = trt) %>%
  # convert from gtsummary object to gt object
  as_gt() %>%
  # modify with gt functions
  gt::tab_header("Table 1: Baseline Characteristics") %>% 
  gt::tab_spanner(
    label = "Randomization Group",  
    columns = starts_with("stat_")
  ) %>% 
  gt::tab_options(
    table.font.size = "small",
    data_row.padding = gt::px(1))

Additional features

There are a few other functions we’d like you to know about!

tbl_uvregression() to make tables summarizing univariable regression models (input a dataset, specify model and parameters… make a UVA regression table easily!)
tbl_survfit() function to summarize survival models
tbl_cross() to make beautiful cross tables
Use themes to format your table for specific journal/aesthetic requirements!

Additional customization options

See the full list of gtsummary functions here. You can use them to do all sorts of things to your tables, like:

Use custom functions for calculating p-values and reporting any statistic for continuous variables (including user-written functions)
Bold and italicize labels and levels
Present missing data in various ways
Sort variables by significance (sort_p()); sort categorical variables by frequency
Calculate cell percents and row percents (default is column-wide)
Report p-values for select variables (add_p(include = ...)); report q-values (like false discovery rate)
Set global rounding options with themes (for estimates, confidence intervals, and p-values)

There is a growing gallery of tables which highlights some of the many customization options!

Wrap-up

The gtsummary package website contains well-documented functions, detailed tutorials, and examples!

If you have any questions on usage, please post to StackOverflow and use the gtsummary tag. We try to answer questions ASAP! You can also report bugs or make feature requests by submitting an issue on GitHub.

May your code be short, your tables beautiful, and your reports fully reproducible!

Acknowledgements

A big thank you to all gtsummary contributors: @ablack3, @ahinton-mmc, @barthelmes, @calebasaraba, @CodieMonster, @davidgohel, @davidkane9, @dax44, @ddsjoberg, @DeFilippis, @emilyvertosick, @gorkang, @GuiMarthe, @hughjonesd, @jalavery, @jeanmanguy, @jemus42, @jennybc, @JesseRop, @jflynn264, @joelgautschi, @jwilliman, @karissawhiting, @khizzr, @larmarange, @leejasme, @ltin1214, @margarethannum, @matthieu-faron, @michaelcurry1123, @moleps, @MyKo101, @oranwutang, @proshano, @ryzhu75, @sammo3182, @sbalci, @simonpcouch, @slb2240, @slobaugh, @tormodb, @UAB-BST-680, @zabore, and @zeyunlu

Teaching the Tidyverse in 2020 - Part 4: When to purrr?

Sun, 19 Jul 2020 00:00:00 +0000

Welcome to the fourth (and final!) post in the “Teaching the Tidyverse in 2020” series. So far we have covered getting started, data visualisation, and data wrangling and tidying. Today the focus will be on when to introduce the purrr package, or more widely, the notion of iteration and functional programming.

In a nutshell, purrr enhances R’s functional programming toolkit by providing a complete and consistent set of tools for working with functions and vectors. Its attractive features include informative naming of functions (even if you don’t know anything about purrr or functional programming you can probably guess that map_chr() is about characters vs. map_int() is about integers) and type consistency. purrr is useful for solving iterative problems in R, and the family of map() functions is what finally broke my habit of writing for loops to solve iterative problems in R.

At rstudio::conf(2020), Hadley Wickham gave a talk titled State of the Tidyverse and among the list of things he is particularly excited about for 2020, he listed “less purrr for data science”. In this post we take a look at a few common data science tasks that are iterative in nature, part of the introductory data science curriculum (or should be!), and that can be carried out using tools others than purrr in the tidyverse.

library(tidyverse)

Reading in many files at once

The vroom package is designed for reading data into R fast, but it also offers a very handy functionality for reading in many data files at once without the need for a for loop or a map() function.

Let’s return back to the palmerpenguins package for this example. Let’s artificially create multiple files we want to read in at once by splitting the penguins dataset into three csv files, one for each species, named as [NAME OF SPECIES].csv, and save them in the data/ folder.

library(palmerpenguins)

penguins %>%
  group_by(species) %>%
  group_walk(~ write_csv(.x, paste0("data/", .y$species, ".csv")))

Let’s inspect the data directory and confirm the files look as we expect them to. We’ll make use of the fs package for this, specifically the dir_ls() function to get information on the contents of a directory.

library(fs)

dir_ls(path = "data", glob = "*csv")

## data/Adelie.csv    data/Chinstrap.csv data/Gentoo.csv

We can read each of these files with read_csv() and bind the rows to create a single data frame.

adelie    <- read_csv("data/Adelie.csv")
chinstrap <- read_csv("data/Chinstrap.csv")
gentoo    <- read_csv("data/Gentoo.csv")
all_three <- bind_rows(adelie, chinstrap, gentoo, .id = "species")

You can imagine this could get tedious quickly if there were a large number of files to be read in. To do this programmatically, we first need a list of the files we want to read in.

files <- dir_ls(path = "data", glob = "*csv")
files

## data/Adelie.csv    data/Chinstrap.csv data/Gentoo.csv

The purrr solution to this problem is as follows. It seems pretty straight forward, but it requires understanding what mapping a function over each item of a given vector means.

map_dfr(files, read_csv, .id = "species")

## # A tibble: 344 x 7
##    species island bill_length_mm bill_depth_mm flipper_length_… body_mass_g
##    <chr>   <chr>           <dbl>         <dbl>            <dbl>       <dbl>
##  1 data/A… Torge…           39.1          18.7              181        3750
##  2 data/A… Torge…           39.5          17.4              186        3800
##  3 data/A… Torge…           40.3          18                195        3250
##  4 data/A… Torge…           NA            NA                 NA          NA
##  5 data/A… Torge…           36.7          19.3              193        3450
##  6 data/A… Torge…           39.3          20.6              190        3650
##  7 data/A… Torge…           38.9          17.8              181        3625
##  8 data/A… Torge…           39.2          19.6              195        4675
##  9 data/A… Torge…           34.1          18.1              193        3475
## 10 data/A… Torge…           42            20.2              190        4250
## # … with 334 more rows, and 1 more variable: sex <chr>

Alternatively, this can be achieved with the vroom() function from the package with the same name.

library(vroom)

vroom(files, id = "species")

## # A tibble: 344 x 7
##    species island bill_length_mm bill_depth_mm flipper_length_… body_mass_g
##    <chr>   <chr>           <dbl>         <dbl>            <dbl>       <dbl>
##  1 data/A… Torge…           39.1          18.7              181        3750
##  2 data/A… Torge…           39.5          17.4              186        3800
##  3 data/A… Torge…           40.3          18                195        3250
##  4 data/A… Torge…           NA            NA                 NA          NA
##  5 data/A… Torge…           36.7          19.3              193        3450
##  6 data/A… Torge…           39.3          20.6              190        3650
##  7 data/A… Torge…           38.9          17.8              181        3625
##  8 data/A… Torge…           39.2          19.6              195        4675
##  9 data/A… Torge…           34.1          18.1              193        3475
## 10 data/A… Torge…           42            20.2              190        4250
## # … with 334 more rows, and 1 more variable: sex <chr>

This feels a lot more like the read_csv() function your students would undoubtedly be familiar with before they set out to read many csv files at once. The species variable needs to be cleaned up a bit, which we can achieve with character manipulation.

vroom(files, id = "species") %>%
  mutate(
    species = str_remove(species, "data/"),
    species = str_remove(species, "\\.csv")
    )

## # A tibble: 344 x 7
##    species island bill_length_mm bill_depth_mm flipper_length_… body_mass_g
##    <chr>   <chr>           <dbl>         <dbl>            <dbl>       <dbl>
##  1 Adelie  Torge…           39.1          18.7              181        3750
##  2 Adelie  Torge…           39.5          17.4              186        3800
##  3 Adelie  Torge…           40.3          18                195        3250
##  4 Adelie  Torge…           NA            NA                 NA          NA
##  5 Adelie  Torge…           36.7          19.3              193        3450
##  6 Adelie  Torge…           39.3          20.6              190        3650
##  7 Adelie  Torge…           38.9          17.8              181        3625
##  8 Adelie  Torge…           39.2          19.6              195        4675
##  9 Adelie  Torge…           34.1          18.1              193        3475
## 10 Adelie  Torge…           42            20.2              190        4250
## # … with 334 more rows, and 1 more variable: sex <chr>

Working with list columns

In the previous post on data wrangling and tidying we worked with a wide data frame of repeated observations stored across columns. We’ll return back to this data frame, except this time let’s store the repeated observations in a single list column called body_mass.

penguins_madeup_list <- tribble(
  ~name,        ~sex,     ~body_mass, 
  "Mumble",     "male",   c(4801, 5699, 5743),         
  "Gloria",     "female", c(4785, 3092, 4220),         
  "Memphis",    "male",   c(3349, 4186, 4454),         
  "Norma Jean", "female", c(4235, 3220, 4019)        
)

penguins_madeup_list

## # A tibble: 4 x 3
##   name       sex    body_mass
##   <chr>      <chr>  <list>   
## 1 Mumble     male   <dbl [3]>
## 2 Gloria     female <dbl [3]>
## 3 Memphis    male   <dbl [3]>
## 4 Norma Jean female <dbl [3]>

Our goal is to find the average body mass for penguin based on these measurements. We can do this using purrr as follows.

penguins_madeup_list %>% 
  mutate(body_mass_avg = purrr::map_dbl(body_mass, mean))

## # A tibble: 4 x 4
##   name       sex    body_mass body_mass_avg
##   <chr>      <chr>  <list>            <dbl>
## 1 Mumble     male   <dbl [3]>         5414.
## 2 Gloria     female <dbl [3]>         4032.
## 3 Memphis    male   <dbl [3]>         3996.
## 4 Norma Jean female <dbl [3]>         3825.

But with a combination of rowwise() and summarise() it’s also possible to accomplish this task without purrr.

penguins_madeup_list %>%
  rowwise() %>%
  mutate(body_mass_avg = mean(body_mass))

## # A tibble: 4 x 4
## # Rowwise: 
##   name       sex    body_mass body_mass_avg
##   <chr>      <chr>  <list>            <dbl>
## 1 Mumble     male   <dbl [3]>         5414.
## 2 Gloria     female <dbl [3]>         4032.
## 3 Memphis    male   <dbl [3]>         3996.
## 4 Norma Jean female <dbl [3]>         3825.

With this structure it’s also possible to create a list column that has many elements, e.g. more than one summary statistic.

penguins_madeup_list <- penguins_madeup_list %>%
  rowwise() %>%
  mutate(body_mass_summary = list(summary(body_mass)))

penguins_madeup_list

## # A tibble: 4 x 4
## # Rowwise: 
##   name       sex    body_mass body_mass_summary
##   <chr>      <chr>  <list>    <list>           
## 1 Mumble     male   <dbl [3]> <table [6]>      
## 2 Gloria     female <dbl [3]> <table [6]>      
## 3 Memphis    male   <dbl [3]> <table [6]>      
## 4 Norma Jean female <dbl [3]> <table [6]>

To confirm that the body_mass_summary column indeed has the summary statistics we asked for, we can unnest that column.

penguins_madeup_list %>%
  unnest_wider(body_mass_summary)

## # A tibble: 4 x 9
##   name       sex    body_mass  Min. `1st Qu.` Median  Mean `3rd Qu.`  Max.
##   <chr>      <chr>  <list>    <dbl>     <dbl>  <dbl> <dbl>     <dbl> <dbl>
## 1 Mumble     male   <dbl [3]>  4801     5250    5699 5414.     5721   5743
## 2 Gloria     female <dbl [3]>  3092     3656    4220 4032.     4502.  4785
## 3 Memphis    male   <dbl [3]>  3349     3768.   4186 3996.     4320   4454
## 4 Norma Jean female <dbl [3]>  3220     3620.   4019 3825.     4127   4235

What is this unnest magic, you ask? Let’s look at that in a bit more detail next.

Data rectangling

JSON is a commonly used hierarchical data type and it is especially commonly used on the web. Reading in data from JSON files and turning them into rectangular (tabular) data is an important skill for most data scientists to have, and with today’s tooling in the tidyverse, it’s feasible to teach this skill in data science courses at any level.

Let’s take a look at our made up penguin data, this time stored in JSON format with a few additional variables. We’ll read in the data using the jsonlite package.

library(jsonlite)

penguins_madeup_json <- read_json("data/penguins_madeup.json")

Let’s take a look at the first entry to get a sense of the structure of each the data.

toJSON(penguins_madeup_json[1], pretty = TRUE)

## [
##   {
##     "gender": ["male"],
##     "first_name": ["Mumble"],
##     "measurements": [
##       {
##         "date": ["2007-11-11"],
##         "body_mass": [4801],
##         "flipper_length": [181]
##       },
##       {
##         "date": ["2007-11-16"],
##         "body_mass": [5699],
##         "flipper_length": [182]
##       },
##       {
##         "date": ["2007-11-19"],
##         "body_mass": [5743],
##         "flipper_length": [181]
##       }
##     ]
##   }
## ]

purrr is a great solution for working with lists, and hence for flattening JSON files. There are a couple ways we can solve this problem with purrr. I’ll start with the less verbose approach.

penguins_madeup_json %>%
  map_dfr(
    
    function(penguin) {
      penguin$measurements <- bind_rows(penguin$measurements)
      bind_cols(penguin)
    }
    
  )

## # A tibble: 12 x 5
##    gender first_name date       body_mass flipper_length
##    <chr>  <chr>      <chr>          <int>          <int>
##  1 male   Mumble     2007-11-11      4801            181
##  2 male   Mumble     2007-11-16      5699            182
##  3 male   Mumble     2007-11-19      5743            181
##  4 female Gloria     2007-11-11      4785            186
##  5 female Gloria     2007-11-14      3092            182
##  6 female Gloria     2007-11-19      4220            183
##  7 male   Memphis    2007-11-11      3349            190
##  8 male   Memphis    2007-11-15      4186            188
##  9 male   Memphis    2007-11-17      4454            191
## 10 female Norma Jean 2007-11-11      4235            193
## 11 female Norma Jean 2007-11-12      3220            191
## 12 female Norma Jean 2007-11-18      4019            194

While this works, it is certainly not trivial code to parse through. A slightly simpler approach with purrr involves being more expressive with how we extract each column of data.

penguins_madeup_json %>%
  map_dfr(
    function(penguin) {
      
      tibble(
        gender         = penguin$gender,
        first_name     = penguin$first_name,
        date           = map_chr(penguin$measurements, "date"),
        body_mass      = map_chr(penguin$measurements, "body_mass"),
        flipper_length = map_chr(penguin$measurements, "flipper_length")
      )
      
    }
  )

## # A tibble: 12 x 5
##    gender first_name date       body_mass flipper_length
##    <chr>  <chr>      <chr>      <chr>     <chr>         
##  1 male   Mumble     2007-11-11 4801      181           
##  2 male   Mumble     2007-11-16 5699      182           
##  3 male   Mumble     2007-11-19 5743      181           
##  4 female Gloria     2007-11-11 4785      186           
##  5 female Gloria     2007-11-14 3092      182           
##  6 female Gloria     2007-11-19 4220      183           
##  7 male   Memphis    2007-11-11 3349      190           
##  8 male   Memphis    2007-11-15 4186      188           
##  9 male   Memphis    2007-11-17 4454      191           
## 10 female Norma Jean 2007-11-11 4235      193           
## 11 female Norma Jean 2007-11-12 3220      191           
## 12 female Norma Jean 2007-11-18 4019      194

I think this is easier to read for an introductory audience, but it still requires understanding how anonymous functions work, which is not trivial.

Enter tidyr, and the family of unnest_*() functions. Let’s go step by step.

Step 1: Place list object resulting from reading in the JSON file into a tibble.

penguins_madeup_json %>%
  tibble(penguins_madeup = .)

## # A tibble: 4 x 1
##   penguins_madeup 
##   <list>          
## 1 <named list [3]>
## 2 <named list [3]>
## 3 <named list [3]>
## 4 <named list [3]>

Step 2: Unnest the list object by turning each element of a list-column into a column with unnest_wider().

penguins_madeup_json %>%
  tibble(penguins_madeup = .) %>%
  unnest_wider(penguins_madeup)

## # A tibble: 4 x 3
##   gender first_name measurements
##   <chr>  <chr>      <list>      
## 1 male   Mumble     <list [3]>  
## 2 female Gloria     <list [3]>  
## 3 male   Memphis    <list [3]>  
## 4 female Norma Jean <list [3]>

Step 3: Unnest the measurements column by turning each element into a row with unnest_longer().

penguins_madeup_json %>%
  tibble(penguins_madeup = .) %>%
  unnest_wider(penguins_madeup) %>%
  unnest_longer(measurements)

## # A tibble: 12 x 3
##    gender first_name measurements    
##    <chr>  <chr>      <list>          
##  1 male   Mumble     <named list [3]>
##  2 male   Mumble     <named list [3]>
##  3 male   Mumble     <named list [3]>
##  4 female Gloria     <named list [3]>
##  5 female Gloria     <named list [3]>
##  6 female Gloria     <named list [3]>
##  7 male   Memphis    <named list [3]>
##  8 male   Memphis    <named list [3]>
##  9 male   Memphis    <named list [3]>
## 10 female Norma Jean <named list [3]>
## 11 female Norma Jean <named list [3]>
## 12 female Norma Jean <named list [3]>

Step 4: Unnest the measurements column again, this time turning each element in the list into a column with unnest_wider().

penguins_madeup_json %>%
  tibble(penguins_madeup = .) %>%
  unnest_wider(penguins_madeup) %>%
  unnest_longer(measurements)%>%
  unnest_wider(measurements)

## # A tibble: 12 x 5
##    gender first_name date       body_mass flipper_length
##    <chr>  <chr>      <chr>          <int>          <int>
##  1 male   Mumble     2007-11-11      4801            181
##  2 male   Mumble     2007-11-16      5699            182
##  3 male   Mumble     2007-11-19      5743            181
##  4 female Gloria     2007-11-11      4785            186
##  5 female Gloria     2007-11-14      3092            182
##  6 female Gloria     2007-11-19      4220            183
##  7 male   Memphis    2007-11-11      3349            190
##  8 male   Memphis    2007-11-15      4186            188
##  9 male   Memphis    2007-11-17      4454            191
## 10 female Norma Jean 2007-11-11      4235            193
## 11 female Norma Jean 2007-11-12      3220            191
## 12 female Norma Jean 2007-11-18      4019            194

The purrr solution may be more flexible, but if all you want to do is to unnest list columns to create rectangular data, I think this approach can be a lot more accessible for an introductory audience. And if you don’t want to think about whether you need to go wider or longer, you can also use unnest_auto() first and let tidyr choose for you!

penguins_madeup_json %>%
  tibble(penguins_madeup = .) %>%
  unnest_auto(penguins_madeup) %>%
  unnest_auto(measurements) %>%
  unnest_auto(measurements)

## Using `unnest_wider(penguins_madeup)`; elements have 3 names in common

## Using `unnest_longer(measurements)`; no element has names

## Using `unnest_wider(measurements)`; elements have 3 names in common

## # A tibble: 12 x 5
##    gender first_name date       body_mass flipper_length
##    <chr>  <chr>      <chr>          <int>          <int>
##  1 male   Mumble     2007-11-11      4801            181
##  2 male   Mumble     2007-11-16      5699            182
##  3 male   Mumble     2007-11-19      5743            181
##  4 female Gloria     2007-11-11      4785            186
##  5 female Gloria     2007-11-14      3092            182
##  6 female Gloria     2007-11-19      4220            183
##  7 male   Memphis    2007-11-11      3349            190
##  8 male   Memphis    2007-11-15      4186            188
##  9 male   Memphis    2007-11-17      4454            191
## 10 female Norma Jean 2007-11-11      4235            193
## 11 female Norma Jean 2007-11-12      3220            191
## 12 female Norma Jean 2007-11-18      4019            194

If you want to learn more about the family of unnest_*() functions, I recommend the rectangling vignnette in the tidyr package, and if you want to learn more about using purrr for such a task, I recommend Charlotte Wickham’s purrr tutorial if you prefer to browse through slides and Jenny Bryan’s purrr tutorial if you prefer written examples.

So… when to purrr?

So far I’ve discussed when not to purrr, and provided alternative solutions to using packages like dplyr, tidyr, and vroom. This approach allows you to solve more data wrangling and import tasks before teaching functions, iteration, and mapping, i.e. get through more of your data science curriculum before diving into topics that are more traditionally programming than data science. So, when would be a good time in the introductory science curriculum to introduce these topics? I would recommend doing so after covering data visualisation, wrangling, and import, but before going into modeling and inference. And I would recommend doing with a motivating example of webscraping, where the webscraping task involves bringing together data from multiple pages that are all formatted the same way (e.g. IMDB pages on movies, voting records for each state). The recipe you might follow is:

Use rvest to scrape a single page
Introduce functions, and functionalize the code you wrote for scraping a single page
Use the function to scrape three pages, one by one, and bind the data together
Introduce iteration, and map the function you wrote across many pages

You can find an example of this approach in a paper I recently published with Mine Dogucu here, where we follow the recipe I outlined above to scrape data from OpenSecrets. We have also made the code available in an RStudio Cloud project to make it easier for readers to try it out.

Before we wrap up this post I want to expand a bit more on why I think it’s worthwhile to discuss the mechanics of iteration prior to introducing statistical inference, especially if you’re teaching simulation-based inference where there is lots of “resampling over and over”. A few years ago I was introducing students to for loops at the same time as I was introducing them to the concept of bootstrapping, i.e. motivating the computational mechanics with statistical inference. But statistical inference is hard to wrap one’s head around, and for loops aren’t necessarily easy for novice programmers either. By introducing the mechanics of iteration (whether via for loops or via functional programming with purrr) I feel like I can spend more time on the why of simulation-based statistical inference rather than the how. After a few examples on bootstrapping where we explicitly write the code for how to resample, I introduce the infer package and offload the computational details to its functions while keeping the focus in the class on the statistical ideas.

I think I can summarise this post on “when to purrr?” in four bullet points:

There are many ways to solve iterative problems in R.
Some ways need more scaffolding than others.
It’s worth considering how much of purrr fits into your introductory data science curriculum, especially if you’re feeling like your syllabus is crammed and you need to make room for other topics or for more practice.
For a more advanced data science or statistical programming course, purrr is a great introduction to functional programming.

That’s the end of the “Teaching the Tidyverse in 2020” series, thank you for sticking with me! Over the four posts in the series we talked a lot about tooling. Before we wrap things up I also want to give a list (in no particular order) of resources that can enhance and supplement your teaching materials:

Illustrations os statistical topics and R packages by Allison Horst
Animations of tidyverse verbs using R, the tidyverse, and gganimate by Garrick Aden-Buie
#TwoFunctionsMostDays by Sharla Gelfand (not actively updated, but lots of gems nonetheless!)
TidyTuesday by the R for Data Science Community
The R-Ladies Global channel on YouTube as well as many other R-Ladies channels on YouTube (many of which have videos in languages other than English!)
All the useR! 2020 videos (and videos from the past useR! conferences) by the R Consortium

And of course, the #rstats hashtag on Twitter for a constant stream of R inspiration!

Teaching the Tidyverse in 2020 - Part 3: Data wrangling and tidying

Fri, 17 Jul 2020 00:00:00 +0000

This is the third blog post in the “Teaching the Tidyverse in 2020” series. The first post was on getting started, the second on data visualisation, and today our focus is data wrangling and tidying. In this post, I’ll highlight of the some new(ish) features of dplyr and tidyr. Over the past year there has been a lot of exciting updates to both of these packages and these updates are well documented in the tidyverse blog. My goal here is to highlight updates that apply to introductory data science or statistics curricula.

Throughout this post we’ll be using the tidyverse package, so let’s go ahead and load it.

library(tidyverse)

Reshaping data

A common task in data analysis is going from wide data (e.g. where repeated measurements on a subject are recorded in a single row across consecutive columns) to long data (where each measurement is represented as a row), or vice versa. We’ll stick with penguins in this post, but make up some (realistic) data that lends itself to reshaping from wide to long. Suppose we have 4 penguins in our sample, and we take measure the body mass of each penguin 3 times. We also record their names, sex, and whether they tap dance (yup, you heard that right!).

penguins_madeup_wide <- tribble(
  ~name,        ~sex,     ~tap_dance, ~body_mass_1, ~body_mass_2, ~body_mass_3, 
  "Mumble",     "male",   TRUE,       4801,         5699,         5743,         
  "Gloria",     "female", FALSE,      4785,         3092,         4220,         
  "Memphis",    "male",   FALSE,      3349,         4186,         4454,         
  "Norma Jean", "female", FALSE,      4235,         3220,         4019        
)

penguins_madeup_wide

## # A tibble: 4 x 6
##   name       sex    tap_dance body_mass_1 body_mass_2 body_mass_3
##   <chr>      <chr>  <lgl>           <dbl>       <dbl>       <dbl>
## 1 Mumble     male   TRUE             4801        5699        5743
## 2 Gloria     female FALSE            4785        3092        4220
## 3 Memphis    male   FALSE            3349        4186        4454
## 4 Norma Jean female FALSE            4235        3220        4019

Now suppose we want to create the following visualisation.

To make this visualisation we need to get our data frame to look like the output shown below, where each point plotted corresponds to one row of the data frame and body mass measurements appear in a single column with a new columns (measurement) identifying which of the three measurements the record comes from.

## # A tibble: 12 x 5
##    name       sex    tap_dance measurement body_mass
##    <chr>      <chr>  <lgl>     <chr>           <dbl>
##  1 Mumble     male   TRUE      1                4801
##  2 Mumble     male   TRUE      2                5699
##  3 Mumble     male   TRUE      3                5743
##  4 Gloria     female FALSE     1                4785
##  5 Gloria     female FALSE     2                3092
##  6 Gloria     female FALSE     3                4220
##  7 Memphis    male   FALSE     1                3349
##  8 Memphis    male   FALSE     2                4186
##  9 Memphis    male   FALSE     3                4454
## 10 Norma Jean female FALSE     1                4235
## 11 Norma Jean female FALSE     2                3220
## 12 Norma Jean female FALSE     3                4019

Previously you might have approached this with the gather()/spread() functions. But there is a new pair of much more intuitive functions in town (i.e. in the tidyr package): pivot_wider() for going from longer to wider data and pivot_longer() for going from wider to longer data. The following animated visualisation by Mara Averick does a fantastic job of visually explaining what we mean by pivoting the longer (or wider).

Before embarking in the code, it’s useful to ask questions about what the expected output will look like in terms or number of rows and columns, e.g. “If the long data will have a row for each penguin/measurement combination, and there are 4 penguins and 3 measurements for each, how many rows will the desired data frame have?". Having some expectation about what the output of a function will look like is good practice to instil in students.

In this case we want to go from a wider data frame (with more columns) to a longer data frame (with fewer columns, and more rows), so we will use the pivot_longer() function. We need to tell the function, at a minimum,

which columns to pivot: any column that starts with the character string "body_mass",
what the name of the new variable where we put the names of the variables that are being pivoted should go to: names_to = "measurement", and
what the name of the new variable where the values of the the variables that are being pivoted should go to: values_to = "body_mass".

penguins_madeup_wide %>%
  pivot_longer(
    cols = starts_with("body_mass"),
    names_to = "measurement",
    values_to = "body_mass"
  )

## # A tibble: 12 x 5
##    name       sex    tap_dance measurement body_mass
##    <chr>      <chr>  <lgl>     <chr>           <dbl>
##  1 Mumble     male   TRUE      body_mass_1      4801
##  2 Mumble     male   TRUE      body_mass_2      5699
##  3 Mumble     male   TRUE      body_mass_3      5743
##  4 Gloria     female FALSE     body_mass_1      4785
##  5 Gloria     female FALSE     body_mass_2      3092
##  6 Gloria     female FALSE     body_mass_3      4220
##  7 Memphis    male   FALSE     body_mass_1      3349
##  8 Memphis    male   FALSE     body_mass_2      4186
##  9 Memphis    male   FALSE     body_mass_3      4454
## 10 Norma Jean female FALSE     body_mass_1      4235
## 11 Norma Jean female FALSE     body_mass_2      3220
## 12 Norma Jean female FALSE     body_mass_3      4019

This is looking pretty good! But remember that the measurement variable we had mapped to the x-axis of our visualisation had the values 1, 2, and 3 (not body_mass_1, body_mass_2, and body_mass_3). We could manipulate the measurement variable with a mutate() after pivoting to remove the character string "body_mass_" from its values, but the pivot_*() functions offer additional arguments to do this sort of manipulation task at the time of pivoting. The argument we need here is names_prefix, which takes a regular expression used to remove matching text from the start of each variable name. So, let’s try again with this argument added to our pivot_longer() call.

penguins_madeup_long <- penguins_madeup_wide %>%
  pivot_longer(
    cols = starts_with("body_mass"),
    names_to = "measurement",
    names_prefix = "body_mass_",
    values_to = "body_mass"
  )

penguins_madeup_long

## # A tibble: 12 x 5
##    name       sex    tap_dance measurement body_mass
##    <chr>      <chr>  <lgl>     <chr>           <dbl>
##  1 Mumble     male   TRUE      1                4801
##  2 Mumble     male   TRUE      2                5699
##  3 Mumble     male   TRUE      3                5743
##  4 Gloria     female FALSE     1                4785
##  5 Gloria     female FALSE     2                3092
##  6 Gloria     female FALSE     3                4220
##  7 Memphis    male   FALSE     1                3349
##  8 Memphis    male   FALSE     2                4186
##  9 Memphis    male   FALSE     3                4454
## 10 Norma Jean female FALSE     1                4235
## 11 Norma Jean female FALSE     2                3220
## 12 Norma Jean female FALSE     3                4019

I think the best place to get started with the pivot_*() functions is the pivoting vignette in the tidyr package. This vignette includes both simple examples for doing the bare minimum when pivoting and more extensive examples that use most or all of the arguments that the pivoting functions offer.

Now that we have the data in the shape we want, we can recreate our visualisation.

penguins_madeup_long %>%
  ggplot(aes(x = measurement, y = body_mass, 
             group = name, color = name)) +
  geom_point() +
  geom_line()

Looking good, though not ideal… Remember the tip from the previous post in the series about reordering your legend in the same order as the data appears on your plot using fct_reorder2()? It would be a useful addition here.

penguins_madeup_long %>%
  mutate(name = fct_reorder2(name, measurement, body_mass)) %>%
  ggplot(aes(x = measurement, y = body_mass, 
             group = name, color = name)) +
  geom_point() +
  geom_line()

If you wanted to get really fancy, you can do directly label the lines with the the geom_label_repel() function from the ggrepel package. Since we only want the third measurement to be labeled, we can filter the data for that measurement and label the points with the names of penguins. While we’re at it, let’s fix up all the other labels in the plot as well.

library(ggrepel)

ggplot(penguins_madeup_long, 
       aes(x = measurement, y = body_mass, group = name, color = name)) +
  geom_point() +
  geom_line() +
  guides(color = FALSE) +
  geom_label_repel(data = penguins_madeup_long %>% filter(measurement == 3),
                   aes(label = name)) + 
  labs(
    x = "Measurement",
    y = "Body mass (g)",
    title = "Body mass measurements of penguins",
    subtitle = "Simulated data",
    caption = "Do you recognize the names of these penguins? 
    See imdb.com/title/tt0366548 for a hint!"
  )

This has quickly turned into a lesson on data visualisation, and that is a good lesson in and of itself – if you start teaching R and data science with data visualisation, which is the starting point I strongly recommend, you shouldn’t feel like you need to cover all of data visualisation before you can move on to the next topic. Often times getting your data visualisation to look a certain way is a great motivator for data wrangling and reshaping, which means that after an initial introduction to plotting basics, your data visualisation and wrangling lessons can be intertwined for a more problem-based approach to teaching.

Column-wise operations

Let’s revisit our wide penguin measurements dataset.

penguins_madeup_wide

## # A tibble: 4 x 6
##   name       sex    tap_dance body_mass_1 body_mass_2 body_mass_3
##   <chr>      <chr>  <lgl>           <dbl>       <dbl>       <dbl>
## 1 Mumble     male   TRUE             4801        5699        5743
## 2 Gloria     female FALSE            4785        3092        4220
## 3 Memphis    male   FALSE            3349        4186        4454
## 4 Norma Jean female FALSE            4235        3220        4019

Suppose you want to find the average body mass for each measurement. You can do this with dplyr::summarise(), once per each measurement.

penguins_madeup_wide %>%
  summarise(
    body_mass_1_avg = mean(body_mass_1),
    body_mass_2_avg = mean(body_mass_2),
    body_mass_3_avg = mean(body_mass_3)
  )

## # A tibble: 1 x 3
##   body_mass_1_avg body_mass_2_avg body_mass_3_avg
##             <dbl>           <dbl>           <dbl>
## 1           4292.           4049.            4609

But that’s quite tedious, especially if you had many columns you wanted to operate on. A new addition to dplyr is the across() function which makes it easy to apply the same transformation to multiple columns, allowing you to use select()semantics (e.g. starts_with(), contains()) inside summarise() and mutate().

penguins_madeup_wide %>%
  summarise(across(starts_with("body_mass"), mean))

## # A tibble: 1 x 3
##   body_mass_1 body_mass_2 body_mass_3
##         <dbl>       <dbl>       <dbl>
## 1       4292.       4049.        4609

A common task in data exploration is finding means and standard deviations for many columns at once. You can use summarise() along with across() to calculate multiple summary statistics at once as well.

penguins_madeup_wide %>%
  summarise(
    sample_mean = across(starts_with("body_mass"), mean),
    sample_sd   = across(starts_with("body_mass"), sd),
    )

## # A tibble: 1 x 2
##   sample_mean$bod… $body_mass_2 $body_mass_3 sample_sd$body_… $body_mass_2
##              <dbl>        <dbl>        <dbl>            <dbl>        <dbl>
## 1            4292.        4049.         4609             682.        1203.
## # … with 1 more variable: $body_mass_3 <dbl>

Note that I named my summary statistics with the prefix sample_ to distinguish them from the functions mean and sd. I think avoiding names that are also functions is useful for new learners, it helps them distinguish what is user input vs. what is R syntax. Unfortunately, sometimes this results in longer than desirable output.

While the code above makes it very explicit that you’re calculating two summary statistics, it is a bit repetitive and would look quite cluttered if you had to calculate many more summary statistics. Instead, you can give the functions to be applied across the columns as a named list.

penguins_madeup_wide %>%
  summarise(across(
    starts_with("body_mass"),
    list(sample_mean = mean, sample_sd = sd)
  ))

## # A tibble: 1 x 6
##   body_mass_1_sam… body_mass_1_sam… body_mass_2_sam… body_mass_2_sam…
##              <dbl>            <dbl>            <dbl>            <dbl>
## 1            4292.             682.            4049.            1203.
## # … with 2 more variables: body_mass_3_sample_mean <dbl>,
## #   body_mass_3_sample_sd <dbl>

A nice data wrangling exercise to give students at this point would be to reshape this output to look like the following.

## # A tibble: 3 x 3
##   measurement sample_mean sample_sd
##   <chr>             <dbl>     <dbl>
## 1 1                 4292.      682.
## 2 2                 4049.     1203.
## 3 3                 4609       777.

You can also use across() along with mutate(). Remember that name and sex variables were characters. Suppose we want to convert both of them to factors.

penguins_madeup_wide %>%
  mutate(across(where(is.character), as.factor))

## # A tibble: 4 x 6
##   name       sex    tap_dance body_mass_1 body_mass_2 body_mass_3
##   <fct>      <fct>  <lgl>           <dbl>       <dbl>       <dbl>
## 1 Mumble     male   TRUE             4801        5699        5743
## 2 Gloria     female FALSE            4785        3092        4220
## 3 Memphis    male   FALSE            3349        4186        4454
## 4 Norma Jean female FALSE            4235        3220        4019

Note that across() supersedes the family of scoped variants like summarise_if(), mutate_if(), summarise_all(), etc. While these functions will continue to be supported, if you are teaching data wrangling in 2020, it’s best to feature across() instead. You can learn more about across() and column-wise operations with dyplyr in general in the column-wise operations vignette.

Row-wise operations

A common data preparation task where multiple measurements have been taken on a subject is averaging these measurements. In the example we’ve been working with, this would mean averaging the three body mass measurements for each penguin and reporting this as an additional column in the data frame.

penguins_madeup_wide

## # A tibble: 4 x 6
##   name       sex    tap_dance body_mass_1 body_mass_2 body_mass_3
##   <chr>      <chr>  <lgl>           <dbl>       <dbl>       <dbl>
## 1 Mumble     male   TRUE             4801        5699        5743
## 2 Gloria     female FALSE            4785        3092        4220
## 3 Memphis    male   FALSE            3349        4186        4454
## 4 Norma Jean female FALSE            4235        3220        4019

There are many ways of accomplishing this task in R, but the one that I think is the most intuitive is using the rowwise() and c_across() functions in dplyr.

penguins_madeup_wide <- penguins_madeup_wide %>%
  rowwise() %>%
  mutate(body_mass_avg = mean(c_across(starts_with("body_mass"))))

penguins_madeup_wide

## # A tibble: 4 x 7
## # Rowwise: 
##   name       sex    tap_dance body_mass_1 body_mass_2 body_mass_3 body_mass_avg
##   <chr>      <chr>  <lgl>           <dbl>       <dbl>       <dbl>         <dbl>
## 1 Mumble     male   TRUE             4801        5699        5743         5414.
## 2 Gloria     female FALSE            4785        3092        4220         4032.
## 3 Memphis    male   FALSE            3349        4186        4454         3996.
## 4 Norma Jean female FALSE            4235        3220        4019         3825.

There are other ways of finding row means in R, e.g. rowMeans(), but one nice aspect of this approach is that it’s extensible to any function, e.g. let’s find row medians instead of row means.

penguins_madeup_wide %>%
  rowwise() %>%
  mutate(body_mass_median = median(c_across(starts_with("body_mass"))))

## # A tibble: 4 x 8
## # Rowwise: 
##   name  sex   tap_dance body_mass_1 body_mass_2 body_mass_3 body_mass_avg
##   <chr> <chr> <lgl>           <dbl>       <dbl>       <dbl>         <dbl>
## 1 Mumb… male  TRUE             4801        5699        5743         5414.
## 2 Glor… fema… FALSE            4785        3092        4220         4032.
## 3 Memp… male  FALSE            3349        4186        4454         3996.
## 4 Norm… fema… FALSE            4235        3220        4019         3825.
## # … with 1 more variable: body_mass_median <dbl>

You can learn more about rowwise() and row-wise operations with dyplyr in general in the row-wise operations vignette.

Grouped summaries

One of the most attractive features of dplyr is easily obtaining grouped summaries by chaining together group_by() and then summarise(). Let’s use this workflow to calculate average body masses by sex and by whether or not the penguin tap dances (ok, this is not going to make sense if you haven’t seen Happy Feet).

penguins_madeup_wide %>%
  group_by(sex, tap_dance) %>%
  summarise(avg_bm = mean(body_mass_avg))

## `summarise()` regrouping output by 'sex' (override with `.groups` argument)

## # A tibble: 3 x 3
## # Groups:   sex [2]
##   sex    tap_dance avg_bm
##   <chr>  <lgl>      <dbl>
## 1 female FALSE      3928.
## 2 male   FALSE      3996.
## 3 male   TRUE       5414.

There is nothing new in this code, but the message "summarise() regrouping output by sex (override with .groups argument)" is new, so you might have code in your teaching materials that didn’t produce this message before that now does. If you carefully look at the output you will see that the data are still grouped by sex. This behaviour has not changed, but previously wasn’t highlighted with a message, which often caused confusion for users. If you want to turn off the message, you need to decide on grouping behaviour and explicitly state this decision in a new argument in summarise(): .groups. Your options are "drop_last" (drop last level of grouping, default behaviour), "drop" (all groups are dropped), "keep" (keep grouping same as the input data for the function), "rowwise" (make each row its own group). For example, if you don’t want your data to be grouped at the end of this pipeline, you would used the "drop" option.

penguins_madeup_wide %>%
  group_by(sex, tap_dance) %>%
  summarise(avg_bm = mean(body_mass_avg), .groups = "drop")

## # A tibble: 3 x 3
##   sex    tap_dance avg_bm
##   <chr>  <lgl>      <dbl>
## 1 female FALSE      3928.
## 2 male   FALSE      3996.
## 3 male   TRUE       5414.

To learn more about this behaviour and the reasoning behind the changes, see here. If you are teaching new R users, I don’t think there is a good reason to go into the history of the message, and hopefully this message will steer new learners to be deliberate about how they use groups, as opposed to stumble into results without intentional grouping.

That’s all I have on teaching data wrangling and tidying in 2020. We have one post left in the series: “When to purr?” 🐈.

Teaching the Tidyverse in 2020 - Part 2: Data visualisation

Wed, 15 Jul 2020 00:00:00 +0000

This is the second blog post in the “Teaching the Tidyverse in 2020” series. The first post was on getting started, and today our focus is data visualisation. In this post, I’ll highlight some new(ish) features of ggplot2 as well as not-so-new features that I see rarely in introductory teaching materials that I think belong there.

Let’s start by loading the tidyverse and palmerpenguins packages.

library(tidyverse)
library(palmerpenguins)

We’ll be using the penguins data from the palmerpenguins package. You can read about the variables in the data frame here and a quick peek is provided below.

glimpse(penguins)

## Rows: 344
## Columns: 7
## $ species           <fct> Adelie, Adelie, Adelie, Adelie, Adelie, Adelie, Ade…
## $ island            <fct> Torgersen, Torgersen, Torgersen, Torgersen, Torgers…
## $ bill_length_mm    <dbl> 39.1, 39.5, 40.3, NA, 36.7, 39.3, 38.9, 39.2, 34.1,…
## $ bill_depth_mm     <dbl> 18.7, 17.4, 18.0, NA, 19.3, 20.6, 17.8, 19.6, 18.1,…
## $ flipper_length_mm <int> 181, 186, 195, NA, 193, 190, 181, 195, 193, 190, 18…
## $ body_mass_g       <int> 3750, 3800, 3250, NA, 3450, 3650, 3625, 4675, 3475,…
## $ sex               <fct> male, female, female, NA, female, male, female, mal…

Making a single box

At some point in ggplot2 history, making a box plot of a single variable required adding factor = 1 to the aesthetic mapping, which I never found to be easy to explain.

ggplot(penguins, aes(y = body_mass_g, factor = 1)) +
  geom_boxplot()

You can now (or more like for the last couple years!) omit factor = 1!

ggplot(penguins, aes(y = body_mass_g)) +
  geom_boxplot()

No more `coord_flip()`

Horizontal bar plots can be really useful, especially for categorical data whose levels have long names that overlap if placed on the x-axis. Previously, making horizontal bar plots required mapping the variable to be plotted to the x aesthetic and then applying a coord_flip() layer to flip the axes, e.g.

ggplot(penguins, aes(x = species)) +
  geom_bar() +
  coord_flip()

geom_bar() now works in both directions, so the categorical variable can be directly mapped to the y aesthetic to achieve the horizontal box plot.

ggplot(penguins, aes(y = species)) +
  geom_bar()

You can read more about what this change enables in other geoms here.

Leverage scales and forcats

One of the biggest strengths of ggplot2 is that it has fantastic defaults and your plots look pretty good without trying hard. This is very attractive especially for teaching introductory audiences when you just want to focus on the basics. However, when teaching data visualisation (even in the simplest sense) it is important to discuss data visualisation good practices, e.g. present data in ascending/descending order, label axes in a way that matches your narrative, etc. Packages like scales and forcats are incredibly helpful for implementing these small but impactful improvements to visualisations.

Suppose we want to plot the percentage distribution of different species of penguins. We can first calculate these percentages in a dplyr pipeline.

penguins %>%
  count(species) %>%
  mutate(prop = n / sum(n))

## # A tibble: 3 x 3
##   species       n  prop
##   <fct>     <int> <dbl>
## 1 Adelie      152 0.442
## 2 Chinstrap    68 0.198
## 3 Gentoo      124 0.360

We can then feed the result to the ggplot() function to be represented using geom_col().

penguins %>%
  count(species) %>%
  mutate(prop = n / sum(n)) %>%
  ggplot(aes(x = prop, y = species)) +
  geom_col()

First, let’s reorder the bars in descending order, with the penguin species with the highest proportion on top. We use fct_reorder() function from the forcats package for this. We can read fct_reorder(species, prop) as “reorder the levels of species based on the values of prop”.

penguins %>%
  count(species) %>%
  mutate(prop = n / sum(n)) %>%
  ggplot(aes(x = prop, y = fct_reorder(species, prop))) +
  geom_col()

The forcats package contains a variety of functions starting with the prefix fct_ that operate on factor levels. Perhaps unsurprisingly, they’re named pretty intuitively (at least for English speakers). (Side note: After fct_reorder(), my favourite function for improving visualisations of messy survey data with factors with many levels is fct_lump().)

Next, let’s think about how we would interpret this visualisation. I would probably say something like “Adelie penguins make up over 40% of the sample, followed by Gentoo penguins at roughly over 35%, and Chinstrap penguins make up the remaining 20%". But the x-axis is showing proportions instead of percentages.

The scales package offers a variety of functions, starting with the prefix label_* that help with this sort of task.

library(scales)

The function we want here is label_percent(). We can also specify the number of decimal places to show with the accuracy argument.

penguins %>%
  count(species) %>%
  mutate(prop = n / sum(n)) %>%
  ggplot(aes(x = prop, y = fct_reorder(species, prop))) +
  geom_col() +
  scale_x_continuous(labels = label_percent(accuracy = 1))

And finally, let’s fix up the axis labels.

penguins %>%
  count(species) %>%
  mutate(prop = n / sum(n)) %>%
  ggplot(aes(x = prop, y = fct_reorder(species, prop))) +
  geom_col() +
  scale_x_continuous(labels = label_percent(accuracy = 1)) +
  labs(
    x = "Percentage",
    y = "Species",
    title = "Species distribution of penguins",
    subtitle = "Adelie, Gentoo, and Chinstrap Penguins at Palmer Station LTER",
    caption = "Source: allisonhorst.github.io/palmerpenguins"
  )

Another very attractive feature of ggplot2 is that you get legends for free. But sometimes the factor levels displayed in the legends may not be optimally ordered. In these cases fct_reorder2() might be helpful. See this gist from Jenny Bryan for an example using this function to reorder levels displayed on a legend of a line plot.

ggplot2 is a vast package, and I don’t think it’s feasible to teach the complete functionality of the package within an intro stats or data science curriculum. That being said, I think it is important to not just teach how to make plots, but how to make good plots that follow data visualisation best practices. Leveraging packages like forcats and scales allows you to do that without adding too much cognitive burden on the learners.

The rest of the gg-verse

There are many packages that extend ggplot2 (e.g. gganimate, ggridges, ggrepel, GGally) and just like it’s not possible to cover all of ggplot2 in an intro course, it’s definitely not possible to cover the entire gg-verse. However, it is useful to introduce your students to some of these packages so they are aware of the existence of the larger ecosystem.

A particularly good place to start is when you find a pain point with ggplot2 and the solution is using one of these other packages (e.g. ggrepel for labelling data points on a plot without overlapping text).

Another good approach for introducing these packages are assignments where students independently explore packages you haven’t explicitly taught them. I like doing this using the following two assignments:

You gotta pick a package or two: Provide a list of fun and/or easy to onboard packages and ask students to read the package documentation and use the package to do something.
Mirror, mirror on the wall, who’s the ugliest of them all? I got the idea for this assignment Give a simple plot and ask students to make the plot as ugly as possible. I like doing this with a disclaimer that says “I realize that ugly is subjective, so we’re mostly looking to see if you can figure out how to change the look of a plot using help files of functions you haven’t learned before. As you do, try to make your plot as visually unappealing as possible.“I got the idea for this assignment from Drew Steen, who shared on Twitter sample student plots that are, well, awful, in the best way possible. Alison Horst also has a lovely blog post where she shares her experience with a similar assignment here.

You can find a more detailed write up of these assignments here.

That’s it for today, next up on the “Teaching the Tidyverse in 2020” series is data wrangling and tidying.

Upcoming changes to RStudio Cloud pricing

Tue, 14 Jul 2020 00:00:00 +0000

RStudio Cloud spans across multiple teams at RStudio, so this is a joint post from the RStudio education, marketing, and Cloud teams.

After an extensive alpha/beta period, RStudio Cloud will be generally available for use and purchase in the fall. If you are not familiar with RStudio Cloud, it is a managed cloud instance of the RStudio IDE. For educators, this means you and your learners can use the RStudio IDE directly from your browser - there is no software to install and nothing to configure on your computer.

While RStudio Cloud will always offer a free plan for individuals, beginning August 3, 2020, we will also offer paid premium plans for individuals, instructors, and organizations. At RStudio, we’re committed to supporting educators using R. That is why we offer our professional products for free. We’d love to also make RStudio Cloud free for everyone, but unfortunately RStudio Cloud is fundamentally different from our other professional products because it is not just software, but also computing. During the beta period, we provided 3.5 million hours of compute time for free. Unfortunately, we just can’t afford to keep doing that — we need to cover our ongoing hosting costs so that we can continue to offer the service. In short: the fees help us offset the cost of operating the service, and enable us to continue to provide a free plan for individuals.

What are my options for teaching?

The monthly pricing plans are available at https://rstudio.cloud/plans/. Typically, your learners will sign up for the Cloud Free Plan, and you as an educator will shoulder all the costs for your learners (called “members” in the plans). Here, we break down your options with a focus on teaching classes or workshops:

Cloud Free Plan: You can have one shared space at a time, with up to 5 learners and up to 15 total projects in the shared space. You and your learners will need to be able to do all the work in the cloud needed in 15 project hours per month. With the max of 5 learners, this would add up to about 2.5-3 compute hours per person (there are additional restrictions on CPU and RAM). This plan is best-suited for educators who offer short, small group trainings that are spaced a month apart.
The next plan up does not have any restrictions on the number of spaces, learners, or projects, and there is more CPU and RAM available. You do have 160 included project hours to divvy up now between learners instead of 15, although you’ll likely need to add even more. Any usage over 160 hours would be added on at 20¢/hour. Pricing for this plan depends on a few factors:
- If you are not a qualified instructor¹ or an RStudio Certified Instructor, this is called a Cloud Premium Plan and starts at \$99/month. However, discounted plans range from \$25-\$50/month, so be sure to check to see if your organization falls into one of the discounted categories listed at the bottom of the plan page.
- If you are a qualified instructor (either teaching at an accredited institution that meets certain qualifications¹, or you are an RStudio Certified Instructor), this is called a Cloud Instructor Plan and starts at \$15/month.
If you want to avoid overage charges, this plan is probably best-suited for folks who offer single or multi-day workshops about once a month, or educators who want to start off using the Cloud, but then transition learners to working locally inside the RStudio IDE.
Custom Cloud Instructor Plan: If you are teaching multiple workshops in a month or a quarter/semester length course, you are likely looking at burning through those 160 included project hours pretty quickly and are probably worried about racking up overage charges. For example, in a typical 3-credit course, you may expect learners to log upwards of 10 hours per week. This would mean you could only have 4 learners—which is probably not a realistic scenario. If you don’t want any surprises, an alternative plan is to sign up for a fixed price per class for both instructors and learners with no usage overage fees. With this plan, you will need to request a quote. Tell us how many learners you will have, and for how long, and we can give you a custom quote for the entire cost.
Cloud Organization Plan: All of the above options are great for individual educators, but if you are a member of a larger group, an organization plan is a good option for getting Cloud access to a bunch of users within a department, university, or a commercial organization. This plan grants all organization users Cloud Premium features, plus Single Sign On integration via SAML, so that users can log into Cloud using their organization credentials. This plan is also a good option if you would like a site license for your organization. You will also need to request a quote for this plan.

What about options for learners?

In most cases, your learners can rely on the Cloud Free Plan. If you as the educator opt for any of the paid plans:

Learners work off of project copies in your shared space. When you create a project in your shared space as an assignment, learners make a copy to work from, but the projects stay in the shared space. This means that the limit on the number of projects in the free plan (15) will not kick in unless a learner manually moves their projects out of the shared space and into their personal space.
Similarly, when learners accumulate project hours, those apply to your shared space. All learner project hours count toward your 160 project hours on a paid plan (unless you are using a Custom Cloud Instructor Plan). This means that the limits on the number of project hours in the free plan (15) will not kick in unless a learner manually moves their projects out of the shared space and into their personal space.

Questions & feedback

If you have any questions about RStudio Cloud pricing, please contact sales@rstudio.cloud.

Visit the RStudio Cloud community page at https://community.rstudio.com/c/rstudio-cloud to ask questions, provide feedback, and interact with other RStudio Cloud users.

Thank you to all members of the R community who have used and provided feedback about RStudio Cloud. We are aware that budgets are very tight, particularly at this time. We will continue to do what we can to make Cloud as affordable as possible for instructional use. We will also continue to add important features and improve performance, reliability, and availability of RStudio Cloud.

To view the list of qualifications, scroll down to bottom of this page. ↩︎

Teaching the Tidyverse in 2020 - Part 1: Getting started

Mon, 13 Jul 2020 00:00:00 +0000

The “official” tidyverse has existed since 2016 but most of its components have a much longer history, for example ggplot2 is the older package and has been around for more than 13 years! The tidyverse continues to evolve and some of the recent updates to tidyverse packages are specifically designed to make it easier for new learners to get started with doing data science in R. Whether you’ve been teaching the tidyverse for years or you’re new to it, it’s useful to periodically catch up with what’s new in the tidyverse.

This week’s theme on the blog is “teaching the tidyverse in 2020” and we will be covering it in four blog posts throughout this week: (1) Getting Started, (2) Data visualisation, (3) Data wrangling and tidying, and (4) When to purrr?

In each of the posts we will highlight recent updates to the tidyverse that educators might want to have on their radar, sprinkled with suggestions for incorporating them into your teaching.

A few housekeeping items before we get started:

This series of blog posts, and especially this first one, assumes that you are an educator who is teaching R at the introductory level to students who are new to statistics, data science, R, and/or programming in general. Some of the tips in the upcoming posts will be useful for more advanced courses as well, but this first post post is, well, exactly as its name suggests, is most useful for audiences that are just getting started.
For many of the code examples I will use the penguins dataset from the awesome palmerpenguins package. So let’s go ahead and load it.

# devtools::install_github("allisonhorst/palmerpenguins")
library(palmerpenguins)

Let’s get started!

So, what is the tidyverse?

The tidyverse is an opinionated collection of R packages designed for data science. All packages share an underlying design philosophy, grammar, and data structures. [Source]

If you’re a tidyverse user and/or an avid reader of this blog, you probably already know this. But how about your students? Do these words mean anything to your students the first time they hear them? How do you introduce your students to the tidyverse, especially if they are also new to R?

Start with the core packages

Start with the core packages, by briefly stating the primary purpose of each, in the order that students will encounter them in your course, e.g.

ggplot2: data visualisation
dplyr: data wrangling
readr: reading data
tibble: modern data frames
stringr: string manipulation
forcats: dealing with factors
tidyr: data tidying
purrr: functional programming

This is the order I recommend and the order that follows the curriculum outlined in Data Science in a Box. Start with visualisation (ggplot2) and delay introducing functional programming (purrr) until later. (More on why and how to delay introducing purrr in the last post in the series!)

I like introducing the tidyverse with a visual showcasing the pretty hex logos. I cannot say that this necessarily adds to student learning, but it sure draws students in!

Figure 1: Hex logos for the eight core tidyverse packages and their primary purposes.

The important thing to note here is that I don’t recommend bringing up the non-core packages, i.e. those installed with the tidyverse, but not loaded along with it. Regardless of the level at which you’re teaching, chances are you won’t be using all of those packages in a single course. I recommend introducing other packages used in your course (whether they are a part of the tidyverse or not) as they become relevant to the topic you’re covering, and simply highlight that the packages from the wider tidyverse share the design philosophy, grammar, and data structures as the core packages, e.g. the rvest package for web scraping plays nicely with pipes.

Use `library(tidyverse)`

Load all packages with library(tidyverse) instead of loading the core packages individually. This is especially useful if you are taking the “let them eat cake first” approach and presenting interesting and complex examples on day one of the course. It also means that your students need to only remember the name of one package, as opposed to multiple packages.

You would, of course, want to mention the names of individual packages that make up the tidyverse as you teach specific topics that are best solved with those packages (e.g. provide a proper introduction to ggplot2 when teaching data visualisation and to stringr when teaching string manipulation) but library(tidyverse) will allow you to harness all that the tidyverse has to offer at once, without having to provide a lengthy introduction to each package on the first day of class.

A useful side-effect of this is that you get access to the few functions in the tidyverse meta package. The tidyverse_sitrep() function (which gives a situation report on the tidyverse packages, i.e. a list of all installed tidyverse packages and their versions) and the tidyverse_update() function (which updates all tidyverse packages) can be useful when debugging code, especially if a student is getting output that looks different than yours after running the same lines of code.

Review the package loading message

When you load the tidyverse package, it prints out the following message:

library(tidyverse)

## ── Attaching packages ──────────────────────────────────────── tidyverse 1.3.0 ──

## ✓ ggplot2 3.3.2     ✓ purrr   0.3.4
## ✓ tibble  3.0.3     ✓ dplyr   1.0.0
## ✓ tidyr   1.1.0     ✓ stringr 1.4.0
## ✓ readr   1.3.1     ✓ forcats 0.5.0

## ── Conflicts ─────────────────────────────────────────── tidyverse_conflicts() ──
## x dplyr::filter() masks stats::filter()
## x dplyr::lag()    masks stats::lag()

I recommend explicitly addressing this message in your teaching.

I think this is the hardest step of them all, because really understanding some of this requires understanding package versions, name spaces, and the :: operator, none of which are things I like to get into in the first 10 minutes of a class. At the same time, ignoring messages/warnings/errors is also not a habit I like to model.

My suggestion is to

suppress package loading messages on the first day activity, which is straightforward if students start off with a template R Markdown document that you prepared, where the chunk where you load tidyverse has message = FALSE set, and then
starting on the second module/day of class go through what the message means in full, with assurances to students that they don’t need to “worry” about it, but it’s worth for them to see it.

A good point in the class to come back to this message is when introducing dplyr::filter(), which tends to be early on in an introductory data science or statistics course. You can run the filter() command without loading the tidyverse package and ask students to guess what the error means.

For example, let’s try to filter for penguins whose species is Chinstrap, without loading the tidyverse. And assume for a second that you are running the following code in a fresh R session, prior to loading the tidyverse package.

penguins %>%
  filter(species == "Chinstrap")

## Error in filter(., species == "Chinstrap"): object 'species' not found

The error is confusing because we know there is a variable called species in the penguins dataset.

If you have already reviewed the tidyverse package loading message earlier in your class, you can now ask students to guess why they might be getting this error. This is a good opportunity to review the message and also an opportunity to clarify why it’s OK to not worry about the message if what you want to do is to use functions from the tidyverse.

Now, let’s try again, this time with the tidyverse package loaded.

library(tidyverse)
penguins %>%
  filter(species == "Chinstrap")

## # A tibble: 68 x 7
##    species island bill_length_mm bill_depth_mm flipper_length_… body_mass_g
##    <fct>   <fct>           <dbl>         <dbl>            <int>       <int>
##  1 Chinst… Dream            46.5          17.9              192        3500
##  2 Chinst… Dream            50            19.5              196        3900
##  3 Chinst… Dream            51.3          19.2              193        3650
##  4 Chinst… Dream            45.4          18.7              188        3525
##  5 Chinst… Dream            52.7          19.8              197        3725
##  6 Chinst… Dream            45.2          17.8              198        3950
##  7 Chinst… Dream            46.1          18.2              178        3250
##  8 Chinst… Dream            51.3          18.2              197        3750
##  9 Chinst… Dream            46            18.9              195        4150
## 10 Chinst… Dream            51.3          19.9              198        3700
## # … with 58 more rows, and 1 more variable: sex <fct>

Et voilà! This is looking much better.

Help them get help

Anatomy of R help docs

R comes with built in help documents. And they tend to be pretty thorough. But they are not always easy to digest, especially if you haven’t seen them before. Kieran Healy has a very nice example of an annotated R help page. I strongly recommend showing this, or better yet, a similarly annotated page for the first help document that you show in your class. It is also useful to tell students not just what’s on the help document, but how to read it. Many R help documents have a lot of technical information between the description and the examples, and usually it’s best to look at those two sections first, before diving deeper into the rest of the documentation. Skipping sections and scrolling to the bottom of the document won’t come naturally to your students, it’s a behaviour you want to model and narrate a few times, early on in your course.

Walkthrough of package pages

Each tidyverse package has a website at [PKGNAME].tidyverse.org (e.g. dplyr.tidyverse.org, ggplot2.tidyverse.org). The functions in each package are in the Reference tab, and this is worth pointing out to new learners. It is also worth pointing out that while the content of the function documentation on package websites mirrors the content in the help documents you can get in R with ?function, the package website shows the output of the code in the examples. It can be a lot more efficient (and pleasant) to browse the documentation pages on the web, especially for plotting functions where documentation clearly shows which function you need to use to get your plot to look a certain way.

Googling for help

Googling how to do something is obvious, but it’s not always obvious how best to Google for help. Appending the search phrase with “tidyverse” is almost always helpful for tidyverse specific help, but not always obvious to new learners.

Figure 2: Search results for 'how to make a boxplot in R' with and without 'tidyverse' appended to the search phrase.

Make time for reprex

What is a reprex? It’s a reproducible example, as coined by Romain Francois. It’s also the name of the package that creates runnable code and output based on R code on the clipboard. Teaching your students how to make reprexes will have an immense payoff for them (and for you, as you try to help them). However making repexes is not trivial for beginners. It’s especially not easy for students learning R starting with an R markdown document as opposed to an R script. This means you should make time in class to teach how to make a reprex, through live coding demos (or narrated screencasts) a few times. If you use an online discussion forum for questions (or if your students email their questions to you), you might need to coach them through making reprexes the first few times they try. Learning how to make a reprex will empower your students to ask good questions, or better yet, help them answer their own questions as they develop the reprex.

Provide background

I strongly recommend assigning (or at least suggesting) the following papers as reading early on in your course.

Wickham, Hadley, et al. “Welcome to the Tidyverse." Journal of Open Source Software 4.43 (2019): 1686.
Wickham, Hadley. “Tidy data." Journal of Statistical Software 59.10 (2014): 1-23.

These papers give insight into the underlying scholarship and the intellectual history underpinning these tools and their development. The first paper (Welcome to the Tidyverse) can be assigned at the beginning of the course, as you introduce the tidyverse. I would recommend holding off on assigning the second paper (Tidy data) until you introduce the not just the concept of tidy data but also tools for tidying data (i.e. functions from the tidyr package).

Instructor Certification Findings

Mon, 06 Jul 2020 00:00:00 +0000

We recently surveyed people who have taken part in our instructor training and certification program during the past 18 months. 92 people responded, and as the figures below show (on a 1-5 Likert scale), most seemed to think it useful, though actual adoption lags a little behind enthusiasm:

Figure 1: How much of what you learned in the training class have you found useful?

Figure 2: How much of what you learned in the training class have you applied in your training?

Figure 3: How satisfied are you with the certification program overall?

Perhaps the most important thing is that our net promoter score is 77, which makes us pretty happy:

Figure 4: How likely are you to recommend this workshop to your friends and collagues?

Qualitative results

We also asked several open-ended questions. Some people gave multiple answers for each, while others skipped some or all of them, but some patterns did emerge.

What did you like best and/or find most useful?

The ten most common responses (in order) were:

Learner personas
Concept maps
Formative assessment
Online teaching methods
Reverse instructional design
Cognitive load
Parsons Problems
Faded examples
Format of training course
Summative assessment

Personas and concept maps are the first two topics we introduce, but that doesn’t necessarily imply people are choosing them because of that: we put them first in order to demonstrate value early.

What did you like least and/or find least useful?

Only eight items were mentioned more than once:

Concept maps (people either love ‘em or hate ‘em)
Course as a whole too short
Online format
Lack of tips for online/asynchronous teaching
Time of day
No explicit coverage of Tidyverse/Shiny exam material
Material on psychology of learning not new
Sessions too long

We’re going to add more material about online teaching starting in July based on these three webinars. It will mean lengthening the class by an hour, but under the current circumstances, it seems essential

What else do you think we should know about the program and how to improve it?

There was even more spread here—only five things were mentioned more than once:

More guidance about exam content (now addressed by providing sample exams)
More tidyverse-specific content
Refresher seminars and other follow-up
More about online teaching (see the comment in the previous section)
Spread the course out and take more time on each part

Regarding the last point, we’ve asked in the past about running the class as four blocks of two hours rather than two half-day blocks. People seem to like the idea in theory, but when the time comes to put it in their calendar, they seem to find the latter easier to manage.

One random finding

Finally, we asked the certified instructors whether their dplyr pipelines use filter then select, or select then filter:

Response	Count
filter then select	37
select then filter	24
mixed/never really thought about it	34

We have many theories for this, but on reflection, have decided that some things in life should remain a mystery.

Accessibility Internship

Thu, 02 Jul 2020 00:00:00 +0000

As I am now halfway through my internship, I would like to share my work and experience.

Internship Projects for Accessibility

From a general viewpoint, I am working on accessibility improvements to make RStudio products usable to a wider range of people with (dis)abilities. I am a part of the RStudio IDE team under the mentorship of Gary Ritchie where I can focus on the RStudio Desktop and Server accessibility.

As a blind R user and developer myself, I found most of the existing data science IDEs inaccessible to assistive technology (e.g., text-to-speech screen readers and refreshable Braille displays) so it had been one of my high hopes to have a reasonably usable toolbox ¹. This unmet need motivated me to apply for the internship program to turn my challenges into ways of RStudio IDE more accessible, not only for myself, but also for those with varying degrees of abilities.

For the past month, I worked closely with Gary to identify and address some critical usability issues in the RStudio Server with special focus on keyboard and screen-reader access. Due to some complex technical issues ², we made the Server version our priority while aiming at a smooth transition towards the Desktop version. As a result, we made meaningful progress in the latest RStudio release, version 1.3, which supports improved accessibility options for keyboard and/or assistive technology users. As a part of this project, I have written technical articles on how to use RStudio Server with screen readers and how to run the RStudio Server on Windows via WSL2.

Besides the accessibility project for RStudio IDE, I have been also involved in Shiny team since June to make its interface more keyboard navigable and screen-reader-friendly. As Shiny currently lacks accessible components, I have been fixing each widget to meet accessibility standards. This project is ongoing and I plan to share my experiences in detail later on.

What I Have Learned and What’s Next

This internship has taught me two important things so far. First, at a personal level, I have learned that data science and software engineering are not far-fetched for a blind person even for collaborative work. Fortunately, most of the communication tools used at RStudio, such as Slack, GitHub, and Zoom, have been reasonably usable, so I have been able to collaborate with other senior engineers on GitHub including pull requests, code reviews, and issue tracking without noticeable challenges. What’s more, I have been enjoying chatting with other RStudio employees (with emoticons, of course :) ) via Slack and Zoom with minimal accessibility barriers. This implies a person’s abilities are limited by a tool’s accessibility level rather than their physical or sensory difficulties.

Second, at a community level, I have also learned how beneficial my work with RStudio would be to other people with a wide range of abilities. What makes me push myself forward is that I have received a great deal of positive feedback from many people highlighting the importance of my role at RStudio this summer. I am very grateful that I can be a part of the meaningful changes towards a more inclusive data-science ecosystem—my contribution here can improve many individuals’ lives across academia and the industry.

Thank you to everyone at RStudio and elsewhere for supporting my most memorable internship throughout this summer—I look forward to what’s next.

Due to this technical limitation, I have been using and developing R packages via the out-of-the-box R Term and R CMD BATCH without any aid from editors. ↩︎
Those who wonder about the technical details of the issues can refer to this discussion. ↩︎

Learning learnr

Wed, 01 Jul 2020 00:00:00 +0000

“Let us change our traditional attitude to the construction of programs: Instead of imagining that our main task is to instruct a computer what to do, let us concentrate rather on explaining to human beings what we want a computer to do.”

– Donald Knuth, Literate Programming (1984)

Data scientists engage in and develop tools for literate programming. A variant of Markdown called R Markdown has provided the foundation for several R packages to assist in writing books ( bookdown), blogs/websites ( blogdown, hugodown), scientific reports for the web ( distill) and presentations ( xaringan). The trend with these packages and tools is to take the base R Markdown document and extend it to provide a powerful way to write documents in a simple Markdown format, yet be able to embed complex mixed media such as code, images, videos, and interactive elements to better suit the type of artifact the user wants to create. But, there is yet another level of literate programming that is now possible for instructors who want to make interactive lessons thanks to the learnr package.

For my summer internship, Alison Hill and Greg Wilson initially tasked me with building Python lessons using the learnr package with the caveat that some infrastructure will need to be built. My journey involved a lot of reading and tracing code, as well as consulting Barret Schloerke, who provided me both knowledge about the trees and the forest of learnr. I started making diagrams to describe the architecture and execution flows, and this diagramming activity became a wonderful tool to identify my gaps of knowledge. Every time I came back to my diagrams, I had new knowledge to incorporate, which again opened up new gaps I needed to fill. In this post, I’d like to show you what I’ve learned so far and how I formed a working knowledge of this intricate package; if you’d like to know more about its specific features, please see this post from my fellow intern Ezgi. In the end, I hope to convey the big picture of learnr and the technologies it combines for interactive lessons.

What is learnr?

learnr’s documentation says that:

The learnr package makes it easy to turn any R Markdown document into an interactive tutorial.

For the rest of the post, we’ll refer to the following example of a learnr document called addition.Rmd that only includes an exercise and its hint/checking counterparts. Exercise handling is what I am most familiar with so I won’t cover how questions are handled.

If you have used the base R Markdown, you will be familiar with components such as the YAML header, the setup code, and the knitr code chunks (the triple back-quoted elements). However, the red highlights shown here are the parts where learnr starts to diverge and extend R Markdown in the following ways:

The output is a learnr::tutorial.
The runtime is shiny_prerendered.
There are some learnr-related setup code.
There are knitr chunks which have custom options such as exercise.

These 4 main differences sets learnr apart from the R Markdown that you are probably more familiar with and I’ll refer to these in the next section covering the overall architecture of the package.

Architecture of learnr

“It’s a dangerous business, Frodo, going out your door… You step into the Road, and if you don’t keep your feet, there is no knowing where you might be swept off to.”

– Bilbo Baggins

learnr combines many tech stacks, making it a difficult package to understand and traverse. However, I found a simple way to think about the package that might help you better grasp the technologies involved. learnr can broken down into two main parts: tutorial creation and tutorial interaction. These two parts allowed me to mentally organize how learnr is working under the hood as well as navigate associated R files involved in each part. This was also a pragmatic approach so I could make extensions to the code only where needed. Here is a high level view of these two parts and the technologies involved:

The rmarkdown and knitr packages process and render the document, relying on learnr to extend behavior around knitr chunks and handle question- and exercise-related information. The interactivity is possible on the frontend using the familiar combination of HTML, CSS, and JS. But, there are also a few third-party JS dependencies like the Ace editor, which is an important one because it provides the editor for exercises. The backend R code mainly consists of http handlers responding to stateful events like “Next Topic” and “Start Over”. There is also R code using Shiny for handling events related to evaluating questions and exercises in response to events such as clicking the “Run” button.

From the document perspective, all you need to really know is that learnr turns your Rmd file into an HTML file using pandoc, which I like to think of as the bridge from the tutorial creation to the tutorial interaction side. At this point, you may skip to my reflections on learning learnr so far. But, those who are curious may continue to the nitty-gritty details of what’s really going on under the hood for each side.

Tutorial creation

After you hit “Run document” in RStudio, learnr does some prep work and takes your addition.Rmd file and uses rmarkdown and knitr to process and shape the final document. You can think of R Markdown as “running the show” because it is responsible for rendering the entire Rmd from end-to-end with the help of learnr. learnr helps R Markdown by specifying the custom output via learnr::tutorial, which is a souped-up HTML document. learnr also helps R Markdown by processing the Rmd file and adding code chunk extensions not normally present in regular Rmd files. Finally, learnr uses gradethis to check results for exercises. Before we jump to the interaction side, let’s briefly talk about some details on initialization.

Package and Shiny server initialization

learnr has two main jobs to do before we move on to the interaction side: apply custom behavior for exercises and setup up the Shiny server. Roughly this is what that process looks like:

The knitr package is used by learnr to add the magic of exercises and its support chunks via custom knitr hooks (knitr-hooks.R) that activate during rendering. These custom knitr hooks process the exercises and its options (for e.g., exercise=TRUE) as well as their associated support chunks using label suffixes like -setup for setup code, -check and -solution chunks for checking answers. During this process, learnr creates Shiny prerendered chunks for each code chunk to be included in the HTML document. Finally, learnr has to register http handlers for handling events, and starting the Shiny server.

We are now ready to cross the bridge to the interaction side!

Tutorial interaction

Brace yourself for this next one:

Crossing the bridge over to interaction, the student can now see and interact with the tutorial, which is an HTML document. rmarkdown produced this document by using a custom output defined by a function in learnr, learnr::tutorial. learnr tutorials are designed to be interactive documents and are better thought of as specialized Shiny apps, not as static documents. This is why you cannot knit a learnr Rmd document into arbitrary formats such as a PDF.

This HTML document you see here is special because it is actually a type of Shiny app using the shiny_rendered runtime. The Shiny prerendered runtime means that some of the code are normally rendered with rmarkdown (render context), while other code execute when the tutorial is served (server context). This is done for performance reasons which you can read more about here. All you need to know here is that the Shiny prerendered scripts included in the HTML will be used to retrieve Shiny reactive values from the backend side (exercise.R). For stateful events such as “Start Over” or “Next Topic” button clicks, the tutorial.js will respond to these and notify http-handlers.R to make changes to the internal state of the tutorial or record events for logging.

Evaluating exercises

When it comes time to evaluating an exercise, exercise.R goes, “I’m going to take all of the code text submitted for this exercise and evaluate it in an isolated R file and the environment it needs. Then, I’ll use knitr to produce the properly formatted regular Markdown that rmarkdown can render, and set the results for the Shiny reactive value.”

The Shiny code within exercise.R then responds with, “Great! You have given me an html output for the exercise, I’ll let the frontend know so it can be appended.”

Here’s the script tag in the HTML document that makes this interaction cycle possible:

<script type="application/shiny-prerendered" data-context="server">
    `tutorial-exercise-addition-result` <- learnr:::setup_exercise_handler(reactive(req(input$`tutorial-exercise-addition-code-editor`)), session)
    output$`tutorial-exercise-addition-output` <- renderUI({
      `tutorial-exercise-addition-result`()
    })
</script>

It essentially sets up the exercise handler and the Shiny function renderUI to retrieve html output after evaluating the exercise. Ultimately, the output is appended under the exercise, which could be code output from clicking the “Run” button or some feedback from clicking the “Submit Answer” button.

Reflections

Daniel Chen had mentioned in his reflection last summer that he turned from a “a user of the R language” to a “developer”. I would say I feel the same way so far. Although I knew how to use R packages, it wasn’t until I had to venture into learnr that I realized that developing packages is a whole different ball game! From a developer’s perspective, it has been a lot of fun making improvements to learnr because building and debugging the package is very fast and allows quick build-test cycles. I also wouldn’t have made it this far without the guidance of Alison and Greg with setting goals for each week and making sure I’m enjoying the work as well. Barret has also been a tremendous help whenever I am stuck on a problem and I’m reminded how great it is to gain tacit knowledge from an expert. I now understand when to use vectorized operations in R such as vapply over a for loop–thanks Barret!

From my learning of learnr, I’ve been able to make two pull requests adding enhancements to learnr. PR #373 was my first easy task which involved allowing the instructor to suppress a confusing warning message about “invisible result”. This PR gave me a good idea of the learnr package execution flow. PR #390 was a much more difficult one which adds support for chaining setup chunks, which can alleviate the tedious process of building up setup code for incremental exercises as voiced by many (see issue #72). It was by far one of the most technical challenges I’ve had to tackle so far, but I am very excited to say that this particular PR also paves the way for a cleaner approach on non-R exercises by changing how we process exercises. But, that’s for another post!

Although we are not there yet to make Python lessons in learnr, I look forward to adding more infrastructure to make this a reality—eventually.

Newly certified instructors in June 2020

Tue, 30 Jun 2020 00:00:00 +0000

We are very pleased to welcome 17 new instructors in June 2020:

This brings the total number of certified Tidyverse instructors to 130, and the number certified to teach Shiny to 21. It was also a month of firsts, including our first blind instructor, our first undergraduate instructor, and our first instructors in Iceland and India. If you would like to speak with any of them about your training needs, their contact information is on the trainers’ roster and they would be happy to hear from you.

Our classes in July, August, and September are now full, but if you would like to join our waiting list, please fill in this form.

Tidymodels Internship

Tue, 30 Jun 2020 00:00:00 +0000

I’ve been spending my summer interning with the tidymodels team at RStudio. Amid all of the instability recently, due both to the pandemic and much-needed surge in engagement with racial justice efforts in the U.S., I’ve been especially grateful for reliable and meaningful work. The internship has involved all of the package development I had hoped for plus so much more.

broom

I spent the first half of my summer working on broom, an R package that supplies functions to convert models and other statistical objects to tidy tibbles. Familiarizing myself with the codebase was definitely a challenge: the broom package is much larger, has so much more history, and is so much more widely used than any package I’ve worked on before. I’m grateful that RStudio 1.3’s global search and replace came just in time for my internship start date!😅

With the help of over 100 new contributors since the last major release, broom 0.7.0 will soon be on CRAN: you’ll be able to read a bit more about it on the tidyverse blog once it’s released.

Model Stacking

With the new release of broom wrapping up, I’m transitioning to my second project: a grammar for model stacking that aligns with the existing tidymodels framework. This functionality was consistently one of the highest-ranked requests in the recent tidymodels community survey, so it’s been really neat to be working on what seems to be a high priority for tidymodels users.

I’ve been very thankful for fellow intern Ezgi’s recent work on learning and teaching tidymodels as I’ve familiarized myself with parsnip, tune, dials, and recipes. The API and implementation are still very much in their developmental stages, but I’m excited to share more about this work as it starts to take shape.

The Big Picture

This internship has meant much more to me than just my projects, though. For one, interns had the opportunity to take part in the RStudio instructor certification program. It was unlike any learning experience I’ve had before, and I’m really excited to get started applying what I learned while leading R and tidyverse workshops soon.

Spending time with so many of my professional idols has been great too: learning from them while also having my input taken seriously has felt really meaningful. (Our shared appreciation for emojis has been helpful in connecting, too.☀️) It’s also been really inspiring to talk with other interns and follow along with their projects. Each of their skillsets are so impressive and different from my own.

I’m genuinely grateful for the opportunity to be interning with RStudio, and I’m excited to see what the second half of the summer brings!🐛

Working with Spreadsheets

Mon, 29 Jun 2020 00:00:00 +0000

Fancy algorithms, lots of code, and beautiful visualizations are usually the first things that come to mind when people think about data science. While these things are a part of the equation, a central piece of the puzzle (though sometimes overlooked) is the raw data itself, where it lives, and how to most efficiently work with it. The focus of my internship addresses a piece of this, namely spreadsheets and the most efficient ways to work with them using RStudio.

If you’ve worked with data no doubt you’ve worked with spreadsheets. In starting this project the goal has been to speak to two groups: those who work with data in spreadsheets directly and those who work with them using RStudio. Currently we’re developing a resource that provides an overview of the most common packages used to handle data stored in sheets, providing key information as to how each package deals with reading in and formatting data as well as providing information on the current state of each package and system requirements. In addition we’re developing a series of educational posts focused on demonstrating the ways in which RStudio functionality can make life easier for handling and analyzing data in sheets, and how R users can utilize the best features of spreadsheets to inform their own work from scripting to the development of shiny apps. Abandoning the notion that analysts who either primarily work in R or primarily in spreadsheets are two distinct groups that shall never meet, the resource we’re developing aims to build a bridge and show how blending workflows that efficiently utilize spreadsheets and RStudio can make for powerful analyses and impactful products.

Since starting I’ve thoroughly enjoyed my time at RStudio especially in being able to work with and learn from Jenny Bryan and Mine Çetinkaya-Rundel. Not only have I been able to lend my own experiences handling all kinds of spreadsheet data to the project, I’ve learned much about different types of spreadsheet workflows used for data entry and the delicate balance of sheets best maintained for human and computer use. What I’ve enjoyed most about RStudio is the community and culture here. While my time here has been short I’ve felt welcome since day one and have been able to participate in company wide events and meet so many amazing people.

Data science summer camp for high schoolers

Wed, 24 Jun 2020 00:00:00 +0000

Instructors and learners alike have had to quickly adapt to virtual education due to the ongoing pandemic. The learnr package has become a popular tool to ease that transition (see Allison Horst’s great post).

Before our lives were completely changed by the pandemic, however; I was fortunate enough to conduct an introductory R session with a group of teenagers in person. I was able to create the materials for this session, Understanding Injury Data with R, with the learnr package and the source code is available on GitHub. Although in person examples of teaching may not be the most relevant topic under these circumstances, I thought that sharing my experience of teaching a younger audience using learnr could offer a unique perspective.

Some background

I was asked to teach an introductory R session as a part of the Data Science for Women Summer Camp in July 2019. The camp was organized by the Translational Data Analytics Institute at The Ohio State University (OSU). Admission was free and available for young women entering grades 8, 9, or 10 attending local high schools in the metro city area.

Figure 1: Summer camp group picture with students

At the time I was asked to teach the session, I was still a PhD student at OSU and the co-organizer of R-Ladies Columbus (I am still today). Camp organizers had seen me present several introductory R sessions in local conferences and R-Ladies meetups, and thought I would be a great instructor for the only hands on coding session of the entire data science camp.

Camp organizers asked me to:

Show how to do data analytics with R
Expect no statistics background from students
Use a health related data set
Do all of this in 50 minutes

Let me assure you, organizers didn’t come to me because they were amazed by my squeaky clean code or my vast R/statistics knowledge. They invited me because they thought I was very enthusiastic, which they believed was the missing ingredient for this session in the past. It turns out, hands-on-coding session wasn’t a favorite among students the year before.

Wake up call

I happily accepted to teach the R session, because I really enjoy teaching R, and thought this short 50 minute session would be easy to figure out and wouldn’t require much work.

Well, I was certainly being naive. While there are many example teaching materials for R, most were designed for college students or other adults, and at the time I couldn’t find any examples for middle- or high-schoolers. Although I came across some amazing K-12 lesson plans to teach statistics on statisticsteacher.org, these weren’t suitable for the short 50 minutes that was allotted for my session. (The wonderful Teacups, Giraffes, & Statistics project didn’t exist back then, but today it would be another wonderful resource to teach R and statistics to a young audience.)

I was also worried about finding a “fun” health data set: talking about diabetes, cancer, or some other complex disease did not sound fun to me at all. Knowing about the unpopularity of the session in the previous year, I was starting to feel quite desperate. I believed my session was going to mirror the bored to death classroom scenes from the infamous Ferris Bueller’s Day Off movie.

Figure 2: A scene from Ferris Bueller's Day Off movie

Luckily, I attended Kenia Wiedemann’s talk at useR!2019. Kenia is involved with a research project called CodeR4MATH, which aims to integrate R programming in high school math classes. While her curriculum also included multiple sessions throughout the semester, she talked about the amazing learnr package and all the cool things you can do with it. We also got a chance to chat about teaching R to teenagers and here some of the important points I remember:

Minimize any unnecessary distraction. Using RStudio Cloud or RStudio IDE in this setting might not be the best choice, as there are too many things you need to clarify before getting to the actual point. This is why learnr is perfect for this setting, you can limit what they can see and do very easily, without making it too rigid or boring.
Most teenagers are quite self-involved, you have to find a data set that they can relate to. If you want to get even some of their attention.
Do not get discouraged if you don’t feel the enthusiasm and engagement you may feel with adult learners. High schoolers can wear their emotions on their sleeves, and you never know what else they are dealing with. They may be disengaged for any number of reasons, and it isn’t for you to fix or figure out.

I have to admit, at this point I was genuinely terrified and still didn’t know what to talk about. But I knew the tool I had to use: learnr!

And learnr saves the day!

Easy setup

Beyond its pedagogical advantages, learnr is also a clean and easy way to deal with installation or subscription issues that come with dozens of laptops running Windows. In my case, the university was providing all the laptops for the session and it was up to me to set them up. Since we had an internet connection available during the session, I certainly did not want to install R locally and was planning on using RStudio Cloud. That’s great in theory, but then you have to then setup separate RStudio Cloud accounts for each machine, which includes setting up different email accounts as well (which we actually did and ended up with dozens of Gmail accounts 😱).

Thanks to learnr and its easy deployment with shinyapps.io I was able to simply enter the link into the browser for each laptop before the session and they were all ready to go! 🎉

Interactive code chunks

I was also finally happy with my dataset. I decided to use the neiss package, which provides access to the last five years of data (2013-2017) from the National Electronic Injury Surveillance System. The dataset is a sample of all accidents reported to emergency rooms in the US.

Since the session was quite short, my aim wasn’t teaching them how to code in R but let them get a feel of it. I didn’t shy away from putting somewhat complicated code chunks in front of them, and expected them to find and change the arguments correctly to get the answers they needed.

During the session, students talked with their neighbors about physical accidents/injuries they had at home or at school. Then they were able to adjust (fill in) the code in the tutorial with the correct variables/terms to look at the most frequently injured body parts for the overall US population, and their gender and age group in the dataset.

Here’s an example exercise chunk:

Figure 3: Example code chunk

Hints

I was also able to add hints or solutions to every exercise, so students didn’t get lost and suffer in silence if my instructions weren’t clear. I think the hints were helpful, because although I was in the same room and walking around, I assumed many would be too shy to ask a question.

Figure 4: Hint box example

Quizzes

I believe adding quizzes throughout the whole session kept students less distracted and more engaged, as they were busy trying to find the answers.

Figure 5: Example quiz from the tutorial

Make it less dry

While default learnr style wasn’t very aesthetically appealing to me, I didn’t have time to explore customization steps before the session. But it is possible to be creative by adding pictures and videos!

Figure 6: Embedded picture example

And if you would like to go above and beyond, there are many ways to customize it further. Allison Horst’s Exploring missing values in naniar is a shining example of what next level customization can do.

Student feedback

Throughout the session I went through the tutorial on my laptop, which was shared on two large screens for students to see. I walked around regularly to see students’ progress or answer questions. Students talked and laughed about their injuries; some shared their stories with the rest of the class. Overall, I thought the session had good participation, even though it was the first activity of the day (as some students complained about it in their feedback).

I have to add that one student pretty much slept throughout the whole teaching session. She was already in the classroom, sleeping on the table when I got there an hour early to set things up at 8 AM. (I later found out that her parents had dropped her off around 7 AM.) Following the suggestion from before, I didn’t try to wake her up nor did I make a comment about it during the session. I believed she wasn’t sleeping because of my subpar teaching, but due to factors outside of the classroom, which couldn’t be resolved in the 50 minutes that we had.

Naturally, I was very curious to hear what students had to say after the session. Organizers shared the survey data from first two years of the camp: in 2018 same hands-on-coding session was conducted with a pre-written, commented R script by a young professor, and it was conducted with a learnr tutorial by me in 2019. Of course, I had to compare the two sessions:

Figure 7: Student feedback shown as bar graph

My hands-on-coding activity wasn’t as popular as other camp activities that involved going to the planetarium or flying drones. 😅 However, I was very happy to see the decrease in the dislikes compared to previous year!

Students were also asked to describe their experience with one word:

Figure 8: Student feedback in wordcloud

Again it was encouraging to see words like “fun”, “exciting”, and “wow” frequently. (I’m not exactly sure what “funkyfresh” means, but I believe “fresh” is a positive thing?)

The whole point of this summer camp is about encouraging students to select analytical fields in the future. I really hope no student was discouraged of coding because of me! 🙃 I aimed to give them a glimpse of coding, showing that it requires some work but can also still be fun. 🎈

Final words

The learnr package provides a powerful framework that lets students easily interact with the code without begin overwhelmed with errors, warnings, package installations, and all other distractions. Even though learnr is mostly designed for on online self-learning setting in mind, it is highly useful for live sessions where there is limited time to introduce RStudio IDE, or for young audiences that can be easily confused and disengaged with the material. Creating content with learnr certainly takes a little more time and effort than a simple RMarkdown document. It also requires a shinyapp.io account (possibly a paid one for better performance). But in my experience, it was worth all this manageable trouble and saved me from boring students to death! 🦸

Finding Errors in Data Analyses

Tue, 23 Jun 2020 00:00:00 +0000

While some people guide their teaching practices with anecdotal evidence, we prefer to study these practices through a scientific lens. The goal of my summer internship with the RStudio Education team is to find out how and how well data scientists and data science students identify errors in data analyses. In particular, we want to explore how the ability to catch errors varies by level of experience as well as familiarity to the data and type of analysis.

To do this we have developed R Markdown documents that contain analyses related to domains such as sports, elections, and property sales. These analyses will be presented to participants who will think aloud as they go through the document and identify errors. Before implementing the study we wanted to test our design, so I recruited two fellow interns and two experienced data professionals as alpha testers. We found that the interns finished the notebooks quicker than the experienced professionals, but still caught all of the errors. Data professionals were much more meticulous with the wording of statistical premises (e.g., association versus effect) and they were more meticulous about their data exploration than the interns. However, the interns were able to wrap their heads more quickly around code they hadn’t encountered before than the experienced professionals.

This experience also helped us refine the length and structure of the document as some of the errors were too obvious. We will start collecting data from real subjects in July, and hope to publish our analysis in the fall. If you are interested in taking part, please contact us at ian.floressiaca@rstudio.com

To support this study I’m collaborating on the development of the R package templar created by Prof. Kelly Bodwin from California Polytechnic University, which provides tools to create variant R Markdown documents. Let’s say you want to create an exam for students and have three different variants, but the narrative of the exercises will stay the same and just the code chunks will differ. You can use templar to select consistent variant code chunks just by adding an extra argument to the chunk’s setup. This package is still in its early stages but it will be useful for both education and research.

What I’ve enjoyed most about my internship so far is the chance to meet and chat with people like Kelly, Mine Çetinkaya-Rundel, and Alison Hill. RStudio as a company is great: they provided me with a MacBook Pro (which has made me rethink my personal setup with Ubuntu and a Tuxedo laptop), and they have provided space and dialogue about the current events regarding racism in the States. They also follow a truly asynchronous remote culture. My day usually starts by coding a little bit before 6am; I then go exercise with my dog, followed by snorkeling in the northeast of Puerto Rico (sorry not sorry), and start my morning around 08:30am by checking Slack and email. I work until around 14:00, then continue after 18:30. It has been a great learning and networking experience so far, and I’m looking forward to the rest of my summer.

Data analysis for social justice in a Native classroom

Mon, 22 Jun 2020 00:00:00 +0000

I’m here to share some insights from a work in progress. I began teaching an introduction to data science last year at the Southwestern Indian Polytechnic Institute (SIPI), a community college in Albuquerque, New Mexico with an exclusively Native American student-body. My professional background is in behavioral ecology, however, my passion for teaching lies in data analysis. Why? Because data literacy and analytical expertise are freely available tools to empower people and remedy many societal ills and injustices. My course datasets are therefore usually related to such ills.

The material is currently delivered in an intensive 4-day workshop. Since the first round of its development and implementation, I’ve learned a number of lessons (beyond how to teach mental models that underlie ggplots). I can group these into three general areas.

Creating culturally relevant and inclusive content and structure.
The importance of logistics and technology.
A teaching attitude that’s make-or-break for beginners.

1. Creating culturally relevant and inclusive content and structure

An inclusive class must address two big issues: is the material personally relevant and is the material accessible and safe to engage with?¹

Skills in coding and statistics grow through application, which happens best when students are motivated to answer a question. If one of our goals as instructors is to increase diversity in STEM and data science, then we need to become literate on a diversity of questions that people are motivated to answer.

For this workshop, I’ve chosen the route of letting students choose among datasets on public health and social justice issues. These topics are too widely pertinent to Native peoples, e.g. diabetes², cancer³, suicide⁴, and gun crime⁵. Now, no group is homogeneous and it is inaccurate to think that every member of a marginalized group is interested in social justice; however, these topics do draw the interest of my students. They are also issues that the power of data literacy can help students solve in their lifetimes. In the future, I plan to incorporate datasets on other contemporary issues, such as social media usage (similar to Girls Inc of NYC), as the current hard-hitting topics may turn-off some students. The provided datasets serve as the basis for group projects, in which students hone and analyze their research questions.

To create a safe and engaging classroom structure, I take a few different abstract and concrete steps…

In the abstract, I first understand that for many Native Americans, and other historically marginalized populations, community and storytelling are a central part of life, playing massive roles in individual identity. The culture of many classrooms does not always value communities and their stories in the same way… Western higher education was established in a highly individualistic culture, whose Protestant Christian roots⁶ emphasize dutiful and successful work (not necessarily community) as a core component of individual identity. This culture has been introduced to the world too often via painful and dehumanizing experiences⁷. So, the elevation of the individual through hustle and perfection, which is a common ambition of higher education, does not always feel familiar to students and, if familiar, it does not always feel safe. For many students, instead, a focus on community and connections to community makes classroom material much more accessible.

Second, I try to adjust my perspective as a teacher, understanding that

I am operating on stolen land.
My students likely have an inseparable connection to their communities and their land.
My students are strong and resilient in the face of intergenerational trauma.⁸
My own notions of health, medicine, and justice are highly individualistic and institutional.

Then concretely, I put the following principles into action.

The destination is clear: Roadmapping is central to effective teaching in any classroom. One of the biggest barriers for students are the tacit expectations teachers place on them, including why they are taking the class and their performance and behavior in it. Students should have a clear outline about what we’re doing throughout and at each stage of the course: what they will learn from it, how and when their performance will be evaluated, and how it will be useful to them outside the classroom. Yup, a good written syllabus + explicit and regular expression of expectations and learning objectives are foundational for inclusive classrooms. Doing this well takes time, practice, and planning.⁹
Everyone is up to speed: At the end of any 15-20 minute lecture chunk I use low-stakes, formative assessments (e.g. ungraded quizzes¹⁰) to focus everyone’s attention on the big picture of what we’ve just talked about and track/realign any misconceptions.
Representation matters: For slideshows, I aim to highlight Native people that are working to solve the problems showcased in each dataset. Whenever possible, I also choose pictures of Native people applying the skills that the students are learning. Each of these gives students role models, so they can envision themselves doing data analysis for public health and social justice.
Make the connection: Upon choosing their data set and at mileposts during their analysis, I ask students to express how the data relates to them and their communities, and how they can share insights from the data with others. Letting students tell their stories builds trust. In the future, I plan to use a talking stick as each speaker shares.
You have agency: I let students decide on their project datasets.
We’re a team: Working in groups begins early. In teams of 3-4, students alternate roles as “lead investigator”, “coder”, and “reporter”. The teams take time to communicate as a class via their reporters.
Tell me more: I always end with a survey (I use SurveyMonkey). This gives students a clear chance to let me know what datasets spoke to them, what tripped them up, and what types of data they’d be interested to work with in the future (as well as the various technical skills they’ve gained).

2. The importance of logistics and technology

Attitudes are vital. Unfortunately, they can’t do much if technical difficulties completely hamper students’ engagement with material. The students we seek to recruit and empower in STEM will often be in resource-limited institutions and this will require additional tricks and strategies from instructors.

One of the easiest ways to ensure a smooth-running workshop or class is to limit class size. I know, this doesn’t sound very inclusive, but I choose to cap workshops at 15 and only work with students that actively choose to participate. I find this ensures a baseline of motivation and allows me to be most effectively hands-on.

Otherwise, the big idea is to come prepared.

For class startup, I try to have different Wi-Fi dependent and independent options. To be clear: Wi-Fi can be a big problem.

I have a version of all materials on RStudio Cloud (Wi-Fi dependent). The cloud’s workspaces and projects for courses and workshops are fantastic. If you’re not already familiar with it, I recommend this tutorial from Mine Çetinkaya-Rundel. Unfortunately, RStudio Cloud is sometimes slow, extremely slow with weak Wi-Fi, and of course simply non-existent when Wi-Fi is down.
I’m lucky to teach in a computer lab – I can coordinate with IT ahead of time to have R and RStudio installed on every computer (yes, time and labor intensive for someone). I have my most recent exercises and assignments posted online for them to download at the start and then run Wi-Fi free (minimal Wi-Fi dependence). I also put my scripts on thumb drives (Wi-Fi independent), for the worst case scenario – zero Wi-Fi.
For the future, when students might bring in their own computers, I’m working on (and asking others to help) write bash scripts for different machines, which install R, Rstudio, and several base packages. I can distribute these bash scripts, and R scripts for the day’s exercises on thumb drives (total Wi-Fi independence) and have students go through dreaded installations with minimal pain. In any case, I do some intros and demos (fun) before installations begin (not fun).

For presentations, I have a powerful mini projector with blue tooth connection (an Anker Capsule, many thanks to NIH research funding). So regardless of the awkward shape or layout of the room available to me, or however weak the projector is, I know I have my own flexible little powerhouse whose ins-and-outs I’m intimately familiar with.

There are two other workarounds (both Wi-Fi dependent) for students to watch live coding when visibility is poor. First is an institutional Zoom account that allows me to share my screen with several students. Another is the new livecode package from Colin Rundel that I’m excited to try. Check out the demo from Rstudioconf::2020 here. Essentially, your RStudio IDE is constantly creating a web page of your work, which your students can watch with the appropriate link.

3. Finally, a make or break attitude for teaching beginners

We generally know, but regularly need to remember… When we first saw R or the RStudio IDE it was daunting and foreign. Hours (or years) of debugging and Google searches may have made us forget this, but we must resist the temptation to trivialize or oversimplify in front of students. In my experience, flashy demos can often dishearten even talented people, making knowledge and skills feel unattainable to all but a few type-A students.

One thing I love about the #rstats community is that this reminder is rarely necessary. People I encounter whose knowledge far exceeds mine most often act with humility and respect for everyone’s stage of the journey. I’m deeply grateful to the #rstats community and education department for their support and training. From my start as a conference diversity scholar, to completing the RStudio instructor certification, to this guest blog post – RStudio has played an enormous part of my teaching journey.

Acknowledgments

I thank Dr. Alfonso Heras Llanos, a math professor at SIPI, who helped me implement this workshop. I also thank my friends and colleagues Tammi Duncan and Carla Sakiestewa of the Navajo, Hopi, and Lakota Nations, who provided helpful comments and feedback while developing this workshop and this post.

Twitter: @NicoleAlineSci

My Organization's First R Package Workshop at rstudio::conf(2020)

Mon, 08 Jun 2020 00:00:00 +0000

tl;dr: all workshop materials are available here:
https://rstd.io/conf20-org-pkg
🔗 https://rstd.io/conf20-org-pkg
License: CC BY-SA 4.0

We were thrilled to deliver our workshop, “My Organization’s First R Package,” at rstudio::conf(2020L). Packages are the fundamental unit of shareable code in R, and the modern ecosystem for developing and sharing packages is efficient and user-friendly. While many R packages are distributed through CRAN, they are also useful for sharing code within your organization, organizing analysis projects, and deploying data science products.

Many great resources exist for learning R package development, including the R Packages book and workshops like Building Tidy Tools. Our workshop was unique, however, in that it focused on developing R packages for use within your organization—whether you’re a data science team, an academic research lab, or a lone R user in a sea of Excel users. We taught participants how to use devtools, usethis, and other useful package development tools to develop and share R packages for internal use. We made R packages for two fictional organizations, AVALANCHE and Intendo, to learn best practices in R development and useful tricks for internal packages.

Day 1

On Day 1, we focused on R package development basics: setting up packages, writing R code, documenting and testing your code, teaching others to use your package, and adding data (and other files) to R packages. We learned how to work with packages with usethis, build and check them with devtools, document them with roxygen2, and test them with testthat.

To put these tools into practice, we developed an R package for the data science team for AVALANCHE, an (alleged) eco-terrorist group looking to take down the evil Shinra Inc.. You can see the package we developed, avalanchr, on GitHub.

We also explored how R package development tools meet the needs of internal R packages. For instance, we included a data dictionary for our database with usethis::use_data(), we included R Markdown report templates with usethis::use_rmarkdown_template(), and we deployed a Shiny app straight from our package.

Day 2

On Day 2, four sections covered several themes: working with databases, writing functions that use DB data, planning package dev within the organization, and integrating standardized reporting. The goals for this day were to review and get practice with most of the concepts learned on Day 1, and, to build a complete package based that utilizes data housed in a database (which is typical of how most organizations store their data). To make package development more fun and provide an experience more akin to a real-world business scenario, we used a set of DB tables that belong to an imaginary game studio called Intendo. We quickly got up to speed with how to access a MySQL database and how to calculate key performance indicators that were important to Intendo during its brief reign in 2015 (the company had moderate success with its Super Jetroid game before fizzling out in early ‘16). The students learned how to create functions for the intendo package that: (1) facilitated data access, (2) quickly got us KPIs most relevant to the organization, and (3) were fully documented. Throughout the day, as on the first day, the package authoring workflow made great use of the easy-to-use functions available in usethis. There were five checkpoints of the intendo package that were available if any of the learners needed to get caught up. Throughout the day, the learners asked us questions, showed us their new package functions, and ran R CMD check dozens of times. They made fully-functioning packages that any organization would be lucky to have! Aside from covering everything in the instructional materials, we exchanged plenty of tips and tricks about how to solve all those little package development snafus, save time during development, and go the extra mile to make the package shine!

Packages

In the spirit of this workshop, we used plenty of packages to deliver the course!

The first was the course package, firstrpkg, which let participants install the materials locally, as well as all the R packages we needed for the course.

Participants also developed two R packages: avalanchr and intendo. You can follow along with their development by installing the materials with firstrpkg or by checking out the slides for each section:

Teaching Materials

Day	Session	Taught By	Theme	Materials
1	Welcome, Whole Game	Malcolm	Package dev	Welcome, Whole Game
1	Setup Packages	Malcolm	Package dev	Setup Packages
1	Write Code	Malcolm	Package dev	Write Code
1	Document	Malcolm	Package dev	Document
1	Test Code	Malcolm	Package dev	Test Code
1	Teach Others	Malcolm	Package dev	Teach Others
1	Adding Data and Files	Malcolm	Package dev	Adding Data and Files
2	Working with Data in a Database	Rich	Databases	Databases
2	Package Functions	Rich	Package dev	Package Functions
2	Package Management	Rich	Organization	Package Management
2	Standardized Reporting	Rich	Package dev	Standardized Reporting

Closing

We had a great time interacting with the learners during the two days of the workshop! Many thanks go out to our wonderful TAs, Amy Tzu-Yu Chen, Samantha Toet, and Greg Lin. They answered dozens of questions and handled all sorts of technical issues.

Learners told us during and after the workshop that they got a lot out of it, and working with this group of enthusiastic useRs was an excellent experience for us, too. We wanted to empower everyone in attendance to be able to create useful R packages. With these new R skills, both they and the organizations they represent will invariably be more successful.

Check out materials from the 18 other rstudio::conf(2020) workshops...

Instructor Training

Tue, 02 Jun 2020 00:00:00 +0000

Lucerne Workshops

Mon, 01 Jun 2020 00:00:00 +0000

Campus Lucerne is running various R workshops in English and German language starting in September 2020. The training offered in English is designed by Dr. Andrea De Angelis, a certified RStudio instructor, using concepts from the instructor training program. The courses will be held at the University of Lucerne, Switzerland. For more information or to register, please visit https://www.campus-luzern.ch/kurse/luzerner-r-kurse-lucerne-r-courses-hs/.

Newly certified instructors in May 2020

Mon, 01 Jun 2020 00:00:00 +0000

We are very pleased to have welcomed eight new certified instructors in May 2020:

This brings the total number of certified Tidyverse instructors to 116, and the number certified to teach Shiny to 18. If you would like to speak with any of them about your training needs, their contact information is on the trainers’ roster and they would be happy to hear from you.

Deep Learning Workshop at rstudio::conf(2020)

Thu, 28 May 2020 00:00:00 +0000

tl;dr: all workshop materials are available here:
https://rstd.io/conf20-dl
License: CC BY-SA 4.0

This past January I attended rstudio::conf(2020). Seems odd to say that I attended a conference in 2020 but I did, along with over 2,000 others. This was my second rstudio::conf and if you have not attended, you definitely need to put it on your radar for future years - the people, community, resources and education are great bar none.

This year I had the opportunity to teach the Deep Learning with Keras and TensorFlow in R workshop. The workshop had max capacity attendence and was sold out within the first couple of months of opening up; showing a strong thirst for deep learning within the R community. With unbelievable support from TAs and RStudio, the workshop was a great success.

State of deep learning resources

There is no lack of deep learning resources. Almost any tech learning platform you look at (i.e. coursera, Udemy) is filled with deep learning courses, publishers are filling virtual deep learning bookshelves, and deep learning blog posts are a dime a dozen. But with all these resources I often find two road blocks for people being able to understand and implement deep learning solutions:

Often the material over-emphasizes algorithmic complexity and uniqueness of deep learning. However, when you simplify most deep learning methods down to their basic ingredients, people that understand basic statistical concepts and common “shallow” learning models such as linear regression can fully grasp deep learning concepts.
Most material use Python and leads R programmers to think that they need to leave the comfort of their current language to do deep learning tasks.

This workshop was designed to debunk both of these myths and provide an intuitive understanding of the architectures and engines that make up deep learning models, apply a variety of deep learning algorithms (i.e. MLPs, CNNs, RNNs, LSTMs, collaborative filtering), understand when and how to tune the various hyperparameters, and be able to interpret model results…all with the simplicity, comfort and beauty of R! ¹

So how did we approach this?

Understanding the ingredients

The first 90 minutes we spent working through a notebook that illustrates how feedforward deep learning models solve very simple linear regression, binary and multi-class classification problems. We simplified these procedures to the bare minimum so folks can understand:

how the model architecture relates to common models they’ve used before,
how the models learn via gradient descent,
what activation functions are,
the idea of learning rate and momentum,
how model capacity impacts performance,
why we care about batch sizes,
and the importance of data prep.

Wow, that seems like a lot…and it was! But by working through very simple examples and illustrations the students started to realize that these concepts are not overly complicated. In fact, many started to see a very obvious relationship to non-deep learning concepts they already know.

Follow a recipe

After getting a basic understanding of key deep learning concepts and terminology, we spent the rest of the morning discussing how to strategically approach training a deep learning model. I’ve gotta admit, finding an optimal deep learning model is far more difficult and time consuming than traditional shallow models. In fact, its rare that you will actually find an optimal model!

As data scientists we can accept this but we still need to have a good mental model that gives us a high probability of finding a near optimal one while reducing overall model exploratory time. For deep learning models, this can be reduced to:

Prepare data
Balance batch size with a default learning rate
Tune the adaptive learning rate optimizer
Add callbacks to control training
Explore model capacity
Regularize overfitting
Repeat steps 1-6
Evaluate final model results

Once folks understood what each one of these steps were doing and how to implement them, they definitely gained confidence in their ability to apply an initial model and then start iterating to improve model performance.

A basic cookbook

Once students had a good mental model of the basic ingredients of deep learning models and a general recipe for approaching training models, the rest of the workshop was spent building on top of a basic feedforward model and working through the concepts of:

computer vision with convolution neural networks,
the idea of re-using previously trained models (aka transfer learning),
encoding text with word embeddings,
applying a deep learning approach for collaborative filtering with customized functional models,
using recurrent neural networks and long short term memory networks for analyzing sequential data (i.e. text, time series, videos).

Each of these models builds onto the foundational knowledge with new key concepts. Along the way we trained over a dozen different types of models and data sets…some small and some big. But working through these different concepts gave folks the exposure to common problems where deep learning shines and also where some models have a hard time improving over a simpler shallow classification model.

Workshop approach

As you may infer, the workshop was very hands-on and covered a lot of material using a variety of approaches. If you peruse the repo, you will notice that we worked through notebooks for interactive analysis, used slides to emphasize key concepts and illustrations, and even opened up an Excel file to help demonstrate what’s going on with basic collaborative filtering and word embeddings!

In fact, I knew going into the workshop that I probably had too much material. But my hopes was that the workshop provided an opportunity to explore the concepts while also allowing folks to easily work through notebooks and compare solutions on their own. So if you missed out on the workshop, all the data and code to reproduce the notebook content and slides are available. I even provide extra content that we didn’t have time to cover such as visualizing CNN models, performing grid searches, and more.

Plus, all the content is licensed as CC BY 4.0 so people can feel free to reuse slides, notebooks, exercises and the like.

Appreciation

I had an absolute blast developing and delivering this workshop. The attendees were fantastic and asked valuable (and challenging!) questions; making the 2-days very interactive and personable.

The workshop was also result of a fantastic TA team! I really enjoyed meeting and getting to know them:

I also could not have pulled it off without the incredible RStudio infrastructure team dedicated to supporting us ( Cole Arendt and Alex Gold) and the entire RStudio Education team. The infrastructure team made using AWS and GPUs as simple as making pop tarts and the education team made everything smoooth and seemless!

Enjoy!

I hope the materials developed for this workshop are useful to learners and educators alike. If they are, please let me know, I’d love to hear about it.

Check out materials from the 18 other rstudio::conf(2020) workshops...

This is not to say that some deep learning concepts don’t become extremely complex; however, I would argue that they are no more complex than advanced extensions of generalized linear models…GAMs anyone??? Also, I am a huge proponent of learning multiple programming languages so this has nothing to do with the ridiculous R vs Python vs … argument! In fact, the more you know about Python the easier it is to debug Tensorflow and Keras problems within R. ↩︎

Teach R with Interactive Courses

Tue, 26 May 2020 00:00:00 +0000

I recently published yet another version of an interactive supervised machine learning course where learners can practice their modeling skills in the browser with four case studies.

It’s a good thing that I like these data sets and this course 😉 because I have released at least three different versions of it at this point (depending on how exactly you want to do the accounting). The latest iteration of this course focuses on how to use tidymodels for predictive modeling. Undertaking another significant revision of this course has given me the opportunity to reflect on the process of building and maintaining interactive courses.

We’re all in this together

I’m not the only one who has built interactive courses over the past year or so. In the aftermath of loss of trust in DataCamp as a learning platform, folks across both Python and R communities have looked into other options, especially open source options that are transparent, free-as-in-speech, and/or free-as-in-beer. Ines Montani created a course platform for both Python and R, with a front-end powered by Gatsby and Reveal.js and back-end code execution powered by Binder. Ines used this course framework for her own excellent course on spaCy, and multiple folks in the R community have built on their own courses as well. For example, Ted Laderas and the team behind the R Bootcamp shared their perspectives on building such a course here at the RStudio Education blog earlier this spring.

The first person I knew who successfully got their interactive R course launched was Noam Ross; his course on generalized additive models is fantastic. 💯

All three of us (Noam, myself, and Ted Laderas) collaborated with Florencia D’Andrea in building our courses. Florencia is one of the most knowledgeable people out there when it comes to getting a course like this up and running! I’ve chatted informally with both Florencia and Noam about their experiences in building and maintaining interactive courses before, so I decided to ask them to gather their thoughts less casually so we could share them all together.

It’s time to build

Everyone I know who has worked on a course like this says that it is a challenge to get up and running. Part of this is probably because it involves JavaScript frameworks that we as data scientists are not 🙅 experts in. “It kind of constrains my ability to maintain or extend it,” says Noam.

Even aside from the JavaScript, this particular course framework involves a complex file structure for exercises, solutions, slides, and so forth that can be onerous to manage. I think I agree with Florencia, who says, “Perhaps the longest part is getting familiar with the file structures and exercises.” Florencia wrote a blog post outlining these details, which is also available in Spanish!

On the other hand, we have all been amazed at learning more about Binder, what it is, and what it can do. “The degree to which the Binder back-end just works is amazing. It’s astonishingly low maintenance, which is one reason I don’t consider moving to something I might understand better,” says Noam. The first time Florencia explained to me how you can access what you have in the repo in an RStudio IDE in a browser, I was floored! “I think it is a great tool to turn a Git repo into an executable environment in a simple way,” she says. To try it out, visit the Binder site for my course, wait for the container to start, then click “New” near the top right, and choose “RStudio”. You will be in an RStudio Server IDE where you have access to all of the code and data from the course.

No free lunch

Building and maintaining courses like these are not without costs, of time ⏳ and money 💰. Both Noam and I sometimes struggle with managing questions or requests from learners. “It would be great to have a forum or something tied to the course where students can ask each other questions,” Noam thinks, and I try to make sure folks know about RStudio Community (perhaps specifically the modeling and machine learning category) and other friendly spaces to get help.

There are different ways to host such courses. Noam hosts his via GitHub Pages and I use Netlify. My interactive course gets enough traffic that I exceed the bandwidth of the free starter plan on Netlify. For a little while, I paid Netlify for hosting costs, but then I applied for Netlify’s open source plan for my course, which has worked out great.

Sweet success

An interactive course like this is a somewhat complicated undertaking, but seeing it finished is so satisfying. Florencia says, “To have a look at the course finished and running is definitely the best time of the work!” We also talked about how much we learned ourselves, about new tools and frameworks.

Seeing a course be used by actual real learners is the true test of success. “It is awesome getting messages from students who use the course,” Noam shares. “I always ask graduate students to send me their papers and dissertations.” At a conference this past year, a fellow R user showed me that he had saved the supervised machine learning course as an icon on the Dock on his Mac, and said he had used it to study for getting a job! 🎉 This type of real impact is why we have invested the time and energy into making our courses free and accessible to people around the world.

If you are a professor or content developer, perhaps suddenly needing to create online content, we can’t tell you if this exact course framework is the right option for you. However, we are happy to be able to share these experiences with our community here, so you can take from it what works for you, whether that’s exploring how to use Binder, how to consider the needs of diverse folks with questions, or whether one of these specific resources we created could fit your needs.

ThinkR Shiny Training

Mon, 25 May 2020 00:00:00 +0000

ThinkR is running 10 half-days of remote training on “Shiny in Production” in July 2020. The training will be done in English, and some of the teaching methods are based on the concepts from RStudio’s instructor training program. To reduce confusion while navigating through multiple PDFs, the RStudio IDE, and the file manager, ThinkR has built an e-learning platform that embeds everything learners need in one interface, which you can see at https://rtask.thinkr.fr/remote-trainings-and-certification/. For more information or to register, please go to https://rtask.thinkr.fr/remote-trainings-and-certification/learning-shiny-online-july/.

Instructor Training

Wed, 20 May 2020 00:00:00 +0000

A Remote Learning Roundup

Tue, 19 May 2020 00:00:00 +0000

This post features original artwork submitted by various artists for United Nations Global Call Out To Creatives - help stop the spread of COVID-19.

In March, Desirée De Leon and I did a webinar called “Sharing on Short Notice: How to Get Your Teaching Materials Online with R Markdown." Since then, we’ve watched as many devoted educators have worked overtime to overhaul their teaching materials into remote-friendlier formats on very short notice.

While these new remote learning resources were created first and foremost to replace in-person courses, some instructors went the extra mile to openly share them for everyone. This may include class schedules/readings, slides, videotaped lectures and screencasts, and sometimes even RStudio Cloud projects, making it possible for us non-students to follow along from the comfort of our own homes. This post is a roundup of some of these new open learning resources.

But first, a disclaimer. Most people I know have less free time now, not more. Even if you do technically have free time you could devote to learning, you may not have the cognitive energy to learn anything new. If you fall into either of these two camps, bookmark this post for the future, and then promptly close this browser tab. Please do not let this post make you feel guilty or stressed. Learning will only stick if you feel good while doing it.

Having said that, there are also folks who were caught by this quarantine at a time when they needed to learn new skills to either get a job or get a better job. If you fall into this camp, then you are in luck, because the resources below were created by some of the most engaging and thoughtful educators in data science. And because they were all created relatively recently, you can also be sure that the content is current.

Finally, please keep in mind that these resources are provided as a courtesy by the instructor—if you do decide to use them and have questions or get stuck, ask for help on a dedicated help forum like RStudio Community; do not contact course instructors directly either in private or public (i.e., by tagging them on twitter).

Ready for R

This course is created and taught by Dr. Ted Laderas, an Assistant Professor at Oregon Health and Science University and an RStudio certified trainer. In Ted’s own words:

“This course is meant to be a gentle introduction to using R/Rstudio in your daily work. It aims to teach useful skills (visualization, data loading, data filtering and manipulation, simple statistics) that students can immediately use in their work. No prerequisites or previous experience required. It is not meant to be a substitute for a full programming course or a full course in statistics.”

For external folks, Ted also started a mailing list that will let you know when materials are updated: https://ready4r.netlify.app/mailing/. To compliment these materials, you may also want to check out Ted’s self-paced R-Bootcamp course, created with Jessica Minnier: https://r-bootcamp.netlify.com/.

Robust tools

This course is created and taught by Dr. Danielle Navarro, an Associate Professor at the University of New South Wales and an RStudio certified trainer. Danielle is also a co-author on the work-in-progress 3rd edition of the book “ggplot2: elegant graphics for data analysis” and recently has started sharing her original generative art created with R. This course is unique because it teaches many of the tools that researchers (and really all data scientists) need, but that too often we assume you’ll learn simply through use alone. In Danielle’s own words:

“ Data science with R: A robust toolkit for psychological research covers an introduction to R programming, modern data visualisation and data wrangling, how to structure your projects, version control and how to write professional documents in R. The course is designed for novices, and no preexisting familiarity with these tools and no programming background is assumed.”

Each section in this course features links to an HTML slide deck, YouTube video, and an RStudio Cloud project.

Danielle also has an online resource called “Learning Statistics with R”, originally designed to teach intro statistics to psychology undergrads.

Advanced Statistical Computing with R

These are the materials for a Spring 2020 undergraduate course offered by California Polytechnic State University professors Drs. Kelly Bodwin (an RStudio certified trainer) and Hunter Glanz. In their own words:

“Advanced techniques for efficient use of computers to perform statistical computations and to analyze large amounts of data. Includes version control systems; tools supporting reproducibility; functional programming; randomization and bootstrapping; dynamic data visualizations; and R package development.”

Follow along with their learners using this course schedule.

Week-by-week, Kelly and Hunter provide a curated sequence of readings, videos, and small practice activities with careful time estimates so you know what you are signing up for.

Each week also features a lab assignment and extra challenges so you can practice if you have the time. There is also a public Discord channel so you can learn with others.

Data Visualization

Created by Professor Andrew Heiss at Georgia State University, also an RStudio certified trainer, this website is an asynchronous online course — with hours of video, interactive code, code examples, and all sorts of neat stuff! From Andrew’s course description:

“Use R, ggplot2, and the principles of graphic design to create beautiful and truthful visualizations of data”

All materials are open source and creative commons licensed, so anyone can adapt and improve it later.

A personal aside: this beautiful website is built using the Hugo Academic theme with the R blogdown package. You can see the source code for the website on GitHub. Andrew’s website is another great example of a course website that was shared on short notice!

Get Started with tidymodels

We recently launched the new tidymodels.org website. If you don’t know what that word means, it is a collection of packages for modeling and machine learning using tidyverse principles. One of the most popular resources on the new website is the Get Started section. It features five articles, starting with how to create a model and ending with a beginning-to-end modeling case study. While there are no interactive exercises (yet!), you can copy/paste the code to work through the materials locally. Be on the lookout for integrations with RStudio Cloud and learnr tutorials that will work within the IDE after our summer intern, Ezgi Karaesman, works her education magic 💫

Supervised Machine Learning Case Studies with R

This self-paced course is newly updated to use the tidymodels framework for predictive modeling, brought to you by Julia Silge. Julia is a member of the tidymodels software engineering team, an RStudio certified instructor, and prolific data science blogger (don’t miss her #TidyTuesday posts with video screencasts!). When I first started my own machine learning journey, Julia’s course was a welcome break for me from predicting home prices in Ames, Iowa. Julia has a talent for explaining complicated things in simple terms, and the whole course is a breath of fresh air if you’ve been trying to learn machine learning by wading through stuffy textbooks. I was lucky enough to get a preview of this revised version, and wholeheartedly recommend—it is a great interactive compliment to tidymodels.org.

Applied Machine Learning

Scikit-learn developer and Columbia University Associate Research Scientist Andreas Mueller has shared his 2020 Applied Machine Learning course. This includes a schedule with links to all his slides (including presenters notes!), and 21 videotaped lectures in a YouTube playlist. Obviously, this is not an R course; it is in Python 🐍. Regardless, any data scientist can benefit from these materials, and it may give you R lovers an excuse to test out using Python and the reticulate package.

R-Hub for Package Developers

Maëlle Salmon, a research software engineer with ROpenSci and member of the RLadies Global team, has been diligently cataloging a treasure trove of knowledge for package developers to ease all steps of the R package development process. This project has been funded by the R Consortium.

Check out her work on the R-Hub documentation site: https://docs.r-hub.io/

And related series of blog posts here: https://blog.r-hub.io/

Remote RLadies Meetups

Finally, if you are craving some socially distant social interactions with your learning, many RLadies meetups have gone online. You can see all the future events anywhere in the world here: https://www.meetup.com/pro/rladies/

I hope these resources are useful if you are able to learn now, or even if you are just daydreaming about a time in the future when you’ll be able to get lost in learning something new again. Hang in there.

Teach R with learnr: a powerful tool for remote teaching

Tue, 19 May 2020 00:00:00 +0000

The unexpected switch to remote instruction has been a challenge for teachers and learners, and has inspired - or for some, forced - the use of innovative teaching methods and tools. Coding lessons pose a unique challenge for remote instruction as teachers are unavailable for in-person troubleshooting, and beginning students are unlikely to have developed debugging or reprex-building skills. On top of coding-related challenges, students might not have access to a device on which they can install R and RStudio.

So, how can we create live coding lessons to include participants who…

…have not used or installed R and RStudio?
…are unable to quickly get in-person troubleshooting help during live lessons?

The learnr package offers a solution to both. In this post, I describe why and how I created a learnr tutorial on Exploring missing data in naniar with both first-time and experienced R-users in mind.

1. Approachable for first-time R users

For my remote lesson on exploring missing data (using Dr. Nick Tierney’s naniar package), I expected a combination of:

Advanced R users
Beginning R learners
Attendees who had never used or seen R & RStudio before

Usually, I have students fork and clone materials from a GitHub repo so that they can follow along in the RStudio IDE (Desktop, or through RStudio Cloud). For my live lesson, I wanted everyone - even those who had never used or seen R/RStudio before - to be able to write and run R code successfully, and I didn’t want those first-time R-users to need to navigate the IDE at the same time.

learnr tutorials look and feel like a simple website

I love the RStudio IDE. If you’re reading this, you probably do, too. But try to remember what it felt like the first time you opened it. There is a lot there, and it takes a long time to feel really comfortable navigating it. Eventually, most R-users will need to become good friends with the RStudio IDE. But for first-time users working remotely and without hands-on help, a learnr tutorial - which looks like a simple, easy-to-navigate website - could be a more familiar and welcoming entry.

For example, here is what my Exploring missing values in naniar tutorial looks like:

No installing or importing necessary

Both RStudio Cloud and learnr solve this problem. No need for R, RStudio, or package installation for learners to get up-and-running. And in learnr, learners don’t even need to read in data; it can already exist as a pre-stored object (e.g. data frame) that can be directly referred to throughout the tutorial. That means that tutorial users can immediately start exploring and playing with the data at virtually no start-up cost. Again, reading in data and naming objects are critical skills that every user will eventually need to learn. Let them learn it later. Let the first time be just the awesome stuff with learnr.

2. Customized hints and solutions

Another major hurdle of remote teaching is how to help students when they get stuck. learnr solves this problem in several ways.

You decide the starting point

Writing code from scratch can be intimidating for first-time users. In learnr tutorials you decide what code already exists, and users can build on that.

For example, you can pre-populate a code example for a basic graph with ggplot2, and users could just add or update variables for the x- and y- aesthetic. Even better: there is no risk of them breaking it. For each code example, there is a button in the top left to “Start Over,” which will return the code to the original.

In the exercise below, there is existing code to make an UpSet plot to explore co-occurrence of missing values:

Hints

This might be my favorite thing about learnr - it’s easy to add one or more customized hints that students can look to when they get stuck. When learners are working through tutorials on their own, I think this is an awesome option to lead them along without giving away the answer.

Solutions

If you want users to be able to see the full solution, you can make that easily available too. This is especially useful in a live-coding demo, when participants can fall behind if they need to troubleshoot or read through a sequence of Hints. Once a solution is created, a Solution button will appear in the code exercise. There’s even a convenient ‘Copy to Clipboard’ button built-in.

Learn how to add solutions, hints and more to your learnr tutorial here!

3. Customize your tutorial with CSS

I wanted the look of my learnr tutorial be highly customized. That meant some CSS, and involved just a few steps:

Making a new /css directory in my tutorial project
Creating a new .css file in it
Adding that to the YAML output format (see more in Section 3.1.4.1 here)
Update CSS with a lot of googling, ‘Inspect Element’ and trial & error

Here are some of the custom CSS changes I made for the biggest differences with the smallest effort:

Update header color and font

Customizing <h3> header:

h3 {
  color: teal;
  font-family: 'Roboto Slab', serif;
}

…and similar to customize other heading levels (h1, h2, etc.).

Remember that if you are using google fonts (like Roboto Slab here) you’ll need to set that up.

Update body background & font

body {
  background-color: white;
  font-family: 'Source Sans Pro', sans-serif;
  font-size: 12;
}

Tons of options to update the overall menu look:

.topicsList .topic {
    font-family: 'Roboto Slab', serif;
    line-height: 40px;
    font-size: 15px;
    padding-left: 10px;
    cursor: pointer;
    background-repeat: no-repeat;
    background-size: 2px 80px;
    background-position: left 100%;
        background-position-y: 100%;
    background-image: url(images/topicProgress.png);
    border-bottom: 1px solid teal;
    -webkit-transition-property: background-position;
    transition-property: background-position;
    -webkit-transition-duration: 0.25s;
    transition-duration: 0.25s;
}

And this stuff changes the look & color of the menu item you click on:

.topicsList .topic.current {
    font-family: 'Roboto Slab', serif;
    background-color: orange;
    color: #ffffff;
    border: 0px;
}

…plus a bunch more stuff, but those are some that made me the happiest with the look of my tutorial with minimal effort.

Font awesome icons!

Icons are great for organization and visual interest in course materials. I used icons to indicate coding examples, exercises, and critical thinking questions. Install and attach the fontawesome package in R to add Font Awesome icons directly to your tutorial.

For example, this…

fa("fas fa-bug", fill = "orange")

…adds this:

4. Sounds great, but can it handle my class size and usage?

This was one of my biggest concerns about running a live lesson with a learnr tutorial: given limitations on hours & data, would the app (hosted through shinyapps.io) crash when everyone tried to use it?

RStudio’s Barret Schloerke directed me to this essential post by Angela Li (), which answers this question exactly. Following Angela’s super helpful post, and expecting ~75 people to simultaneously start and use the app for ~30 min during the lesson, I decided to:

Upgrade my subscription to Standard ($99/month - check with your school / university to see if they already have a shinyapps.io subscription or could get one to support teaching)
Max out instances (to 5 with a Standard subscription)
Max out instance size (XXXL - 8 GB)
Set Max Worker Processes to 2
Set Max Connections to 17
Set Start Count to 5

See Angela’s post for more information on what these actually do, and to help you decide on settings for your tutorial based on class size and needs.

5. Summary

I feel that learnr is a great option for coding lessons and activities, especially for remote instruction with beginning R users.

For me, the biggest benefits of learnr are:

Looks and feels like a simple website (great for first-time R users, knowing that eventually they’ll need to work in RStudio IDE)
No account, login, or installations necessary
Pre-populated code exercises, hints and solutions ensure no one gets left behind in the absence of in-person troubleshooting
Data / objects already exist - no need for beginners to import data or store objects
Easy to publish and share (no forking/cloning/emailing materials)
Relatively easy to customize with CSS

Some potential drawbacks:

You may need to upgrade shinyapps.io subscription to suit course needs
If you hate CSS, you might not love customizing (I did a lot of Inspecting Elements, and ended up really enjoying it and learning a lot)

My overall rating of learnr as a teaching tool: five stars. Give it a shot, and have fun teaching and learning with a learnr tutorial!

Decorate your R code with flair

Mon, 04 May 2020 00:00:00 +0000

Update: Watch a 15 minute talk about this package:
https://kbod.win/talks/user_2020
https://youtu.be/sXFJ_AZ4jeA

It is my distinct pleasure today to introduce you to the flair package.

The following is an example of the type of classroom disaster that motivated this package:

You are presenting an analysis to a class or audience, and you turn to a slide where you show both source code and its output. Because you wanted to emphasize a line of the source code, you copy-pasted the code text into the slide, and added highlighting to the relevant section.

Upon opening the slide, you realize with creeping horror that you made a change in the source code, but you forgot to edit your slide. The code text displayed on your screen no longer matches the output, and your students are confused.

Was this relatable? Have you, too, lived out this horror story?

This kind of un-reproducibility of materials, and the simple frustration of the fiddly nature of manually highlighting code text, led me to develop flair. I wrote this package first and foremost for educators, although I have found it equally useful for conference talks and workshops.

You can find the basic package documentation and vignettes at this site. Today, though, I want to take the time to show you a few of my favorite examples of flair in action, to give you an idea of how it might be useful in your classroom or presentation.

These examples all use the baby_names dataset from https://www.kaggle.com/kaggle/us-baby-names, which contains counts of babies born with each given name, in each state, since the 1800s. We’ll restrict our data only to babies born in California with the first name “Kelly”. You can download this data to follow along.

Example 1: Emphasize small differences in code.

The most default ability of flair is quickly adding basic highlighting to code.

There are a lot of use cases of this simple functionality. I am particularly fond of using the flair() function to show how small changes in code impact the output.

For example, suppose I am teaching the concept of geometries in ggplot. I wish to plot the number of babies born each year with the name “Kelly” in California, colored by gender assigned at birth.

I have made two different plots; one using columns, and one using lines. The code chunk for my work looks like this:

```{r geoms, include=FALSE}
baby_names %>%
  ggplot(aes(x = Year, y = Count, fill = Gender)) +
  geom_col()

baby_names %>%
  ggplot(aes(x = Year, y = Count, color = Gender)) +
  geom_line()
```

With the decorate and flair functions, I can trigger this code chunk to be evaluated, while simultaneously adding highlighting to the chosen parts of my code.

Ordinarily, we would use echo = FALSE on the first chunk below, so as not to see the flair() process.

decorate("geoms") %>%
  flair("_col") %>%
  flair("fill = ") %>%
  flair("_line") %>%
  flair("color = ")

baby_names %>%
  ggplot(aes(x = Year, y = Count, fill = Gender)) +
  geom_col()

baby_names %>%
  ggplot(aes(x = Year, y = Count, color = Gender)) +
  geom_line()

Note: If you have many pieces of code to flair, and you don’t want to manually specify everything, the flair_rx() function lets you input regular expressions instead of fixed strings.

Example 2: Match colors to concepts.

When teaching, we often want to link concepts to code, like in this beautiful flair-created slide by Andrew Heiss:

Coloring different pieces of your code different colors is straightforward with flair(). For an extra shortcut, you can also pipe strings though the flair functions to color parts of your text, and even add your own special html tags if you wish.

Code Chunks:

```{r, results = "asis", echo = FALSE}
"This model has a response variable, two predictors, and an interaction term." %>%
  flair("response variable", color = "deeppink") %>%
  flair("predictors", color = "cornflowerblue") %>%
  flair("interaction term", color = "orange") %>%
  flair_all(before = "<h4>", after = "</h4>") %>%
  cat()
```


```{r, echo = FALSE}
decorate("lm") %>%
  flair("Count", color = "deeppink") %>%
  flair("Gender:Year", color = "orange") %>%
  flair_rx("Gender |Year ", color = "cornflowerblue")

```

Results:

This model has a response variable, two predictors, and an interaction term.

mod <- lm(Count ~ Gender + Year + Gender:Year, data = baby_names)

summary(mod)


## 
## Call:
## lm(formula = Count ~ Gender + Year + Gender:Year, data = baby_names)
## 
## Residuals:
##     Min      1Q  Median      3Q     Max 
## -625.27 -128.36  -13.67  155.13  943.86 
## 
## Coefficients:
##               Estimate Std. Error t value Pr(>|t|)
## (Intercept)   837.0953  3555.4360   0.235    0.814
## GenderM      2769.6513  4980.9342   0.556    0.579
## Year           -0.1064     1.7965  -0.059    0.953
## GenderM:Year   -1.6660     2.5171  -0.662    0.509
## 
## Residual standard error: 337.2 on 147 degrees of freedom
## Multiple R-squared:  0.3876,	Adjusted R-squared:  0.3751 
## F-statistic: 31.02 on 3 and 147 DF,  p-value: 1.357e-15

Example 3: Mask code for easy practice activities.

Last but not least, my absolute favorite usage of flair is the mask() function for hiding segments of code. This feature was originally suggested by Alison Hill, and it has quickly become my most-used function in the package!

Suppose I am teaching ggplot, and I want students to understand the Grammar of Graphics framework. I would like for them to have practice identifying a few key elements of the plot:

Which variables are being used for which aesthetic elements.
Which geometries are being used to make the plot.
Which theme_*() function is being applied to the plot.

Thus, I can create the following challenge: Fill in the code blanks, based on the plot output.

library(ggplot2)

baby_names %>%
  ggplot(aes(y =      , x =     , color =       )) +
  geom_     () +
  geom_    () +
  theme_     ()

Here I have hidden the flair chunk, so that you can see the exercise as the students do. This is what it looked like:

```{r, echo = FALSE}
decorate("plot") %>%
  flair_rx("ggplot2?", background = "pink") %>%
  mask("Count") %>%
  mask("Year") %>%
  mask("Gender") %>%
  mask("point") %>%
  mask("line") %>%
  mask("light")
  
```

Students learning to code in R will often quickly figure out how to write code and guess-and-check until the output matches what they wanted. However, it’s also important that they be able to think ahead, and anticipate what each piece of the code will influence in the output.

Fill-in-the blank activities are a great way to practice, and masking with flair makes creating these activities quick and easy!

Wrap-up

You can try out the code in this blog post in this RStudio Cloud project. In general, flair can be used with most R Markdown HTML-based output formats, including slide makers like ioslides and xaringan. It is unfortunately not yet possible to knit to pdf or MS Word files with flair formatting - although we hope to provide that functionality in the future.

If you have any ideas for future flair abilities that would make your teaching and presenting easier, please don’t hesitate to file an issue on GitHub, or to reach out to me personally.

We hope that flair makes your code-presenting process a bit more simple, reproducible, and enjoyable.

Happy flairing!

Newly certified instructors in April 2020

Thu, 30 Apr 2020 00:00:00 +0000

We are very pleased to have welcomed thirteen new certified instructors in April 2020, including our first from Hungary and Ireland:

Carlos Agüero (Tidyverse)
David John Baker (Tidyverse)
Ildiko Czeller (Shiny and Tidyverse)
Jim Duggan (Tidyverse)
Bradford Dykes (Tidyverse)
Fodil Ihaddaden (Tidyverse)
Michael Irvine (Tidyverse)
Jim Leach (Tidyverse)
Ross Manley (Tidyverse)
Matthew McDonald (Tidyverse)
Danielle Navarro (Tidyverse)
Sam Rogers (Tidyverse)
Svetlana Vinogradova (Tidyverse)

This brings the total number of certified Tidyverse instructors to 107, and the number certified to teach Shiny to 18. If you would like to speak with any of them about your training needs, their contact information is on the trainers’ roster and they would be happy to hear from you.

Country	Number of Certified Instructors
Algeria	1
Argentina	3
Australia	4
Austria	1
Belgium	2
Canada	7
Costa Rica	3
Czech Republic	1
France	7
Germany	3
Hungary	1
Indonesia	4
Ireland	1
Israel	1
Italy	1
Kenya	1
Netherlands	1
Puerto Rico	1
Senegal	1
South Korea	1
Switzerland	1
Thailand	1
Trinidad and Tobago	1
United Kingdom	14
United States of America	46

Announcing 2020 Interns

Wed, 08 Apr 2020 00:00:00 +0000

We received almost two hundreds applications for this year’s internship program, and while we wish we could have offered positions to everyone, in the end we were only able to select five:

Simon Couch: tidymodels package support
Ezgi Karaesmen: interactive tutorials for tidymodels.
Devin Johnson: support for people working with spreadsheets in R.
JooYoung Seo: accessibility improvements.
Nischal Shrestha: interactive tutorials for Python.

They will all start in May, and will blog here regularly about their progress—we are looking forward to working with them.

First year of instructor training

Mon, 06 Apr 2020 00:00:00 +0000

RStudio’s instructor training and certification program has been running for a year now, so it’s time to take stock of what we’ve accomplished and what we’ve learned. The first part is easiest: of the 280 people who have taken part in the training course, 95 have certified as tidyverse instructors and 17 as Shiny instructors. A combined 35% completion rate may seem low, and at first glance the completion rates seem to have dropped over time:

However, this is pretty clearly because most people take a while to complete their exams:

Setting aside the first class at rstudio::conf 2019 the overall completion rate seems to be hovering around 45%, and the average time a little over 100 days. We’d like to increase the first figure and lower the second one, but overall we’re pretty happy.

The more important question is what impact the training is having. Feedback from participants has been positive, but that’s obviously biased in several ways. so we plan to launch a survey later this month to get more information. We will also watch what happens now that the IDE supports integrated tutorials: I will personally mail a box full of stickers to the first person who puts a concept map in the new tutorial pane.

The biggest question right now, though, is whether we helped prepare people for the seismic shift in teaching and training caused by the COVID-19 pandemic. Our webinars have summed up key points about general teaching practices, using rstudio.cloud for teaching, and sharing materials online with R Markdown; we hope that our lessons and other material gave people more to draw on, but the only way to find out will be to ask them in a year when the dust has settled and we can see what has changed for good.

If you would like to take part in training, please see this blog post or read a fuller description at https://education.rstudio.com/trainers.

Sharing on Short Notice

Mon, 06 Apr 2020 00:00:00 +0000

Thanks to everyone who joined us for last week’s webinar on how to share your teaching materials online— on short notice— with R Markdown. We weren’t able to get to all of the questions that were asked during the webinar, so here are answers to all of them.

Slides at https://rstd.io/sharing
https://github.com/rstudio-education/sharing-short-notice
Video
If you have any other questions, please don’t hesitate to post on RStudio Community

Questions about R Markdown

I’m a newbie to R Markdown. I’m a writer but not really a coder. Where can I start to with all this?

RStudio has some self-paced online tutorials for getting started with R Markdown. Also, the Communicate section of the book R for Data Science gives a great overview of the basics of R Markdown. To learn about the different types of output formats available, we recommend R Markdown: The Definitive Guide by Yihui Xie, J. J. Allaire, and Garrett Grolemund.

For the website building tools we covered, here are some specific resources:

Figure 1: A climb up R Markdown Mountain

How can you incorporate learnr exercises in R Markdown HTML output?

This is a bit tricky, but possible! Desirée has done this extensively on her Teacupes, Giraffes, and Statistics R Markdown website. She also wrote a blog post with instructions.

Figure 2: Embedding learnr in R Markdown

Questions about the RStudio IDE

My RStudio IDE doesn’t have Build. Could you share how to show it?

Somtimes you’ll need to restart the RStudio IDE to detect the output format and show you the correct “build” button on the Build tab.

Figure 3: Build tab in the RStudio IDE

Here is a bit more discussion on this, and how to use the .Rproj file to debug (hint: you are looking for BuildType: Website!).

Questions about Netlify

Because we focused on how to share your teaching materials online on short notice, we introduced Netlify Drop. Here are a few questions about that.

Can you change the name of the Netlify link (while keeping the Netlify subdomain)?

Yes! By default, Netlify provides you a sometimes amusing, random Netlify subdomain. See this slide for how to change your site name, keeping the Netlify domain ___.netlify.com; the video below walks you through those steps.

Figure 4: Changing the Netlify subdomain

Can you choose a web address for Netlify?

Yes! The Netlify docs contain instructions for setting up custom domains.

Any preferences between using Netlify vs. Travis-ci for continuous integration?

I use Netlify mainly for continuous deployment. This means that I connect Netlify to a Git repository and the two things- my source files and my website- are kept in sync. Then every time I commit and push changes to Git, my updated website automatically deploys without me having to remember to manually update my site.

For blogdown websites, this workflow is particularly nice because Netlify can use Hugo to build my site from my source files, but I still need to serve the site locally first because Netlify does not know R.

Travis does know R, so I have used that for continuous integration of HTML books created with bookdown, as with the Stat545 website. Lately, many users are testing out GitHub Actions with R Markdown-based sites with success. For example, Emil Hvitfeldt wrote up some great instructions for using GitHub Actions with Netlify for a bookdown book. Similarly, here are some instructions for using GitHub Actions with a blogdown website, which is set up for the tidyverse.org site. There is a ghactions R package that can also help.

Can you make a private site using Netlify for free?

No, site passwords are not in Netlify’s free tier.

Questions about bookdown

Can bookdown export to PDF or Word docs as well as HTML?

Yes- the bookdown package enables several different output formats. We focused on only one of the HTML output formats: the GitBook style.

I tried the Netlify Drop and worked great. I tried afterward to link it to the respective GitHub repository, but when it tried to build it I got an error. I used the build command npm run build, and the directory _book.

Netlify cannot build your book for you- your bookdown book needs to be built with the bookdown R package in RStudio. When you use Netlify, you don’t use a build command at all, but you should change the publish directory to the _book/ sub folder.

Questions about blogdown

Is it waaaaaay simpler to use Blogdown?

No. This blog post by Maëlle Salmon, who has developed several Hugo websites using blogdown including ROpenSci and R-Hub Documentation, is a great overview of what you need to know. As we mentioned in the webinar, unless you have high HTML fluency and high degree of comfort working with websites, we don’t recommend you start here if you are sharing on short notice and this would be your first blogdown project.

Why does signing up to Netlify using a version control account make your life easier?

Wiring up your version control account (i.e., GitHub, BitBucket, GitLab) with Netlify is a good thing ™️. This is because it enables you to continuously deploy your website, so that every commit/push that changes your source files triggeres the site to be re-built.

What should I do if I want to update the blogdown theme?

First, I do not recommend updating your blogdown theme while teaching a course. Ask me how I know.

Figure 5: Alison's blogdown advice

But, if you must update an already installed theme like for example "gcushen/hugo-academic", use:

blogdown::install_theme("gcushen/hugo-academic", 
                        force = TRUE, 
                        update_config = FALSE,
                        theme_example = FALSE)

Then, I would look at the new example site, now located in themes/hugo-academic/exampleSite. First, look at the site configuration files (config.toml plus any .toml files in config/_default/) and update manually. You’ll also want to look at the YAML in the updated example site to see if that changed as well.

It is possible to deploy a blogdown site, not in Netlify, but in Github?

Yes it is possible.

Questions about “behind the scenes”

How did you make such neat screen recordings? They were great for teaching!

Desirée made the videos in the webinar using a Mac OSX app called Kap, an open-source screen recorder. Here is an example video, which shows how to use the “Deploy to Netlify” button we demoed from this GitHub README:

Figure 6: Demo of the 'Deploy to Netlify' button

In the Kap app preferences, we selected “Highlight clicks”, which creates that circle halo around the cursor when you click on the screen (you can see it about 7 seconds in to the video above). She also magnified the mouse pointer by changing an OS-specific setting before recording.

Thank you

We really enjoyed making and delivering this webinar. We have so enjoyed seeing all the sites already built and shared so far!

Figure 7: Bye!

Teaching online with RStudio Cloud

Wed, 01 Apr 2020 00:00:00 +0000

Thanks to everyone who participated in last week’s webinar on Teaching online with RStudio Cloud. We weren’t able to answer all of the questions that were asked during the webinar while we were online, so here are answers to all of them. If you have any other questions, please don’t hesitate to post on RStudio Community.

🖥 Slides
📽 Video

Course administration

Does rstudio.cloud integrate well with Moodle?

There is currently no learning management system (LMS) integration, however this is something the engineering team has on their radar. See below for how students can submit their work on your LMS.

How do students download files from RStudio.Cloud? For example, how do they submit assignments to the learning management system we use?

One option is is to export and download the file from rstudio.cloud. In the example below, I’ve checked the csv file I want to download, clicked “More”, then Export. If multiple files are selected, they are combined into a zip file.

You might have other options to submit homework, for example submitting the cloud project, or if you want to get advanced, ask students to push to a Git repository.

Do I need a separate space for each group of students if I have more than one?

This depends on what you mean by “group”. I recommend keeping students who are exposed to the same material and assignments in a single workspace, even if the course has multiple sections (e.g. multiple lab/workshops sections but same lectures, assignments, assessments).

For different courses (covering different materials and with different assignments) use separate spaces.

I think about it as one workspace for each course I teach.

Should I want to assign a different project to each different group of students, should I create different workspaces or could I have one workspace and create different projects within it with different access privileges so that students can access only the project assigned to them?

It is currently possible to open project access to a subset of students in a workspace. If you wanted to do this you can either create separate workspaces (as described in the previous question) or use the share a single project option for specific groups of students.

Is it possible to correct homework automatically? Or do we need to visualize each student’s answers?

There is no autograding on RStudio Cloud currently.

In the 2nd option (shared workspace), is it possible to share a link with students to the specific project being assigned within the class workspace so they don’t have to go looking for it? I’m thinking of the idea of including the URL in my LMS.

Yes, you can do this. The student will need to be enrolled in the workspace first. Then, create the project and make it an assignment. Then, you can add a link to the project, and when the student clicks on that link it will be equivalent to starting an assignment. Student can then leave and come back, and they will see a Continue instead of Start button for the assignment.

How to

How do you load a data set or existing files into the cloud? {related} What’s the process for sharing data files, just load them into the workspace?

In the Files pane, click on upload, then browse your computer to find and upload the file.

You said that for sharing a project with students there are two main ways. In the first way they have to make a copy of the project in order to not to lose the changes. Can you show how to do this?

When a student goes to your shared project they’ll see a blinking red text that says “TEMPORARY COPY” and next to it is a button to “Save a Permanent Copy”.

How can you SET the base project?

This video walks you through the steps for setting a base project. Briefly,

Create a new project and install any packages, add any files, etc. you want in your base project.
Name this project something you’ll recognise (I like naming them base).
While in the project, click on the gear icon on the top right, then on Access, and set the project to be visible to everyone in the workspace.
Then, go back the homepage of your workspace.
Click on the gear icon on the top right, and you will see a menu where you can set your base project. Click on the three dots to pop open a window where you can select the project you want to set as base.

Collaboration / assistance

When peeking into a student’s project, can the instructor directly edit and run code?

Yes! The only thing to be aware of is that two people can’t be in the same project at the same time. So my recommendation is to ping your student before you peek into their project.

Can a student also have their workspace open when me (instructor) “peeking” in? My experience is that having me in their workspace crashes their session.

Two people can’t be in the same project at the same time, so my recommendation is to ping your student before you peek into their project.

Can you suggest any sources I can read/see that can help me to use rstudio.cloud with my research group instead of my class? e.g. start large experiments, reproducibility…

I’m not aware of something official written about this but a few ideas come to mind:

I would create a workspace for the group, if anything, to keep things organised and in one place.
I imagine you would want members of your research group to make their work visible to others, so you can relax the permissions for members to change visibility of their projects.
The assignment feature might not be relevant, you can make projects visible to others without making them into assignments.
RStudio Cloud projects are great for collaboration, but note that two people cannot work on the project at the same time. So people will either need to take turns editing a project, or if your research group uses version control, they can of course use a service like GitHub for the collaboration aspect.

Can students collaborate on projects?

There is no concurrent collaborative editing of projects – so your students couldn’t collaborate like they might do on a Google doc – so this is important to note. But there are a few approaches to collaboration:

If you also teach version control, you can have a single repo on GitHub that all students in a group has access to and they clone this repo on their individual RStudio Cloud accounts within your course workspace and they can push their changes to the repo. This is the approach I use in my data science courses. You can read more about here and here.
If not, one possible approach is to have you (instructor) or students in a team create an RStudio Project outside of a workspace and share with team members. Currently, there is no way to share a project with specific individuals within a workspace.

Is there an integrated chat system in rstudio.cloud like Slack, so students can ask questions and I as instructor can answer? I currently use Slack, but it would be nice to have it all in one place?

There is not.

Limits

What is the individual file limit RStudio.cloud projects? e.g., GitHub has something like 100MB limit per file] {related} Are there file size constraints with RStudio Cloud?

Each project is allocated 1GB of RAM.

Do we have to ask for permission to add more than 10 students for each workspace? or can I ask a single time? {related} It seems like we do not need to request anything if our group is under 25 students, is that correct?

Each account is allocated one private space, with up to 10 members (including the workspace admin, i.e. the instructor) and 25 projects. You can submit a request to the RStudio Cloud team for more capacity if you hit one of these space limits, and we will do our best to accommodate you. You do need to put in a request for an increase in members for each workspace. If you are using a Professional shinyapps.io account, you will not encounter these space limits.

I’m teaching an “Intro to Deep Learning” course online next month and this looks like it could solve a lot of issues I think I might have with controlling 60-70 different installs etc., but they will probably need substantial computation time. Is there anything I should take into account specifically on the computation-side of things in RStudio Cloud?

You will want to try out your assignments with the default memory limit, and if you find that it’s not sufficient, you can request a memory increase.

R Packages

Are there some packages that we can not use with RStudio Cloud ?

There are some R packages that require system libraries. If you’re using a package that uses a system library that is not available in RStudio Cloud, you won’t be able to use that package as currently it’s not possible for users to install these. We recommend posting this on RStudio Community as a request to install the system library and the RStudio Cloud team should be able to help.

Is there a trick to installing packages from github? Getting rate limiting error.

There isn’t a trick, devtools::install_github() works. The answer might depend on the package you’re installing though.

Service issues

Have you had trouble with RStudio cloud not working during teaching? I was using it in class in late January (first day of class) and none of us could login. It worked before and after class, so I think there was a problem with RStudio cloud itself. I had to improvise and show how to use desktop version. This only happened to me once out of 4 lab sections. But does it happen rarely or often?

This is certainly not a regular occurence, but we also know that some users have found themselves in this situation if their class happens to be running during a system outage. If this happens again I would recommend checking https://status.rstudio.com/. If RStudio Cloud is noted as operational there, the issue might be something on your end (e.g. WiFi failure?). You might also be the first person to encounter the issue, so we would very much appreciate if you can report any such issues on RStudio Community or by emailing support@rstudio.cloud, but we appreciate that you probably won’t get to do this in the middle of teaching.

Miscellaneous

When the paid plan is available, will free features be limited and if so, which ones?

We’ve not yet finalized the pricing plans for RStudio Cloud. However, I can say for sure that we will have a free plan. The free plan may include restrictions on amount of CPU, memory, and storage resources that may be used, and may have limits on the number of members and projects that can exist within a space.

I had a problem with RStudio Cloud to connect it to the relational databases. How do you use RMySQL, DBI… packages on RStudio Cloud?

Connecting to databases from RStudio Cloud is supported using a wide variety of packages. However, you may need to contact your network administrator to allow access to your firewall so that the RStudio servers are able to connect to those databases. Information can be found in the guide: https://rstudio.cloud/learn/guide#external-access

Can we run code chunks in, e.g, python or C?

Yes. Python, RCpp, and C chunks in RMD documents are supported. Please, keep in mind memory limitations might affect the ability to compile some chunks.

Any tips to make projects open fast? What causes projects to load slowly?

Project opening performance is something we’re actively working on improving. There are a number of issues that can cause things to open slowly that we hope to address in the near future. A couple of things to keep in mind to reduce opening times: 1) Ensure you’re on a fast and reliable internet connection. 2) Avoid having loading very large files into your R session at startup.

Lessons

Can I get an example of a file on git that could be used to create a new class and/or project?

Here is an example of a repository that is an assignment in an introductory data science course. Note that in my course I would have made copies of this repo for each student (with the repo name appended with student’s GitHub name) that only that student and myself can view. You can do this sort of making many copies of repos for students using the ghclass package in R or using GitHub Classroom.

Each student would then take the URL of their repo with these started documents and create a New Project from Git in the course workspace (so one repo -> one project). This RStudio Cloud project would be populated with these starter documents and also would have the R packages they need installed (coming from the base project in RStudio Cloud).

And for completeness, here is the assignment instructions.

So you have some examples of data wrangling with R?

There are great examples among our primers, especially in the Work with Data and Tidy Your Data primers.

Newly certified instructors in March 2020

Tue, 31 Mar 2020 00:00:00 +0000

We are very pleased to have welcomed nine new certified instructors in March 2020:

María Paula Caldas Rivera (Tidyverse and Shiny)
Colin Fay (Tidyverse and Shiny)
Cervan Girard (Tidyverse and Shiny)
Marly Gotti (Shiny)
Vincent Guyader (Tidyverse and Shiny)
Brad Lindblad (Tidyverse)
Daryn Ramsden (Tidyverse)
Sebastien Rochette (Tidyverse and Shiny)
Gregor Thomas (Tidyverse)

If you would like to speak with them or any of our other trainers, their contact information is on the trainers’ roster and they would be happy to hear from you.

Tips for Making a New Cheatsheet

Fri, 27 Mar 2020 00:00:00 +0000

Shortly after Winston Chang and I were hired by RStudio, I was surprised to spot his name at the bottom of a LaTeX cheatsheet that I had used all through grad school. His idea was too good to waste; and soon after, the first RStudio Cheatsheet was born!

Since then RStudio cheatsheets have appeared in classrooms as learning aids, flown off tables as marketing material, and thrilled rstudio::conf goers as a particularly cherished piece of conference swag. They’re downloaded over 10,000 times a week from https://www.rstudio.com/resources/cheatsheets, and they’ve inspired an army of community created cheatsheets.

You can create your own cheatsheets to explain, popularize, and market your favorite R packages (and if you do I’d be happy to share them—send me a pull request at https://github.com/rstudio/cheatsheets). Having developed quite a few, the guide below describes everything I’ve learned from making and honing cheatsheets.

RStudio cheatsheets are not meant to be text or documentation! They are scannable visual aids that use layout and visual mnemonics to help people zoom to the functions they need. Think of cheatsheets as a quick reference, with the emphasis on quick. Here’s an analogy:

A cheatsheet is more like a well-organized computer menu bar that leads you to a command than like a manual that documents each command.

Everything about your cheatsheet should be designed to lead users to essential information quickly. If you are summarizing the documentation manual, you are doing it wrong! Here are some tips to help you do it right:

Getting Started

RStudio cheatsheets are hosted at https://github.com/rstudio/cheatsheets. You can submit new cheatsheets to the repository with a pull request.
The files keynotes/0-template.key and powerpoints/0-template.ppt are official templates that contain some helpful tips.
You may find it easiest to create a new cheatsheet by duplicating the most recent Keynote / Powerpoint cheatsheet and then heavily editing it—that’s what I do!

Process

Budget more time than you expect to make the sheets. So far, I’ve found this process to be the least time consuming:

Identify which functions to include by reading the package web page and vignettes. I try to limit my cheatsheets to the essentials.
Organize the functions into meaningful, self-explanatory groups. Each group should address a common problem or task.
Think about how to visualize the purpose of each function. Visual mnemonics are easier to scan than text, which all looks the same.
Think about what key mental models, definitions, or explanations the cheatsheet should contain in addition to the functions. Ideally, use these to explain the visualizations.
Sketch out several possible layouts for the sheet. Take care to put the more basic and/or pre-requisite content above and to the left of other content. Try to keep related content on the same side of the page. often your final layout will itself be a “mental map” for the topic of the cheatsheet.
Type out all of the explanations and function descriptions that you plan to include. Lay them out. Use placeholders for the visuals. Verify that everything fits. White space is very important. Use it to make the sheet scannable and to isolate content groups. Retain white space, even if it means smaller text.
Make the visuals. They take the longest, so I save them for last or make them as I do step 6.
Tweak until happy.

Visual Design

Use the existing theme that you see in the cheatsheets. It is cohesive and black and white printer friendly.
Choose a highlight color to use throughout your cheatsheet, and repeat this highlight color in the background of the top right corner. Ideally you could find a color that is different enough from the other cheatsheets that you can quickly tell yours apart when flipping through a booklet of cheatsheets.
Use a second color sparingly or not at all to draw attention to where it is needed and to differentiate different groupings of content.
Include lots of white space.
Visually differentiate groups of content. Backgrounds, boxes, side bars, and headers are helpful here. It is very useful for the user to know immediately where one group of content begins and where one ends. Our “gradation headers” fail here, so think of better solutions if possible.
Align things to guides, i.e. align things across the page. It helps define the white space and makes the cheat more orderly and professional.
Make the text no smaller than ~10pt.
If the letters are white on a colored background, make the font thicker - semibold or bold.
Save bold text for simple, important statements, or to draw scanning eyes to important words, such as words that identify the topic discussed. Don’t make an entire paragraph bold text.

Content

Include a hex sticker, IDE screenshot, or other branding material. The cheatsheets have a second function as marketing material.
Include a Creative Commons Copyright to make the sheet easy to share. You’ll find one baked into every cheatsheet and the template.
Be very concise - rely on diagrams where possible.
Pay attention to the details! Your readers sure will… so be correct.
If in doubt, leave it out. There is a documentation manual after all.
Code comments inform, but fail to draw the readers attention. It is better to use arrows, speech bubbles, etc. for important information. If it is not important information, leave it out.
Simple working examples are more helpful than documentation details. They meet the user at his or her pain points, demonstrating code, and reminding users how to run it, with the least context shifting.
Add some concise text to help the user make sense of your sections and diagrams. Images are best, but readers need to be able to interpret them.

Summary

Your cheatsheet has two goals. First, to help users find essential information quickly, and second, to prevent confusion while doing the above. Your best strategy will be to limit the amount of information you put into the cheatsheet and to lay that information out intuitively and visually. This approach will make your cheatsheet equally useful as a teaching tool, programming tool, or marketing tool.

P.S. Cheatsheets fall squarely on the human-facing side of software design. They focus on human attention. What does that mean? When you write documentation, your job is to fill in all of the relevant details—that’s a software facing job, you need to know the software to do it. You assume that interested humans will find their way to your details on their own (and understand them when they do!). When you make a cheatsheet, your job flips. You assume that the relevant details already exist in the documentation. Your job is to help interested humans find them and understand them. Your job is to guide the human’s attention. Don’t just write, design.

Reopening applications for instructor training

Tue, 24 Mar 2020 00:00:00 +0000

We temporarily put applications for RStudio’s instructor training program on hold in December 2019 so that we could clear some of our backlog. In order to help people who are now moving training online on short notice, we have decided to reopen applications and to put on some additional classes over the next three months. If you would like to become certified, please fill in this form and we will find a spot for you as soon as possible. Please note that all upcoming training sessions will be run online, and that we will schedule them to be as convenient as possible for people in different timezones. As always, you can preview the training materials here or read more here. If you have questions or suggestions, please contact us.

Online teaching Q&A

Mon, 23 Mar 2020 00:00:00 +0000

Thanks to everyone who took part in our webinar on teaching online on short notice — we hope you’ll be able to join us for the next in the series on resources and tips for teaching (with) R remotely. We weren’t able to answer all of the questions that came up in the first webinar while we were online, so here are some from the community discussion; if you have others, please add them to that forum and we’ll tell you what we can.

Recorded video
Slides in English
Slides in Spanish (thanks to Ian Flores)
Slides in French (thanks to Olivier Berger)
Slides in Czech (thanks to Petr Simecek)

Engagement

Do you have tips to notice quickly when you’re losing someone during a training?
I taught ~50 data science students online this Monday for the first time. I could see who was online and I could see that during the 4h class I lost some of the lower-tier students. They simply logged out and left the class. Do you have advice on how to avoid this?
- This is a problem in large in-person classes as well. The best solution I’ve come up with is to focus on a subset of learners at any time: I pick half a dozen learners, direct my questions to them for an hour, then pick another half dozen after the break and so on. It doesn’t completely solve the problem, but nothing can: in a large group, some people are going to be lost or mentally wandering no matter what you do.
A big component of Carpentries workshops is having helpers in the room to get people working with unfamiliar laptops, garbled configurations, missed steps, etc. How to emulate online?
- I think this is the hardest part of moving programming instruction online. The best thing I’ve found is to have learners screenshare with you so that you can talk them through whatever debugging is needed, but (a) “I talk and you type” is hard and (b) many are (quite reasonably) embarrassed about sharing their desktops with the whole class when things aren’t working. If video conferencing tools allowed one-to-one screensharing, our lives would be much easier.
Any “ice breaker” exercise ideas to make everyone more comfortable with the online environment?
For a smaller class (6-11) thoughts on doing quick introductions at the start?
- Ironically, the best way to show people how to use video conferencing tools is with a recorded video: by design, they can’t see your controls when you screenshare. For other tools, use a short warmup exercise: for example, at the start of online instructor training, I put everyone’s name in the shared Google Doc and ask them to add a sentence to introduce themselves to the class. This isn’t just an icebreaker: it also confirms that they have write access to the doc.
When people “check out” have you tried a separate room for those people with a second trainer?
- When I can, I will split a class in two based on learner’s levels (true beginners in one room, false beginners or intermediate learners in another). I haven’t had a chance to do this online, mostly because it requires extra resources. I think that doing so would help people who are lost, but I’d be surprised if it made a difference for those who’ve lost interest (or were never interested in the first place).
The students don’t turn on their video. I dont know the reason, maybe they don’t feel comfortable. I don’t know how ask them to change this. Could you recommend me what to do please?
- They may have very good reasons not to: if they’re working from home, for example, there may be a lot going on in the background that they don’t want to share with the world, or their connection may not be stable enough to support two-way video. Focusing on a subset at once can partially address this, but only partly.

Class Management

How many students do you usually teach to in any given class? What class size is too large for your liking?
- My ideal class size is four people—anything beyond that automatically and unavoidably shifts from conversation to lecture. My upper bound for online classes is around 15 people, both because engagement drops off after that and because of video conferencing limitations. That said, I have taught classes as large as 100 online, but it was definitely “talking at” rather than “sharing with". One of the advantages of recording lectures is that it scales much better; teaching to a subset of a dozen students (so that you get questions and interaction), then sharing that recording with the rest of the class, is an interesting hybrid strategy, but I haven’t seen any studies of its effectiveness.
Do you have a tactic for keeping track of participants responses when they may have strange or unrecognizable names that come up associated with their device?
- I ask them to change their screen names for the duration of the class.
Calling people by name, is in didactical terms referred to as “harpooning” and discouraged. You risk lower-tier and introvert students leaving the online teaching-platform to avoid being “called out”
- Agreed, but if you only speak to people who volunteer, your class will be dominated by the privileged and the extroverted. Calling on specific people, and keeping track of how many times you’ve spoken to each, is a visibly fair mechanism for distributing your attention throughout the class.
Do you have any advice for sticky note substitutions for participants to give feedback on the pace (whether it’s going too fast or slow)?
Are there any other methods besides hand raising for online training compared to in-person cues like your colored sticky notes method?
- Zoom and other tools do have nonverbal feedback mechanisms.
Do you have any tips for audio issues where more than one student has something to say at the same time, so one ends up talking over the other?
- Mute everyone at the start, re-mute everyone after each speaker, and emphasize that they have to signal that they want to talk and wait to be called on before they do so. Be sure to explain that this is not because you’re a control freak, but because you want to make sure that everyone has a fair chance to be heard.
Why do you want everyone to be muted early? Don’t you want them to have time to fully respond to ask questions?
- I mute them because I want them to be able to respond: without conversation management, the room will be dominated by those who hit the “talk” button most quickly. Chelsea Troy‘s discussion is well worth reading, and the rules for running a productive meeting always apply.
Any thoughts on the number of people in a breakout room?
- Four people: it tiles nicely on the screen, it’s small enough that everyone should get a chance to speak, and most groups will be able to get into their room successfully. (This may be superstition, but I believe that once you have more than half a dozen people going into a breakout room, it takes significantly longer to start up—if anyone has hard data one way or the other, I’d be grateful if you could share.)
Can you substitute “small talk” to fill dead air with music?
- People don’t seem to share my taste in music.
How do you recommend dealing with trolls? Do you suggest removing them from the online classroom?
- Please handle them the same way you would in an in-person class: yellow card on a first offense, red card on a second. As soon as someone is being offensive or a bully, your responsibility is no longer to them: it is to all of the other learners in your class.

Using a Shared Document

I usually feel rather lost reading all of the feedback from students in a shared doc. Do you have any tips to read the feedback fast enough and be able to give good feedback on your feet?
- Your copilot can help here by reading while you’re talking and flagging things for your attention.
How do you work with Google Docs/Hack MD when it is new to your class and they have said using it is “overwhelming”?
- It is overwhelming the first time they try to use (and probably the second and third as well). I introduce right at the start of online instructor training classes because I want to give future instructors a chance to practice with it; in other classes, I wait until learners are comfortable with video conferencing before adding to their cognitive load.
Have you ever used either a forum or a shared doc while giving an online lecture to a virtual class so that students can ask questions, ideally upvote/downvote them and potentially even answer their peers?
- I haven’t, but I’ve seen other people do so. My instinct is that asking questions is a fairly light load, but as soon as learners are expected to upvote others’ questions, it’s more cognitive load. Again, I think this is a good thing for the copilot to manage.

Technology

Is there a way to help teach us how to use Zoom if we never have?
- We will look at setting up some training.
Would Zoom be recommended to teach a robotics class for kids? Any platform recommendation?
- I’ve never taught anything with physical bits and pieces online, but I’ve just started taking guitar lessons over Skype, and getting things close enough to the camera (or vice versa) to be seen clearly seems pretty awkward. I’d enjoy hearing from others who have more experience.
What do you think about using Notability as a white board?
- I haven’t tried it—again, I’d welcome feedback from anyone who has.
In certain regions of the world we are having issues with Zoom. Any other recommended platform for videocalls?
- I’ve used Whereby for projects outside of work, and it seems to work well, but I only have experience in Canada to draw on. Again, I’d welcome feedback from people elsewhere.
Can you talk about adding captions to live-streamed content on Zoom or other tools?
- I’m just starting to play with this—I think it’s challenging to caption live coding, but if anyone has examples they can share, please post them.
Does it help to include the speaker’s image on the screen while projecting the slides?
- Absolutely: radio can be very engaging, but being able to see the speaker helps even more.
Do you have a recommendation for a chat platform?
- Slack seems the most popular choice, though I find its archiving tools unsatisfying.
One of the issues raised in a dry run earlier in the week was switching from instructor screen to the students working through tutorials and their own work. We can’t rely on students having two screens to have both at the same time, any suggestions?
- If I understand correctly, the problem is learners toggling between the presenter’s video in full screen mode and their own IDE in full screen mode on a single device. I don’t have a solution for this: there are only so many pixels in the world…
Is it worth using keycasting to show typing on the screen?
- Yes. I use Keycastr even when I’m teaching in person so that people can see what I’m doing. Some people complain it’s distracting, though, and there’s the problem of showing Mac keystrokes to Windows users and vice versa.

Asynchronous Teaching

Any suggestions for asynchronous teaching and learning? I’m finding myself having to timeshift my work—and imagine lots of others are in the same boat with childcare obligations, etc.
- This is a huge topic, and I don’t know nearly as much about it as a lot of other people. We’ll try to get some of them on a webinar soon.
What are your thoughts on pre-recording and then uploading videos versus teaching a course online? Advantages and disadvatages for each?
- It’s also a huge topic in general; in our current situation, my advice is that you should teach live and share a recording of that rather than trying to record and edit video to share with your class later. Again, teaching to a selected subset of learners will liven things up.

Resources and tips for teaching (with) R remotely

Thu, 19 Mar 2020 00:00:00 +0000

Having to move your teaching from in person to online on short notice is a difficult task. Thankfully there are plenty of openly and freely available resources that might help ease this transition, and allow you to focus on the bits of your teaching that only you can do. Below is a list of resources as well as tips to help you shift your teaching of R online.

Code in the cloud

If your students don’t have R and RStudio set up locally on their own devices, the easiest way to get them accessing these tools in the cloud is using RStudio Cloud. Not only can you get your students up and running in an RStudio instance in no time, but you can also peek into their projects when they need help, which is extremely helpful when you’re trying to help them debug something but you can’t look over their shoulder. Shifting to a new technology on short notice is difficult, but here are some pointers to get you started:

Read the RStudio Cloud Guide for getting started with setting up your course on RStudio Cloud.
Watch the RStudio Cloud in the Classroom webinar step-by-step instructions, tips, and best practices.
Sign up for our upcoming webinar with on RStudio Cloud on March 24th, 4-5 pm EDT here. In addition to going through how to set up a course on RStudio Cloud, we’ll focus on teaching with RStudio Cloud remotely.

Outsource content delivery

One option for content delivery is synchronous virtual sessions and we’ve given you some tips for this here. Another option is pre-recorded videos. Videos can be a great supplement to any class, but they can be especially useful for making time in synchronous virtual sessions for discussion as well as providing alternatives for students who are unable to make it to synchronous virtual sessions. The drawback is that they can be incredibly time consuming to produce, even if you promise yourself you won’t spend too much time on perfecting them. You might be able to leverage existing video content, especially if you’re using these to supplement other synchronous teaching sessions you’re already planning to run:

A searchable list of RStudio webinars and conference talks
Many courses on Coursera have an audit option. The Data Science Specialization and Statistics with R specialisations have lots of statistics and R content in video form that your students can watch for free with the audit option.
Each of the OpenIntro books come with videos accompanying each chapter, e.g. click on the videos link here.
The Cloud Based Data Science course on Leanpub also features videos (and exercises students can complete for free).

Flip code into interactive tutorials

Interactive exercises are great not only for self-paced learning, but also for the preparation phase in a flipped class, for formative assessment, or for self-contained demos during synchronous teaching (since they make it easy for students to jump in mid-analysis and code along with you). Interactive tutorials can also be a great replacement for pre-recorded videos that walk students through an analysis step-by-step, and while not trivial to create, they are likely less time consuming than creating a well edited video. The following resources feature many interactive tutorials for R that you can use / assign to your students.

The learnr package makes it easy to turn any R Markdown document into an interactive tutorial. RStudio Primers cover topics like R basics, visualising, wrangling, and tidying data and iteration and functions.
R Bootcamp is a “gentle and gradual introduction to manipulating and visualizing data in R using the tidyverse suite of packages”. Read more about it here.

Plan for the “turn it in” phase

If your originally planned workflow required students to print out work they completed in R and turn in hard copies, you are probably having to shift from this. Yes, they can always email you things, but that’s a bit of a mess… Below are a few options, from simpler to implement to more complex.

Upload to learning management system (LMS): If students are working locally, students will have local copies of their files that they can upload to your LMS. If they’re using RStudio Cloud or other server access, they can select the files they need to submit from the Files pane in RStudio, then go to More -> Export, which will download all selected files as a zipped folder. They can either unzip and upload, or upload as is (especially since some LMSs have restrictions on file types they allow, but usually most zip files).
Publish to RPubs: RPubs is a free publishing service for R Markdown documents. Before you go down this route, note that all documents published to RPubs are publicly visible, so this option might not work for all types of assignments and you need to consider compliance with FERPA, GDPR, etc. for your students. But one option for protecting student identity is don’t have students write their names on their documents they publish on RPubs, collect URLs to published assignments via your LMS, download as a spreadsheet, and now you have something much simpler than email submissions to sort through.
Dropbox File Request: If you don’t have access to an LMS where students can upload work or your LMS is fussy about file types, sizes, etc. you can use the file request feature on Dropbox for students to upload their files. Read more about it here. The benefit of this approach over uploading to something like a Google Drive is that students can’t see each others’ submissions.
Using GitHub as your LMS: I wouldn’t recommend introducing GitHub only for the sake of collecting student assignments, but if version control is already part of your course or if you’re teaching students who are already familiar with Git and GitHub (and you are familiar with them as well!), the ghclass package and GitHub Classroom both make it easy to set up using GitHub as your learning management system. These slides from the Designing the Data Science Classroom workshop at rstudio::conf(2020) give an overview of how to get started.

Additional resources

You’re probably not changing your reading list mid-semester, but your students might appreciate pointers for free, online books they can use to supplement their learning. The following books are freely available online.

R for Data Science
Hands on Programming with R
OpenIntro textbooks: OpenIntro Statistics, Introductory Statistics with Randomization and Simulation, Advanced High School Statistics, Introductory Statistics for the Life and Biomedical Sciences
Statistical Inference via Data Science
Modern Data Science with R (some chapters are freely available online)

We also have a trove of openly licenced materials for teaching here. Some highlights include Data Science in a Box, Stat 545, and materials from RStudio workshops.

This is by no means a complete list. If you have, or know of, resources and tips for teaching R, data science, and statistics remotely, on short notice, or if you are looking for specific resources to help with your transition to online teaching, the RStudio Community as well as #rstats Twitter are great places to share / ask.

Teaching online on short notice

Tue, 17 Mar 2020 00:00:00 +0000

Recorded video
Slides in English
Slides in Spanish (thanks to Ian Flores)
Slides in French (thanks to Olivier Berger)
Slides in Czech (thanks to Petr Simecek)

So here you are: you planned to teach your class or deliver your workshop in person, and now you have to do it online or not at all. Nobody is giving you time or money to make the change, and a hundred other things also need your attention. Where should you start, and what should you aim for?

Don’t change what you don’t have to. Assignments, submission, grading, discussion forums: if you’re already doing them online, don’t change them now. The same goes for content: your slides and exercises may not be perfect, but nothing ever is.
Don’t make assumptions about your learners’ technology or circumstances. As Elizabeth Wickes said, “Don’t presume people have {thing}, have great {thing}, have {thing} to themselves, or even have a home where {thing} could be. For each thing, fill in:internet, computer, monitor, attention, etc.”
Don’t try to be (or to beat) recorded video. Even mediocre videos require time and production experience that you probably don’t have right now, so move your live teaching online instead of trying to record and edit yourself. (If you are going to make videos, please read Chen and Rabb’s “ A Pattern Language for Screencasting” first.)
Learn the song, then improvise over it. Good musicians don’t just make things up on the fly: they learn the song and then improvise around it. Great musicians listen to their bandmates and their audience while they do this. The best live teaching (whether in person or online) works the same way: make a plan, then vary your delivery depending on who your learners are, what questions they ask, and what you realize as you’re speaking.
Don’t teach to empty chairs. We all rely on small social cues like nods and “mm hms” far more than we realize. Teaching without these is really hard, so if it’s not practical to have everyone turn on video, choose a subset of 4-6 learners and have them do it so that your hindbrain believes you actually have an audience. This also promotes engagement: learners can see that they’re not alone, and after each break, you can select a different subset of learners and direct your questions to them.
Start with a tour. Many features of your video conference tool will not be obvious to participants. Point out where they can toggle the chat, change their participant view, answer polls, and so on. If you have time, join your call as a student, take a few screenshots, annotate them, and share them with your class. (Remember, your view of the video conference will be different from that of participants.)
Direct traffic. Tell people where to put things and where to direct their attention. “Put it in the chat,” “add it to the doc,” and “unmute and tell us” will all make the class run much more smoothly.
Mute early, mute often. Background noise kills meetings, so mute everyone after every speaker and then unmute the next person you’ve called on. And as Chelsea Troy pointed out, in most online meetings, the first person to speak during a pause gets the floor. The result? “If you have something you want to say, you have to stop listening to the person currently speaking and instead focus on when they’re gonna pause or finish so you can leap into that nanosecond of silence and be the first to utter something. The format…encourages participants who want to contribute to say more and listen less.” The solution is to run a text chat beside the video conference where people signal that they want to speak, and then call on them in turn.
Call on people by name. “Any questions?” often produces an awkward silence, and even when it doesn’t, it gives fluent extroverts undue air time. Instead, call on people from your selected group by name. (If your video conferencing tool doesn’t display real names by default, ask participants to give theirs when they ask questions in the chat.) This also helps even out the effects of differing ability: you can throw easy questions at people who are struggling and save the hard ones for people who might otherwise get bored.
Don’t teach alone. Every great surgeon has a great nurse beside her. Equally, when you’re teaching online for the first time, get someone else to monitor the chat for questions, figure out who to call on next, and so on. If none of your colleagues can do this (remember, they’re probably scrambling too), ask one of your more advanced learners to help out. Whoever it is, make sure to introduce them at the start of class.
Do a dry run (with your copilot). Fifteen minutes with a small group before you do a real (larger) class can save you from saying, “Nobody told me there was a firewall.”
Keep your notes beside you. For whatever reason, people seem less distracted when they look to the side at a printed copy than when they look up at a second monitor. There’s also less risk of your audience getting to see the inside of your nose…
Add speaker’s notes to your slides. These can be point-form or long-form depending on how much time you have, but they will make your content easier to find, easier to review, and more accessible to people who have trouble seeing or hearing.
Use accessibility tools to help everyone. Speaker’s notes are just one example of this: enlarging your cursor, using a key caster to display control keys as you type, switching to high-contrast mode all help compensate for shaky video or low-quality screens.
Teach from your smallest screen. If your slides or your code are on the fancy meter-wide monitor you use for your daily work, they’re not going to look good when they’re squashed down to fit in the 800-pixel window your learners have on their tablets. Using a smaller video window also reduces bandwidth a little, which may in turn help learners in lower-quality environments.
Your voice matters more than your face. You can switch off video if you have to, but if you lose sound, your class is over. You can use a headset with a microphone, but this can become uncomfortable after a couple of hours (particularly if you wear glasses). A Yeti or Samson Meteor microphone is more comfortable, but if you use one, it’s worth $30 to get a stand (because if it’s on your desk, all your audience will hear is your typing).
Turn off notifications (theirs too). It’s rude to check your phone or read email during an in-person meeting, so don’t do it when you’re teaching (not even while your learners are working on an exercise). You probably can’t persuade your learners to be similarly respectful, but the subset you’re talking to at any particular time might.
Share work in real time. Have learners share their work in a Google Doc or HackMD during the lesson. (This is no more or no less intimidating than asking a music student to play something for the class.) When you do this, paste in a list of people’s names so that they know where to type. Once they’re comfortable with this (which will take a few hours), have them take shared notes in the same doc so that your copilot can see what they think you’re saying.
Keep track of who has and hasn’t spoken. Again, a laissez faire class can quickly turn into a discussion among a couple of extroverts, so keep a tally of who’s spoken how often and try to even it out. You don’t need technology to do this: a scrap of paper and a pencil will work just fine.
Ask—fill—call. Thinking takes time. So does typing, and there’s always lag, so when asking for questions or suggestions, give people time to respond, but talk while you’re waiting for answers in order to avoid dead air.
Ask for predictions. Online polls help keep people engaged but need to be set up in advance. Asking people, “What’s going to happen when we run this code?” is a good just-in-time alternative.
Use breakout rooms. Peer instruction is the most effective scalable teaching practice we know of. It relies on students debating their answers to a motivating question for two or three minutes at a time. Zoom‘s breakout rooms make this relatively easy to run online: it takes 15-30 seconds to get everyone into rooms, and in a class of forty there will be one or two who initially have problems, but it does a lot to keep everyone engaged and motivated. (Zoom also supports whiteboards, but please don’t try to use them until you’re comfortable with its other features.)
Take a break every hour, because the basic unit of teaching is the bladder.

The most important thing to remember is that nobody really knows how to do this—not yet. Don’t be afraid to try things, and please share your experiences: we’ll all learn faster if we learn together.

Register here to join us for a webinar on March 19, 2020 to discuss these ideas.

Instructor Training

Wed, 11 Mar 2020 00:00:00 +0000

(Re)building the R Bootcamp and generating R tutorials

Fri, 06 Mar 2020 00:00:00 +0000

This article outlines the original R-Bootcamp, why we moved it to the current platform, and talks about our experiences setting it up on the new mybinder.org based platform that was created by Ines Montani.

The original RBootcamp

The original R-Bootcamp lived on DataCamp as a free course that anyone could take. We decided to move the course off of DataCamp’s platform because we no longer felt it was ethical to support them. The R-Bootcamp focuses on teaching students the basics of the tidyverse with an interactive learning approach. It is not meant to be comprehensive, but it is meant to empower students who think they might be interested in data visualization, data wrangling, and simple statistical modeling. Most importantly, the R-Bootcamp is meant to be a psychologically safe and positive environment.

Ines Montani’s Platform

Ines Montani has developed a course platform that runs R and python code on mybinder.org. It is robust, and because it is based on mybinder.org, it scales very well.

How does it work? It takes advantage of mybinder.org‘s ability to run R in a Docker container. The website itself is hosted on a service such as Netlify, which handles the lesson material, code submission, and displaying results. The code is submitted via JavaScript to the Docker container and results (such as data.frames and ggplot2 figures) are returned to the user on a webpage.

Pros

Scalability. Because it is hosted on mybinder.org, a free service, the course scales very well. We have had hundreds of users run the RBootcamp, and we have had very few hiccups. Without this ability, we could not offer our course for free for everyone globally.

Free for right now. Solutions such as LearnR are great, but they require a shinyapps.io account to host the material, which have limited bandwidth for the free accounts, and more access costs money. Ines’ platform is dependent on two services that are currently free: mybinder.org and netlify.

Separates out code from content. DataCamp lessons are organized into chapters that contain instructions and then an interactive coding platform that gives code scaffolding, hints and solutions. This allows students to learn interactively by following instructions to complete code prompts within an R environment. Ines’ platform allows for similar interactivity, but separates out the slide contents from the code. This is very helpful in testing and debugging the code.

Works on phone browsers. A lot of students want to learn on the run. Because Ines is a usability master, the platform runs on phones with no problem, although some of the returned data frames may display a little small.

Cons

Takes some time to learn. The file structure of the platform takes a little getting used to, with code, exercises, and slides residing in different folders and files. It is not difficult to understand, but you do have to take some time learning these structures.

Assumes you understand Git (particularly branches). Because the course is run off two branches in the repository, you need to understand what goes where. Course material, exercise code, and slide material live in the master branch. Data and the docker related files to build the container live in the binder branch. Until you wrap your head around this, it can be a little confusing.

Currently no way to track user completion/award certificates. This platform is not meant to be a full replacement for online learning platforms such as Coursera or EdX. Again, it is perfect for our application of providing free lessons on learning R and encouraging students.

Code checking is limited. Ines provides a template based method of matching of code. It works, but it is a little limited. We are looking at using the gradethis package to add more feedback about mistakes that students make and add helpful hints in response to these mistakes.

Getting Started

The best way to start authoring content with this platform is to usethis::create_project to fork the R course repo and create an R project you can start altering. Once you have that open, the decampr documentation will help get you started with making chapters, and adding and editing exercises.

We also recommend looking at the existing course repos ( RBootcamp, GAMs in R by Noam Ross, Machine Learning Case Studies by Julia Silge and Ines’ spacy course) to understand exactly how exercises, lessons, and data are set up. Florencia has been working in the framework and also maintaining a list of courses that use this platform, so look for other examples there. Please reach out to us! We want to help you put your content online.

One note on the Docker container, that is built on mybinder.org: while the install.R method works, we recommend building on existing work through using a Dockerfile. That way, you can build on existing Docker containers that contain R installations and packages, such as Rocker (which has the tidyverse and geospatial containers you can build on), which has containers such as the base rocker image, geospatial, and others (by the way, Rocker rocks!).

Contributing

The decampr package developed by Ted Laderas and Jessica Minnier includes some simple utilities to process R-based DataCamp lessons to Ines’ platform. We encourage people with DataCamp repositories to try it out on their own lessons and give feedback on how to improve the package. More examples of using Ines’ platform will help it improve and grow to encompass many use cases.

Ines’ platform is very powerful and flexible. However, as mentioned in the Cons, it can take some time to learn and there are some quirks to the file and git organization. Therefore, it would benefit greatly from community contribution to additional examples for documentation and instructional material. This is a great way to contribute to the educational community!

Conclusion

This platform has provided us the means with making our course content free and accessible to a large group of people worldwide. It requires a bit of technical skill to set up, but we have tried to make the process less painful with our decampr package. We highly encourage you to try setting up your own course. Reach out to us and we’re happy to help you.

Instructor Training

Wed, 26 Feb 2020 00:00:00 +0000

Applications for 2020 Intern Program Are Now Open

Thu, 20 Feb 2020 00:00:00 +0000

As we announced last year, RStudio’s summer intern program will run for a third time in 2020, and applications are now open. Five people will work with an RStudio mentor full-time for 10 weeks starting in May 2020. Everyone is welcome to apply: you do not need to be a a full-time student to be eligible for an internship.

The compensation rate for these positions is $25/hr, assuming 40 hours each week; applicants must be residents of, and able to accept employment in, the United States. Since RStudio is a geographically distributed team, you can be based anywhere in the country: unless you live in Boston or Seattle, you will be working 100% remotely, though you will meet with your mentor regularly online.

How to Apply

The closing date for applications is midnight on Friday, March 6 AOE (Anywhere on Earth), and we will interview and make offers as quickly as possible thereafter.

Apply here

Projects

This year’s internships will be divided between our open source and education teams, and the projects will be selected from:

Create resources for people working with spreadsheets in R. Develop content that does for spreadsheets what sites like db.rstudio.com and environments.rstudio.com do for databases and reproducible environments, respectively. Primary tasks will include writing, synthesis, comparison, exposition, and exampling. This project is not explicitly about package development, although the work could easily lead to pull requests to spreadsheet reading/writing packages. Candidates should show evidence of general R experience, basic competence with Git/GitHub, previous use of R Markdown, and ability to write clearly about code. Supervisors: Jenny Bryan and Mine Çetinkaya-Rundel.
Build interactive learnr tutorials for tidymodels based on our existing introductory tidymodels workshop materials. Candidates should show evidence of having used R for data analysis and/or statistical modeling as well as basic competence with Git and GitHub; experience using the learnr package is a plus. Supervisor: Alison Hill.
Build interactive learnr tutorials for Python using reticulate. These would mirror the content of our existing tidyverse primers. Candidates should be comfortable using R or Python for data science and have basic competence with Git and GitHub; experience using the learnr package is a plus. Supervisors: Alison Hill and Greg Wilson.
Tidymodels package support. This intern will work on the support and development of modeling packages, primarily broom, which provides a large number of methods to turn models into tidy data frames. The work will include internal refactoring, revisit the testing strategy, and further develop the augment method. Candidates should understand R packages, S3 methods, and unit testing, and be comfortable using Git and GitHub. Supervisor: Max Kuhn.
Tree and rule-based models. The Cubist and C50 packages contain large amounts of C code to train ensemble models. This intern will improve their sustainability and add new features such as variable importance, efficiency, and cost-sensitive models. Candidates should understand R packages work, have solid C skills and some experience with modeling, and be comfortable using Git and GitHub. Supervisor: Max Kuhn.

Apply by Friday, March 6 AOE

Building Tidy Tools Workshop at rstudio::conf(2020)

Tue, 18 Feb 2020 00:00:00 +0000

tl;dr: all workshop materials are available here:
https://rstd.io/conf20-tidy-tools
License: CC BY-SA 4.0

It was my pleasure to co-teach Building Tidy Tools at rstudio::conf(2020) with my brother Hadley.
This workshop was advertised for

… those who have embraced the tidyverse and now want to expand it to meet their own needs.

In practice, this means we talk a lot about package development, since packages are the easiest way to develop (and share) a set of related functions, but we also touch on workflow, design, and specific implementation details.

In this post, I’ll outline a few things that aren’t as obvious from just browsing the materials: the philosophy and themes that guide the entire workshop, as well as some of the details of delivering the materials.

Philosophy and Themes

This piece of advice shows up in the workshop when talking about R CMD check (which runs a set of automated package checks):

“If it hurts, do it more often” – Martin Fowler

But I feel like it sums up the philosophy of the entire workshop, with perhaps an addendum:

“If it hurts, there is probably a usethis or devtools function for it.
If it still hurts, do it more often”

In the case of R CMD check, the devtools check() function is only a keyboard shortcut away, so there is no excuse for not running it. But, it still hurts, because check() is always pointing out what is wrong with your package.

Running check() often, not only reduces the chance you’ve introduced many new problems, it also desensitizes you to any feelings of failure you might get when you receive its report card on your package. To help participants overcome these feelings we employ two strategies:

We demonstrate how to treat check() more like a todo list, than a report card. I think it’s useful to see even Hadley doesn’t rely only on his memory to build a package from scratch, he does what he remembers, then figures out what he forgot by running check().
We get participants used to running check() often, by setting the goal of a check() with no errors, warnings or notes in many of the your turn exercises.

Another example of something that can hurt is getting a package started. This is where usethis and devtools really shine! In the first session of the workshop we cover usethis::create_package(), usethis::use_r(), devtools::load_all(), devtools::check(), devtools::document(), usethis::use_mit_license() and devtools::install(). And that’s enough to have a fully functioning package before the morning coffee break!

It takes about 20mins to create a package from scratch using this workflow for the first time, but participants then practice this workflow, adding a few extra steps, throughout the two days. By the end of the workshop they have built 3-5 packages from scratch, and hopefully find it a pain-free experience.

These are both examples of one of the big themes in the workshop: Workflow. Embracing certain workflows when you switch to package development leads to big payoffs. Some of these payoffs are short term. For example, following the package convention of putting functions in script files inside an R/ folder, along with loading them with devtools::load_all(), is immediately much more streamlined and less error prone, than sourcing functions individually with keyboard shortcuts, or source().

Other payoffs are long term, for example, writing tests adds work up front (although usethis helps a lot with the initial setup) but the long term payoff is huge: a package that is more reliable, easier to maintain, and easier to extend.

The other two big themes in the workshop are Interface and Implementation:

Interface describes the user facing side of your package. Your decisions about interface govern how easy users find your package to learn and use. One of the core values of the packages in the tidyverse is to “Design for humans”. In the workshop, we work through some case studies to elucidate what this value means and how to identify areas for improvement in your own packages.
Implementation describes the code inside your package. In the workshop we pick just a couple of topics to delve into, those we think are the most useful to know about:
- Dependencies: how and when to rely on code in other packages
- Using the tidyverse inside packages: the common problems that you run into when using tidyverse functions inside your own functions, and their solutions.
- The S3 object oriented system: why and how you might use it in your own packages.

Teaching Materials

We used the breaks to split the workshop into 8 sessions. Each session, of 1.5 hours, is a different topic, except for Interface which took up two sessions for a total of 3 hours.

Day	Session	Taught by	Theme	Materials
1	The Whole Game	Charlotte	Workflow	`1-intro.pdf`
1	Testing	Charlotte	Workflow	`2-testing.pdf`
1	Documentation / Sharing	Charlotte	Workflow	`3-sharing.pdf`
1	Dependencies	Hadley	Implementation	`3-dependencies.Rmd`
2	Using the Tidyverse	Charlotte	Implementation	`4-tidyverse.Rmd`
2	Interface	Hadley	Interface	`5-interface.Rmd`
2	OO programming / S3	Charlotte	Implementation	`7-oop.Rmd`

You might notice some numbering inconsistencies — 3-dependencies.Rmd is presented after 3-sharing.pdf and there is no 6-… 🤷.

The first three sections have slide decks (created in Apple Keynote), but the other sections have an R Markdown file that acts as a script (in script/) and another R Markdown file that records what was actually typed (in notes/).

Hadley and I refer to the script as we teach (usually open on another device like a phone or ipad), but create and update the notes version as the session progresses, and commit it to GitHub regularly. Participants would have their web browser pointing at the notes version on GitHub, refreshing when needed to grab any code required for the “Your Turn” exercises.

The script approach encourages live coding and allows for some digressions if participants raise specific questions. From an instructor perspective, it’s nice to have a record of both what you planned to teach and what you actually taught — you can look back and see how the timing worked, or questions participants raised.

The early sections (the “Whole Game”, Testing and Documentation) focus more on workflow and are harder to document in a live code script, since unlike code for scripts or functions, much of the code is run on the console and involves context switching — switching to a new RStudio session, switching to a script file that has opened in the Source Editor, or getting something running in the “Build” pane. So, I think keeping these initial sections as slides worked in this case.

Thanks

Our workshop wouldn’t have been as successful (or as fun!) without our fantastic teaching assistants: Julia Blum, Ingrid Rodriguez and François Michonneau.

These materials have been taught from and developed over a few years. A big thank you to everyone that has contributed to them! In particular, lots of credit belongs to Hadley and Jenny Bryan.

Check out materials from the 18 other rstudio::conf(2020) workshops...

Data Visualization Workshop at rstudio::conf(2020)

Tue, 18 Feb 2020 00:00:00 +0000

tl;dr: all workshop materials are available here:
https://rstd.io/conf20-dataviz
📖 Data Visualization: A Practical Introduction
License: CC BY-SA 4.0

I was delighted to have the opportunity to teach a two-day workshop on Data Visualization using ggplot2 at this year’s rstudio::conf(2020) in January. It was my first time attending the conference and it was a terrific experience. I particularly appreciated the friendly and constructive atmosphere that RStudio so clearly goes out of its way to encourage and sustain.

The workshop focused on learning how to think about good data visualization in principle, and how to do it in practice. After many years of trying and often failing to learn how to make good visualizations myself, I became convinced of two things. First, there is a real need for an approach that effectively combines the why of visualization with the how. A lot of otherwise excellent introductions to data visualization will teach you why some visualizations work better than others, and will present a series of mouth-watering examples of fabulous graphics. Then you sit down in front of an empty .Rmarkdown file and … now what? How do I do that?

Meanwhile, many very good, detailed introductions to writing ggplot2 code may be a little out of reach for beginners or—perhaps more often—will tend to get picked up by users in a recipe-like or piecemeal way. People cast around to find out how to more or less solve a particular problem they are having. But they leave without really having a good grasp on why the code they are using looks the way it does. The result is that even people who are pretty used to working in R and who regularly make graphs from data end up with a hazy idea of what they’re doing when they use ggplot.

The second thing I became convinced of as I developed this material was that data visualization is a fantastic way to introduce people to the world of data analysis with R generally. When visualizing data with R and ggplot, it’s possible to produce satisfying results almost right away. That makes it easier to introduce other tidyverse principles and tools in an organic fashion.

For both of those reasons, I ended up writing a book that approached things in just the way I wanted: a practical introduction to data visualization using ggplot2 that kept both the ideas and the code in view, and tried to do so in an engaging and approachable way. It was this text that formed the core of the workshop.

While teaching over the two days, I was assisted by four TAs:

When I saw the roster, my first reaction was that mine was the only name I didn’t recognize. Having Thomas as a TA, in particular, did rather threaten to cross the line from the merely embarrassing to the faintly absurd. It was a real treat to meet and work with everyone for the first time.

The materials from the workshop are available at the GitHub repository for the course. The repo contains all the code we went through as well as PDFs of all of the slides. The code and the slides also include additional examples and other extensions that we did not have time to cover in over the two days, or that I just mentioned in passing.

One of the benefits of teaching a short course like this is that I get a (sometimes sharp!) reminder of what works best and what needs tweaking across the various topics covered. Revisiting the code, in particular, is always necessary just because the best way to do something will change over time. For example, a few of the small tricks and workarounds that I show for dealing with boxplots will shortly become unneccessary, thanks to the work of Thomas, Dewey, and others on the next version of ggplot. I’m looking forward to incorporating those elements and more into the next version of the workshop.

Data visualization is a powerful way to explore your own data and communicate your results to other people. One of the themes of the book, and the workshop, is that it is in most ways a tool like any other. It won’t magically render you immune to error or make it impossible for you to fool others, or fool yourself. But once you get a feel for how to work with it, it makes your work easier and better in many ways. The great strength of the approach taken by the grammar of graphics in general and ggplot in particular is that it gives people a powerful “flow of action” to follow. It provides a set of concepts—mappings, geoms, scales, facets, layers, and so on—that let you look at other people’s graphics and really see how their component pieces fit together. And it implements those concepts as a series of functions that let you coherently assemble graphics yourself. The goal of the workshop was to bring people to the point where they could comfortably write code that would clearly say what they wanted to see.

Check out materials from the 18 other rstudio::conf(2020) workshops...

Instructor Training

Tue, 18 Feb 2020 00:00:00 +0000

R for Excel Users Workshop

Tue, 18 Feb 2020 00:00:00 +0000

tl;dr: all workshop materials are available here:
https://github.com/rstudio-conf-2020/r-for-excel
🔗 https://rstd.io/conf20-r-excel
🎨 Slides
🌺 Cross-posted: https://openscapes.org
License: CC BY-SA 4.0

Background

We were thrilled to co-teach the R for Excel Users workshop at rstudio::conf(2020)! From early on in our weekly early-morning work sessions and brainstorming hikes, we knew that our R for Excel Users workshop would not be about wholesale translating Excel operations into R. Instead, it would be a more holistic approach to reproducible analyses with R – a friendly introduction to becoming a modern R user.

Figure 1: Art by Allison Horst

Our philosophy was always about empowering our attendees to continue learning R after our workshop – and so that they would be excited about it. We wanted to teach not only the skillsets of the modern R user, but also the habits and mindsets for working in a reproducible and collaborative way. Through hands-on experience our attendees would build skills and confidence at the workshop, and through stories and packages from the #rstats community, they would build the mindset to expect what they want to do is possible and have a good start to finding it.

Thus, attendees would learn:

coding with best practices (RStudio/tidyverse)
collaborative bookkeeping (Git/GitHub)
reporting and publishing (RMarkdown/GitHub)

And they would build the mindset:

to expect that what they want to do is possible
to have confidence they can find it
to continue learning with supportive community
to enable others

Focusing on #rstats communities at our workshop was especially important to us because of our audience. These folks were coming to a 2400-person conference all about R – and they did not yet know R! That seems scary! Anything we could do to not only teach them about reproducible workflows but also make the conference easier to navigate for a newcomer we felt was time well spent. Thus, we deliberately focused time on R learning communities that they would see and can get involved in at the conference and afterwards. And, we included a discussion about how Twitter is a legit tool for R, and how to get started.

Teaching at RStudio::conf!

We taught R for Excel Users at RStudio::conf(2020) with our amazing TAs (and fellow Santa Barbara R-Ladies) Jessica Couture and Jamie Montgomery. We jumped into Day 1 of the workshop with 25 optimistic participants from industry, government offices, non-profits, and even several RStudio employees.

Figure 2: Julie, Jessica, Allison, and Jamie at RStudio::conf(2020)!

Our workshop assumed no previous experience with R or RStudio. After setting the tone and expectations of the workshop with how R is like the Force from Star Wars, we spent the first two sessions on meeting, exploring, and setting up our tools, including:

With Jessica and Jamie’s awesome troubleshooting, we were all off and running at the end of Session 2 with RStudio, R Markdown, and GitHub and installed, running, and somewhat familiar. Of course after getting set up with our software, we had work to do! We spent the rest of the day:

Our fearless attendees returned on Day 2, with a chorus of “Alligator mouth dash” (<-) in response to Alison’s question “How do we assign an object in R?”. We immediately jumped into coding by:

Our final session was revisiting and practicing all that we had learned throughout the workshop while participants also collaborated on RMarkdown files with each other through GitHub.

The vibe throughout the workshop was fun and lighthearted, which is exactly what we were hoping for. In addition to “Alligator mouth dash”, my favorite moment in the whole workshop was an audible whisper (“very nice!”) from someone using separate() for the first time. A close second was the cheers for janitor::clean_names() and Allison’s responding, “Yes, this is worth cheering over!”. Our attendees were hard-working folks with a great attitude and sense of humor, who are now equipped for more exciting steps in their R journey.

What’s next

We loved developing and teaching R for Excel Users, and hope to do it again. Our course materials evolved quite a bit throughout months of development, and were hugely helped by a pilot workshop we ran at UC Santa Barbara in early December. Even so, there are little things we would like to iron out and improve upon for next time. And we will also update the Book with images from the Slides so that the Book is completely self-contained and the Slides are a bonus, rather than a necessity.

We also got feedback that we should change the name of the course because while it has some framing from Excel, it is certainly not limited to Excel Users. This seems like a good idea. When we were first talking to RStudio’s Alison Hill about the workshop, we discussed how it could be somewhat of a precursor to Jenny Bryan and Jim Hester’s What They Forgot to Teach You About R – ours being What You Should Know When You Learn R. Jenny and Jim’s have a great acronym, WTF, so I have been thinking about names. I learned from Jenny that WTF was a welcome byproduct that came after they came up with the workshop name, but I have to approach it as a backronym. I’ve had many terrible ideas, but! Through cocktail chats at the conference with Charlotte Wickham and Hannah Frick, we landed on TLDR being best. I love Charlotte’s suggestion of Take a Leap and Dive into R or my less-great Time to Learn Data analysis in R. This is an ongoing pursuit, and suggestions are very welcomed :).

Figure 3: photo by Robert Bye with art by Allison Horst

Check out materials from the 18 other rstudio::conf(2020) workshops...

Introduction to Machine Learning with the Tidyverse

Fri, 14 Feb 2020 00:00:00 +0000

tl;dr: all workshop materials are available here:
https://rstd.io/conf20-intro-ml
🔗 https://conf20-intro-ml.netlify.com/
License: CC BY-SA 4.0

At rstudio::conf(2020) in January, I was lucky to lead a new two-day workshop called “Introduction to Machine Learning with the Tidyverse.” This workshop was designed for learners who are comfortable using R and the tidyverse, and curious to learn how to use these tools to do machine learning using the modern suite of R packages called tidymodels. If you just read that last sentence and don’t yet know the word “tidymodels” yet, it is a collection of modeling packages that, like the tidyverse, have a consistent API and are designed to work together specifically to support the activities of a human doing predictive modeling (which includes machine learning).

If you have heard or used the caret package, tidymodels is its successor. The development of tidymodels is supported by RStudio, and the team is led by Max Kuhn, the author of caret, Cubist, C50 and other R packages for predictive modeling. Max has offered an Applied Machine Learning workshop for several years now, but we have not yet attempted to teach tidymodels to a beginner audience. Until now! 🎉

Figure 1: Art by Allison Horst

My colleague Garrett Grolemund and I designed the workshop to provide a gentle introduction to supervised machine learning: concepts, methods, and code. Attendees learned how to train and assess predictive models with several common machine learning algorithms, as well as how to do feature engineering to improve the predictive accuracy of their models. We focused on learning intuitive explanations of the models and best practices for predictive modeling. Along the way, we introduced several core tidymodels packages including parsnip, recipes, rsample, and tune, which provide a grammar for modeling that makes it easy to the right thing, and harder to accidentally do the wrong thing.

Figure 2: Art by Allison Horst

Prerequisite Knowledge

Before workshops for this year’s conf were announced, we framed two questions to help potential learners gauge whether this workshop was the right one for them:

Can you use mutate and purrr to transform a data frame that contains list columns?
Can you use the ggplot2 package to make a large variety of graphs?

If you answered “no” to either question, you can brush up on these topics by working through the online tutorials at https://rstudio.cloud/learn/primers.

These questions were driven by the fact that when we started developing the workshop, using tidymodels required fairly advanced purrr skills; see an end-to-end code example from Max’s Applied Machine Learning workshop at rstudio::conf(2019) here.

However, between the time we first conceived of the workshop and when we taught it, a lot of the tidymodels API had changed (for the better). In hindsight, I would reframe with these questions (rationale in italics):

Have you used R for statistics, that is, doing hypothesis tests or another kind of inferential modeling? Comfort with at least lm and hopefully more packages/functions for modeling is helpful.
Can you use the pipe operator to combine a sequence of functions to transform objects in R (like a data frame)? Tidymodels code uses pipes, but tends to be more for combining functions within a single package rather than across packages.
Can you work with tibbles (or data frames) that contain list columns? Tidymodels code generally returns tibbles, often with list columns that you need to get comfortable with.
Can you use dplyr::select() helper functions? This helps when composing recipes for feature engineering.

Packages

We set up RStudio Server Pro workspaces for all workshop attendees, which provided more horsepower for running some of the more computationally intensive models, and which came pre-loaded with all the workshop exercises as R Markdown files and the packages needed to do them pre-installed. For those who wished to follow along on their local machine, we provided the packages needed as prework.

The code made heavy use of packages from the tidyverse and tidymodels:

install.packages(c("tidyverse", "tidymodels"))

Like the tidyverse, tidymodels is a meta-package that bundles most of the building blocks we needed:

library(tidymodels)

## ── Attaching packages ────────────────────────────────────────────────────────────────────────────────── tidymodels 0.0.3 ──

## ✓ broom     0.5.3          ✓ purrr     0.3.3     
## ✓ dials     0.0.4          ✓ recipes   0.1.9     
## ✓ dplyr     0.8.4          ✓ rsample   0.0.5     
## ✓ ggplot2   3.2.1          ✓ tibble    2.1.3     
## ✓ infer     0.5.1          ✓ yardstick 0.0.4     
## ✓ parsnip   0.0.4.9000

## ── Conflicts ───────────────────────────────────────────────────────────────────────────────────── tidymodels_conflicts() ──
## x purrr::discard()    masks scales::discard()
## x dplyr::filter()     masks stats::filter()
## x dplyr::lag()        masks stats::lag()
## x ggplot2::margin()   masks dials::margin()
## x recipes::step()     masks stats::step()
## x recipes::yj_trans() masks scales::yj_trans()

Two tidymodels packages were not yet on CRAN at the time of the workshop. We installed the development versions of workflows and tune from GitHub.

# install once per machine
install.packages("remotes")
remotes::install_github(c("tidymodels/workflows",
                          "tidymodels/tune"))

# load once per work session
library(workflows)
library(tune)

We also used some non-tidymodels packages as well:

install.packages(c("kknn", "rpart", "rpart.plot", "rattle", 
                   "AmesHousing", "ranger", "partykit", "vip"))

# and

remotes::install_github("tidymodels/modeldata")

Teaching Infrastructure

RStudio Server Pro: Our RStudio Server Pro workspaces used Amazon compute optimized c5.large instances with 2 vCPUs and 4 GiB memory for each learner.
Slides: I used the xaringan package to build all my slides in R Markdown. The source files all live within the site/static/slides folder of the repository.
- For a xaringan tutorial, you can see my rstudio::conf(2019) workshop slides here.
- I also highly recommend the countdown package, which I used to create the exercise timers ⌛.
Workshop website: I used the blogdown R package to build the website, with the Hugo academic theme with a custom CSS designed by Desirée De Leon. If you want to re-use my workshop website (you’ll need GitHub and Netlify accounts), click on Deploy to Netlify button at the top of my README 🚀

In the rest of this post, I’ll walk you through the materials available through the workshop website:

Materials

The workshop consisted of 8 sessions. In each session, we presented slides interspersed with timed group activities and independent coding exercises. All of these links are also available on our website.

session	Slides	Materials
00	Welcome & Introductions
01	Predicting	Exercises, Solutions
02	Classifying	Exercises, Solutions
03	Sampling & Resampling
04	Ensembling	Exercises, Solutions
05	Workflows	Exercises, Solutions
06	Recipes	Exercises, Solutions
07	Cross-validation	Exercises, Solutions
08	Tuning	Exercises, Solutions

Instructor Notes

We did a trial run of this workshop in December 2019 in Boston with about 20 participants, which proved one of Greg Wilson’s cardinal rules:

“Remember that no lesson survives first contact with learners…”

Actually, the workshop went pretty smoothly for a first run, and we received positive feedback from our attendees. But, like any good educators, Garrett and I decided that a content renovation would make the workshop even better. This decision was driven by a few observations:

We realized that the process of using a fitted model object for generating predictions was pretty new to many attendees. We needed to spend more time on this, so we beefed up our early section on predicting considerably. This meant that parsnip was the first tidymodels package we introduced, which felt right! Parsnip probably should be the first tidymodels package to learn/teach to new users (previously, we had started with rsample).
Many attendees were less familiar with resampling methods in general, and in particular with bootstrap resampling. Since bootstrapping is such a key concept, we pushed cross-validation later and added an earlier section on sampling and resampling.
To lay out the red carpet for ensembling (we worked up to bagging and random forest models), we spent some time working with and interpreting single decision trees, including a “Guess the Animal” team activity that helped to loosen everyone up on day 1.
A new, but very much welcome, kid on the tidymodels block appeared just before our workshop in December: workflows. For conf, we re-factored our approach to introduce workflows by bundling together formulas and parsnip model specifications first (via add_formula() and add_model()), then introducing recipes as a way to move beyond formulas and do feature engineering (substituting add_formula() with add_recipe() instead).
To accomodate the new and improved content reorganization we envisioned, we hit a few code hiccups. Garrett and I made an executive decision to write some helper functions so that the code just worked and we kept the content on track. These were the earliest fitting functions we used on day 1, before transitioning to tune::fit_resamples() and tune::tune_grid() on day 2 after introducing cross-validation.

As an educator, this is typically something I try to avoid if possible, as my goal is to guide learners to be able to use the package APIs as designed independently. But debugging this specific error introduced too much “inessential weirdness” because:
- we would have needed to describe things that were not really necessary to understand, and
- these things were likely to alienate people (you can follow a discussion and reprex of one error here).
Bottom-line: If you are trying to follow these slides on your own, open the accompanying exercise files for each slide deck and run the first chunk locally (look out for our helper functions named fit_data() and fit_split()). If you want to take the training wheels off and use the base tidymodels functions, you may run into similar errors, but roughly:
- fit_data() = parsnip::fit()
- fit_split() = tune::last_fit()
Finally, we re-worked most of our exercises (within R Markdown documents) to provide code templates that were either “fill-in-the-blanks” or “fix me” (i.e., replace or add arguments to already written code). On the first run, it became abundantly clear that, because tidymodels code can be verbose, we wore learners out with too much typing. In fact, we wore ourselves out typing. To reduce the typing (and cognitive) load, we tried to adopt a no-code-chunk-left-blank strategy so that learners did not feel like this at the end:

Figure 3: Video from YouTube.

What would I change?

In hindsight after teaching this material twice, I would try to make room for a final case study with a new dataset so that learners get a chance to create a full predictive modeling pipeline, from the initial split to the last fit. To make room for a case study, I would try to get workflows and recipes to join forces a bit earlier. One of the clearest benefits of using workflows is that you don’t need to spend too much time monkeying around with the prep, bake, and juice functions from the recipes package, so we could shorten the bridge between presenting these two packages considerably. I also think that cross-validation and tuning could be more closely aligned timing-wise, since tuning with tidymodels is only possible with resampled data.

Thanks

I sincerely enjoyed developing this workshop with Garrett, getting a chance to work closely with Max Kuhn and Davis Vaughan of the tidymodels team (now including the inimitable Julia Silge!), and having the opportunity to introduce a new cohort of R and tidyverse users to tidymodels. I hope the materials we developed are useful to learners and other educators too—if they are, please let me know, I’d love to hear about it.

And most of all—thanks to our Boston and San Francisco workshop participants! You all were a pleasure to model with.

Happy predictive modeling!

Special thanks

This workshop was made possible by an ⭐ all-star ⭐ TA team- you can find out more about them on our workshop website.

Check out materials from the 18 other rstudio::conf(2020) workshops...

Text Mining Workshop Materials from rstudio::conf(2020)

Thu, 13 Feb 2020 00:00:00 +0000

tl;dr: all workshop materials are available here:
https://rstd.io/conf20-tidytext
🔗 bit.ly/silge-rstudioconf-1 and bit.ly/silge-rstudioconf-2
License: CC BY-SA 4.0

At rstudio::conf(2020) in January, I had the pleasure of teaching a two-day workshop on text analysis using tidy data principles. With two whole days to dedicate to this topic, we had the opportunity to cover a lot of ground and go into significant detail. On the first day, we focused on exploratory data analysis for text, and on the second day, we addressed modeling for text, with a bit of both supervised and unsupervised machine learning.

In our workshop, we had three skilled and supportive TAs:

Similar to many of the other workshops at rstudio::conf(2020), our workshop TAs had such deep teaching and subject matter expertise that they could have been the ones teaching! Jeroen is a linguist by background and a Tidyverse Certified Trainer himself, Emil is the author of several R packages for text modeling, and Kasia has taught many R workshops, including those focused on natural language processing. Having a team of such capable and caring TAs contributed to our workshop going remarkably smoothly.

However, workshops that involve dozens of participants, live coding, Wi-Fi, and package installation are bound to run into a few hiccups and we were no exception. One of the things I took away from my own experience in RStudio’s training certification is how, when handled well, those kinds of challenges can be valuable learning opportunities. During this workshop, I (inadvertently) introduced a bug in the second day’s slides. The bug jumped out at me as we were working through our supervised machine learning example. I had used select() where I should have used distinct() in some data preparation, resulting in “leakage” of training data into the test set. Data leakage is a huge problem in machine learning and so, so easy to stumble into; although I never enjoy making mistakes in front of people, it was great to have such a concrete reason to talk about it in detail.

The materials for this workshop are available on GitHub; you’ll find an outline of what we covered, the code that created the slides, and the .Rmd files that participants worked through during the two days. (The data leakage bug has been fixed, in case you are wondering.)

I like to use xaringan for code-heavy workshop slides these days, and I used GitHub Pages to serve the slides as HTML. The slides for the first day on exploratory data analysis start from what we mean by a tidy data structure for text and then work through other exploratory approaches for text such as sentiment lexicons and tf-idf. The first day wrapped up with moving beyond single words to n-grams and the rich kinds of analysis larger units of text can open up, such as network analysis. The slides for the second day on modeling start with an example of unsupervised machine learning for text (topic modeling) and end with an example of supervised machine learning (regularized regression, which works great for text).

Throughout both days, participants chose their own text datasets from Project Gutenberg to use during the workshop. There is value in learners being able to have some autonomy in what they spend two long days looking at over and over again, and also in seeing how their results differ from their neighbors’. Seeing our participants engage deeply with learning about text analysis and with each other was a highlight of my conference experience this year!

Check out materials from the 18 other rstudio::conf(2020) workshops...

Tidy Time Series and Forecasting in R

Thu, 13 Feb 2020 00:00:00 +0000

tl;dr: all workshop materials are available here:
https://rstd.io/conf20-ts
📖 Forecasting: Principles and Practice
License: CC BY-SA 4.0

For the last couple of years I’ve watched the twitter feed from the Rstudio conference with jealousy — not just FOMO but KIWMO (Knowing I Was Missing Out). So when I was asked to teach a workshop on Tidy Time Series as part of rstudio::conf2020, I agreed without hesitation. The idea was to teach a workshop using a tidy approach to time series — something that has only been possible very recently.

It is now very common for organizations to collect huge amounts of data over time, and existing time series analysis tools are often unable to handle the scale, frequency and structure of the data collected. In response, I have been working with Earo Wang, Mitch O’Hara-Wild and Di Cook to develop a suite of packages to handle modern time series data in a tidy framework. This workshop was an introduction to how to use these packages.

All the materials for the workshop are on a github repository. The workshop was based on the new edition of my textbook with George Athanasopoulos.

I was very lucky to have four awesome teaching assistants in Mitch O’Hara-Wild, Rhian Davies, Phillip Lear, and Steven Lawrence.

Day 1

On day 1, we looked at the tsibble, lubridate and feasts packages (along with the tidyverse of course). We introduced the tsibble data structure for flexibly managing collections of related time series, and explored how to do data wrangling, data visualizations and exploratory data analysis, along with some feature-based methods to explore time series data in high dimensions.

Links to slides for day 1 are given below.

Day 2

Day 2 was about forecasting using the fable package. We looked at several well-known time series forecasting models and how they are automated in the fable package. We also discussed ensemble forecasts. Finally, we looked at forecast reconciliation, allowing millions of time series to be forecast in a relatively short time while accounting for constraints on how the series are related.

Links to slides for day 2 are given below.

Lab Sessions

We alternated between me presenting and lab sessions where participants worked with time series data in R. The instructions for the lab sessions are available on the repo.

R code providing solutions to the lab exercises are also available here.

Check out materials from the 18 other rstudio::conf(2020) workshops...

What They Forgot to Teach You About R at rstudio::conf 2020

Thu, 13 Feb 2020 00:00:00 +0000

tl;dr: all workshop materials are available here:
https://rstd.io/conf20-wtf
🔗 https://rstd.io/wtf-2020-rsc
License: CC BY-SA 4.0

What did they forget to teach you about R? If you’re like many people, your R education focused mainly on how to do statistical analyses in R. However, there are many other skills that are crucial to working productively in R and are rarely taught. Filling in these gaps was the focus of the What They Forgot to Teach You About R workshop that Jenny Bryan, Jim Hester, and I taught at rstudio::conf 2020.

The first morning of the workshop was devoted to talking about project-oriented workflows, and how best to organize one’s R projects. We discussed how to create a project structure that is self-documenting, organized, and easy to revisit and collaborate on. Creating a logical folder structure, using informative and well-formatted file names, practicing “safe paths”, and splitting analyses up into manageable pieces were some of the key components of robust R projects. In the afternoon, Jim led the group through an exploration of R’s debugging tools, including traceback(), browser(), debug(), trace(), and recover(). Finally, we covered how to use git and GitHub to track the history of our projects and communicate our results.

Day two began with personal R administration ( part 2): how to maintain your R installation and package libraries, how to set up a development environment, how to install source packages and read source code, and how to create reproducible project environments with renv. From there, Jenny took us into more advanced git workflows. Using a repo full of ASCII art, everyone practiced visiting the history of their projects and reverting and cherry picking commits. We also covered some time honored strategies for working with git, including the repeated amend and the burn it all down method. We ended the day with a lesson on using purrr for repetitive tasks.

All of the materials from the workshop are available at https://rstudio-conf-2020.github.io/what-they-forgot/, including:

slides
hands-on exercises
links to further reading on the What They Forgot to Teach You About R and Happy Git and GitHub for the useR sites
the popular Spotify playlist we played during the course

Throughout the workshop our fantastic team of TAs—Hannah Frick, Myfanwy Johnston, Sean Kross, and Theo Roe—kept things running smoothly by moving throughout the room and answering learners’ questions. Thank you to them, to the rest of the RStudio team, and to the workshop participants for making the two days such a success!

Check out materials from the 18 other rstudio::conf(2020) workshops...

Workshop wrap-up from rstudio::conf(2020)

Thu, 13 Feb 2020 00:00:00 +0000

In January, we wrapped up rstudio::conf(2020)—our fourth conference about all things R, RStudio, and data science. This year, the conference was held in San Francisco, California. Before the conference, we offered 19 (mostly) two-day workshops taught by RStudio staff as well as experts throughout the R community. Topics ranged from R for Excel Users, Javascript for Shiny Users, to Deep Learning with Keras and Tensorflow. With a teaching staff of 102 and 1307 workshop attendees, our instructors worked overtime to craft learning experiences that both challenged and empowered learners.

This year, the RStudio Education team designed a workshop line-up that we hope offered something for everyone. Some of our tried-and-true workshops were offered, but we also welcomed some new kids on the block, many by popular demand from attendees who weighed in on our post-conf surveys in the past. We were excited to work with new instructors from around the world, and to bring our conference attendees a slate of unique R-focused workshops.

For learners who attended workshops as well as those who could not join us, all workshop materials this year are available online with CC BY-SA 4.0 licenses. Even though the materials alone cannot replace the actual workshop experience, we hope that you’ll find them useful. Instructors will be blogging individually about their workshops as well, so watch this space for some repo roadmaps to help you navigate their workshop materials. RStudio also regularly hosts workshops throughout the year so please subscribe to training updates.

Thanks to all our instructors, teaching assistants, and workshop attendees this year—we hope to teach and learn together again in 2021 in Orlando!

Links

workshop	blog post	instructors
A Practical Introduction to Data Visualization with ggplot2 Workshop		Kieran Healy
Applied Machine Learning Workshop		Max Kuhn
Big Data with R Workshop		Edgar Ruiz, James Blair
Building Tidy Tools Workshop		Charlotte Wickham, Hadley Wickham
Deep Learning with Keras and TensorFlow in R Workshop		Bradley Boehmke
Designing the Data Science Classroom Workshop		Mine Cetinkaya-Rundel
Introduction to Data Science in the Tidyverse Workshop		Amelia McNamara, Hadley Wickham
Introduction to Machine Learning with the Tidyverse Workshop		Alison Hill, Garrett Grolemund
JavaScript for Shiny Users Workshop		Garrick Aden-Buie
Modern Geospatial Data Analysis with R Workshop		Zev Ross
My Organization's First R Package Workshop		Rich Iannone, Malcolm Barrett
R for Excel Users Workshop		Julia Lowndes, Allison Horst
R Markdown and Interactive Dashboards Workshop		Carl Howe, Yihui Xie
RStudio Instructor Training Workshop (1-day)		Greg Wilson
RStudio Professional Products Administration Workshop		Andrie de Vries
Shiny From Start To Finish Workshop		Danny Kaplan
Text Mining with Tidy Data Principles Workshop		Julia Silge
Tidy Time Series and Forecasting in R Workshop		Rob Hyndman
What They Forgot to Teach You about R Workshop		Kara Woo, Jenny Bryan, Jim Hester

Licensing

All workshop materials are licensed under a Creative Commons Attribution-ShareAlike 4.0 International License.

This is a human-readable summary of (and not a substitute for) the license. Please see https://creativecommons.org/licenses/by-sa/4.0/legalcode for the full legal text.

You are free to:

Share—copy and redistribute the material in any medium or format
Adapt—remix, transform, and build upon the material for any purpose, even commercially.

The licensor cannot revoke these freedoms as long as you follow the license terms.

Under the following terms:

Attribution—You must give appropriate credit, provide a link to the license, and indicate if changes were made. You may do so in any reasonable manner, but not in any way that suggests the licensor endorses you or your use.
ShareAlike—If you remix, transform, or build upon the material, you must distribute your contributions under the same license as the original.

No additional restrictions — You may not apply legal terms or technological measures that legally restrict others from doing anything the license permits.

Notices:

You do not have to comply with the license for elements of the material in the public domain or where your use is permitted by an applicable exception or limitation.

No warranties are given. The license may not give you all of the permissions necessary for your intended use. For example, other rights such as publicity, privacy, or moral rights may limit how you use the material.

Instructor Training

Tue, 11 Feb 2020 00:00:00 +0000

Instructor Certification Exams

Wed, 05 Feb 2020 00:00:00 +0000

Since RStudio’s instructor training program launched last year, more than 65 people have completed the exams needed to become certified. We hope these sample exams will give prospective trainers an idea of what we’re looking for; as always, we would be grateful for feedback from the community.

Teaching Exam

The exam covers material from the one-day instructor training course, and we’re happy to answer questions about scope.
You must complete within 90 minutes.
You may use any books or online resources you want during this examination, but may not communicate with any person other than your examiner, and may not share information with other people about the content of this examination.

Instructions for Sample Lesson

Prepare a 15-minute lesson on a topic related to R, RStudio products, or data science and submit it to the examiner at least two days before your scheduled examination. Your submission should include (but is not restricted to):

A learner persona characterizing the audience for the lesson.
A concept map showing the mental model you intend to convey.
Two formative assessments (such as multiple choice questions or Parsons Problems).
Any notebooks or slides you would use to support delivery of the lesson.

You will have 15 minutes during the examination to deliver the lesson and its formative assessments.

Live coding is strongly encouraged; if you make any mistakes (deliberate or otherwise), try to incorporate them into your teaching as you would in front of a class.
Your examiner will (try to) work through one of your formative assessments during the lesson. Please allow 3–5 minutes for this in your planning.

Question 1

Present the demonstration lesson you have developed for this examination.

Question 2

Elements of data structures in R can be indexed using single square brackets thing[index], double square brackets thing[[index]], or dollar signs thing$index. You are teaching an introductory workshop on R, and have just given examples of all three kinds of indexing.

Create a multiple choice question to test their understanding. Include one right answer and at least two wrong answers, and explain clearly what misconceptions the wrong answers are intended to diagnose.
Create a short fill-in-the-blanks coding exercise to test their ability to use all three kinds of indexing correctly. Provide the explanatory text you would give the learners and the template code they would fill in, and explain what answers you expect and what errors you expect learners to make.

Question 3

To support a just-in-time online training course (i.e., a MOOC) for people who are already competent programmers and are learning their way around the tidyverse, your colleague has created a set of programming challenges and written a dozen unit tests to go with each one. When the learner submits a solution, the system runs all of the unit tests and tells the learner how many passed and failed. The learner does not get to see the tests themselves: all they get back each time they submit is a score like “6/12”.

What are two strengths of this approach from a learner’s point of view?
What are two weaknesses from a learner’s point of view?
What are two strengths from a teacher’s point of view?
What are two weaknesses from a teacher’s point of view?

When answering, please connect your points to specific aspects of educational or pedagogical theory where you can.

Question 4

R has several structured data types, including vectors, lists, matrices, and data frames.

What labels would you add to the concept map below to explain their relationship?
What are two other concepts you would add to this concept map, and how would they relate to each other and to the existing concepts?

Question 5

A senior professor in your department wants to give this question to an undergraduate statistics class to prompt discussion of bias:

People of East Asian or South Asian ancestry make up 8% of the Canadian population, but 60–75% of undergraduates in Computer Science at major Canadian universities.

Write two one-page papers to argue pro and con that this proves people of European descent are intrinsically less capable of abstract reasoning than their Asian counterparts.

Compare and contrast your arguments with those made about the underrepresentation of women in computing and data science being due to aptitude and/or interest.

In one or two sentences each, explain two pros and two cons of using this exercise with this audience as if you were giving your colleague feedback. (Note: you are not expected to answer the question above, but rather to give your senior colleague feedback on it.)

Question 6

Watch the video embedded below and list feedback you would give the presenter about what they’re doing well and what they could improve.

[link varies from exam to exam]

Content	Presentation
		Positive
		Negative

Tidyverse Certification Exam

This exam covers material from R for Data Science (https://r4ds.had.co.nz/). If you have any questions about scope, please get in touch - we’d be happy to clarify.
You may use any books or online resources you want during this examination, but you may not communicate with any person other than your examiner.
You are required to use the RStudio IDE for this exam. You may use either the desktop edition or rstudio.cloud as you prefer.
You may do your work in an R script or an R Markdown file, and may use one for the whole exam or one for each question as your prefer. Whichever you choose, you must send your final work to the examiner by email upon completion of the examination.
Please let the examiner know when you finish each part of each question so that they can check your work.

August 2020: Marly Gotti has created a solution guide for this exam.

Question 1

The file at_health_facilities.csv contains a tidy dataset with four columns:

The ISO3 code of the country that reported data.
The year for which data was reported.
The percentage of HIV-positive children born to HIV-positive mothers age 15–17.
The percentage of HIV-positive children born to HIV-positive mothers age 20–34.

Please answer the following questions:

How many countries reported data?
What is the difference between the minimum and maximum year with valid data for each country?
How many countries reported data in 3 or more years?
Which countries reported 100% incidence for at least one year in either age group?

Question 2

A student has sent you the file rmd-country-profile.Rmd, which is an R Markdown document analyzing the data in at_health_facilities.csv for Bangladesh. They could not knit the file, and are providing you with the raw .Rmd file instead of a rendered file.

Go through the file, fixing things that are preventing it from knitting cleanly.
Change the two lines of bold text to H2-level headers to organize the document, and add a table of contents.
Convert this R Markdown report for Bangladesh into a parameterized report with the country’s iso3 code as its parameter. Knit a new country profile for Egypt (ISO3 code “EGY”).

Question 3

You have been given a CSV file infant_hiv.csv that is formatted as follows:

ISO3	2009 est	2009 hi	2009 lo	2010 est	2010 hi	2010 lo
ALB	-	-	-	-	-	-
BLR	>95%	>95%	>95%	>95%	>95%	>95%
BLZ	77%	89%	3%	75%	88%	3%
BRA	25%	35%	19%	25%	35%	19%

The first column is ISO3 country codes.
There are three columns for each year from 2009 to 2017. Each set has estimated, low, and high values for the year (in that order).
A dash - indicates that no data is available.
Our analyst tells us that >95% means “the data is unreliable”.

Your task is to turn this into a tidy data table for further analysis:

Describe what columns a tidy layout for this data would have and why.
Write a function that takes the name of a file containing this table as input and returns a tidy version of the table.
- The function should replace all - and >95% values with NA.
- The body of the function may contain one or more pipelines and may create temporary or intermediate variables, but may not contain any loops.

Question 4

The file ranking.csv contains two columns:

The ID of an item being rated.
A rating, which is one of “negative”, “positive”, “indifferent”, or “wtf” (meaning the respondent didn’t understand the question).

There are multiple ratings for each item.

The plot below shows this data:

Each dot represents one item i.
The size of the circles shows the total number of ratings for item i.
The X coordinate for item i is the percentage of ratings for that item that are “negative”.
The Y coordinate for item i is the percentage of ratings for that item that are “positive”.
The regression line is created using the ‘lm’ method.

Re-create this plot using the tidyverse and ggplot2, fixing any mistakes you notice along the way.

Gestalt Internship

Tue, 04 Feb 2020 00:00:00 +0000

Of all the projects listed for the 2019 internships, the one that stood out to me the most was the Grader Enhancements. Mainly because I knew how deceptively difficult the problem is.

It’s now named gradethis because grader made it to CRAN on my first week of the internship. The package tries to grade code in a learnr document, but the real magic of the package isn’t just reporting a correct or incorrect answer, it’s the ability to provide meaningful feedback to the learner. For example, if the solution to a question was sqrt(log(1)) and the student provided sqrt(log(2)), it would report the answer as “incorrect” but also return “I expected 1 where you wrote 2. Try it again; next time’s the charm!”.

If it wasn’t for Hadley’s lobstr talk a year earlier, I wouldn’t have even known about ASTs ( abstract syntax trees) to approach the problem. I probably thought it would’ve involved writing the gnarliest regular expression pattern ever (I clearly don’t come from a computer science background).

Ever since I’ve been involved with the R (and python) community, I’ve always been surprised how much (free) material is out there for you to learn. Everyone in the community just fosters a welcoming learning environment, and the internship was yet another way to level-up my R skills. From a technical perspective, the most jarring part of the internship was transitioning from “a user of the R language” to a “developer”. I’ve taught workshops and written R packages, but nothing came close to the type of code I had to write for my internship.

Some of the major topics were:

Using vapply instead of sapply: You might be okay in an analysis script with using sapply, but vapply guarantees the type of vector that is returned.
Testing: This goes for package unit tests but also writing internal testing code to make sure the object you are working with is actually what you think it is. This was done with the testthat package for running unit test suites, and the checkmate package to write powerful assert statements to check objects.
Non-standard evaluation: A good part of the internship was just reading and writing toy example code to get a sense of what NSE is in R. There’s a reading list of links on one of my earlier posts

To give a sense of how deep of a hole I needed to get myself out of just to understand what was going on, it took me about a month to fix the package and implement the first issue.

gradethis was refactored out of learnr, so the entry-point into the grading functions were highly coupled to what learnr passed into the grading function. If it weren’t for all the unit tests that were already there, refactoring the package and changing the API would’ve been impossible. What made unit tests essential to the work was that print statements and browser calls wouldn’t work as expected (if at all) because learnr is a very complex piece of software that needs knowledge of how knitr and shiny works. If I needed browser statements, I’d actually have replicate the error in a unit test and put a browser statement into the actual test call. This wasn’t something that Jenny Bryan talks about.

I eventually got a hang of things, and give a small internal lightning talk of it working. Along the way I polished up the API, and even found a bug in the == operator, which I reported to r-devel. You can also use the package as a standalone grader! One of my proudest accomplishments was putting together a function that standardizes function calls with all the default arguments. This way something like vapply(X = LETTERS[1:3], FUN = stringr::str_to_upper, character(1), USE.NAMES = TRUE) and vapply(X = LETTERS[1:3], FUN = stringr::str_to_upper, character(1)) are marked as “correct”.

What made the internship such a wonderful experience was how many people I saw and spoke with, even though everyone is remote. The interns rotated every week to host a virtual coffee hour, so we would meet one another. The common theme of our discussions were usually along the lines of “I have no idea how I got here”, “everyone is amazing”, “we don’t want to go”. Needless to say, we all loved working there.

I had the chance to meet a few interns in person while at conferences over the summer, but it was great meet the rest of the interns and RStudio employees at rstudio::conf:

The @rstudio interns gather for a picture at #rstudioconf #rstats.

AKA this is why parallel programming is hard. pic.twitter.com/QslxOjAPTV
— Dⓐniel Chen @ rstudio::conf 🐍🏴 ☠️ (@chendaniely) January 31, 2020

But why “Gestalt Internship”? It wasn’t just an internship where I got to work on an R packages. I had an entire R and Carpentries community behind me to get me there. I didn’t just learn how to be a better R programmer, I worked on an education tool that would benefit future learners in R. I’ve left the internship with a better understanding of topics that I can pay forward to the rest of the community. After being on the Education team, I’ve found my way around my own dissertation topic and studying data science education in medicine, now. It’s more than just the “street cred” of being an intern at RStudio, I feel even more responsibility to take all that I’ve learned to help the community grow.

So if you ask, “what was it like interning at RStudio?", it’s anything and everything you could possibly hope for.

rstudio::conf 2020

Mon, 27 Jan 2020 00:00:00 +0000

rstudio::conf 2020 covers all things RStudio, including workshops to teach you the tidyverse, and talks to show you the latest and greatest features.

Learning R for Software Engineers

Mon, 23 Dec 2019 00:00:00 +0000

A couple of weeks ago, one of the Software Engineers at RStudio asked what I’d recommend for learning R, and the education team thought it might be useful to share more widely on this blog. This is my advice for quickly picking up R if you’re already familiar with another programming language.

Work through the first few chapters of R for Data Science (R4DS) to get a sense of what R and data analysis feels like:

Attempt to ignore any feelings about how weird the language is and focus on getting a sense of the exploratory process of “playing” with data, rapidly asking, and then attempting to answer questions that you might have. To make sure you’re prepared to work with your own data, skim the vroom docs, and learn about tidy data so you have a sense for how to organise your data most effectively (although you may want to use the new pivot_() function instead of spread() and gather(): https://tidyr.tidyverse.org/articles/pivot.html).

By this point, your curiosity about R as a programming language has probably grown to an almost unmanageable level, so I’d recommend reading about copy-on-modify and the lazy evaluation of function arguments. It’s probably also worth familiarising yourself with the basic data structures and the basics of subsetting, which are particularly important in R.

I’d then pivot back to R4DS, and tactically read the chapters about the data types ( strings, factors, date-times, etc.) that you’re working with.

If you’ve mostly worked in object-oriented programming languages, I’d recommend reading the chapter on functionals in Advanced R; if you’re already familiar with functional programming, just skim the purrr docs. R uses a style of OOP that’s different to most other programming languages, so also read the intro chaapter to get some sense of the differences.

Hopefully, this now gives you a sense for how people use R and some of the things that make it different as a programming language.

Introduction to Machine Learning with the Tidyverse

Thu, 12 Dec 2019 00:00:00 +0000

This is a test run for a workshop in the final stages of development. The workshop provides a gentle introduction to machine learning and to the tidyverse packages that do machine learning. You’ll learn how to train and assess predictive models with several common machine learning algorithms, as well as how to do feature engineering to improve the predictive accuracy of your models. We will focus on learning the basic theory and best practices that support machine learning, and we will do it with a modern suite of R packages known as tidymodels. Tidymodels packages, like parsnip, recipes, and rsample provide a grammar for modeling and work seamlessly with R’s tidyverse packages.

Students should feel comfortable plotting with ggplot2 and using the dplyr and purrr packages. You can brush up on these topics by working through the online tutorials at https://rstudio.cloud/learn/primers/2 and https://rstudio.cloud/learn/primers/5. This will be a hands-on workshop—so be sure to bring a laptop and power cord!

The workshop will be led by RStudio instructors Alison Hill and Garrett Grolemund.

Since this is a test run, the workshop is limited to a small number of seats. The low price reflects the experimental nature of the material. Students will be asked to provide constructive feedback in a course survey.

Instructor Training

Mon, 09 Dec 2019 00:00:00 +0000

Ten Quick Tips for Making Your Stuff Findable

Mon, 09 Dec 2019 00:00:00 +0000

As RStudio’s resident Information Architect & Digital Librarian, I get asked a lot how to organize stuff with the goal of making content more findable. Here are 10 suggestions to make your own work product (whatever it is) findable by yourself & others!

1. Isolate the Findability Problem

When we talk about findability, it is important to clarify that there are actually three different levels we’re concerned with. There’s finding your work on the web, finding a specific item within a website, and finding a piece of information within a specific item. Depending on what content you’ve created, you may have all three areas to think about! While there are fine-tuning techniques appropriate for each, I do believe that the remaining nine suggestions will improve access to the information your end-user seeks across the board. What is important in this first tip is to make sure that when you say “I can’t find it” you recognize that the problem(s) could be at any one level, or more!

2. Know Your Users

Before making any changes to your item(s), site or underlaying software, take time to determine who your users are. Depending on your content, you might have only a small, expert audience. If your work is publicly available, though, you want to be sure to accept the idea that complete novices will find your work. They should be able to understand and navigate your content as well as a subject expert—or at the very least, you don’t want to make it excruciatingly difficult for them!

3. Mimic Real World Directions

It’s really common for content designers to think that since their audience is highly educated, that they’ll have either an innate understanding of the way you’ve structured your content, or unlimited patience to persist until they get what they need. As I learned through over a decade spent with lawyers, internet users are all the same! They scan, don’t read, click on the first close thing they see and give up really, really soon. Lots of the time they’re on their phones or are task-switching—you do not have their full attention and they’re unlikely to really read while they are in ‘search mode.’ That said, it’s your job to make it easier for them by ensuring you have put up as many virtual signs as possible. Things like breadcrumb trails and menus on websites, and headings, file paths, & table of contents on documents/files give your users a sense of where the information resides as part of the larger information ecosystem they’re currently “in” (because we use physical language to describe our internet behavior, even though we don’t physically “go” anywhere!). Give your users a virtual map with sign posts and directions so they can figure out where they need to go.

4. Understand the Difference Between Form & Substance

I’ll go into more depth about tagging below, but it’s important to understand that there are terms to describe what your content IS (format), and also terms to describe what it is ABOUT (subject). Going back to your users, what subjects are important to them, and doe those topics carry over or change between differences in format? This is basically a question of combined terms—are your format terms uniquely matched to topical terms (blog posts are always about news), or do you have multiple topics in each format (blog posts and tutorials on the same subject)?

5. Do Not Abbreviate

Don’t abbreviate. Or, at the very least, spell out abbreviations or acronyms in all headings and at least the first time in narrative text. This goes back to the idea of accessibility for all user experience levels: spelling out acronyms and abbreviations breaks down the exclusivity of language used by a select group and it makes people feel welcome. Especially with acronyms, remember that they’re often repurposed by different professions or disciplines and what seems obvious to you is probably not obvious to a number of other people.

6. Use Tags

I can’t tell you what tags you should or shouldn’t use, but I can explain a bit about types of tagging systems and considerations you should take into account. Broadly speaking, I’ve found that people use ‘tag’ and ‘index’ and ‘taxonomy’ interchangeably, though to a librarian they are wildly different things! Outside of information science we can think of two types of tags: folksonomies and controlled vocabularies. Folksonomies are like what you see with tags on Flickr: it’s pretty much a free-for-all. Users tag with whatever terms they like and the list of possible terms is both uncontrolled (no one is watching for synonyms or misspellings!) and crowd-sourced (created by non-experts). A controlled vocabulary, on the other hand, has a defined list of ‘official’ terms that is created & maintained by an ‘expert’ of some sort. There may or may not be relationships built between terms: equivalencies (CA = California), broader/narrower terms, and/or replacement (weed USE marijuana). The good news is that there is probably a place you can find tags in use that are a similar topic or content to yours that will inspire the tag structure and/or terms you’ll want to use. If you go the folksonomy route, beware of plural/singular discrepancies in your terms!

7. Maximize Software Utilization

Many file storage, word processing programs and website software actually have built-in metadata capabilities, though they may be hard to find and harder to understand how to leverage. The worst part may be getting into the habit of adding metadata to your content after creation. Just like people who end up with piles of photographs with nothing written on the back, we all have digital mounds of files & content with no format or subject information in the Properties. The benefits of having metadata are huge, for users and for you! You’ll need to have done some thinking about format and subject, but if your website software has any metadata functionality (like tagging), please use it!

8. Utilize textual structure

Textual content is created and aggregated in so many forms using so many different programs that specificity is difficult. Generally, you want to exploit the features of the textual program to the greatest degree possible. Using Headings in Google Sheets or hyperlinked Table of Contents in Microsoft Word are the two examples that come best to my mind. If the program you’re using has built in options to establish hierarchy or structure to that text, please use it!

9. Name Carefully

This tip came to me a few weeks ago when I went looking for a particular cheatsheet. Turns out that between the heading and the descriptive text the package name and the words “cheat sheet” appeared, but not next to each other. A Google search netted a ridiculous number of results, but the current version of that package’s cheat sheet was not on the first two pages. Needless to say, it was only through knowledge I’d recently gained from a coworker that I remembered the exact file path to that page and could read through until I found the one that was the right match. Let this be a lesson: what you call your content is how you should name it, and all the words should be together (imagine someone will put that name in quotes in the search box). Also, think about nicknames or shortened versions and make sure they’re present in text or tags so that the content can be discovered by a search engine and a user.

10. Utilize Search and Browsing

Research into information-seeking behavior shows that people use a combination of searching AND browsing when they’re trying to find information they need. As they browse a website or document or file, they put together a mental map of the content they could possibly find and make a search based on that assumption. They’ll further refine their search as they see results, perhaps navigating into a result or two to further their understanding . You’ve probably seen or done something similar with a print book, trying to determine if it’s one you want. Given this behavior, it’s important to provide access to your information through both methods: search and browse. Tags help with searching, though browsing a list of tags will tell you a lot about the content contained in the resource you’re looking at. Software that makes use of metadata and structural labels enhances search tremendously.

The more of these tips you’re able to implement, the greater success users will have in finding the information you’ve created for them.
Good luck!

This Is Not Like the Others

Mon, 02 Dec 2019 00:00:00 +0000

This summer I had the opportunity of working as an intern for RStudio. Among the available projects/mentors, I was fortunate to collaborate with Max Kuhn developing the applicable modeling R package now available here. The package comprises of a collection of applicability domain models to measure the reliability of a given model’s prediction. These models are borrowed from Chemistry, where they are widely used to measure the reliability of QSARs models.

Applicability Domain Methods

Applicability domain (AD) models are unsupervised approaches to characterize the nature of a prediction’s extrapolation. They are based on the premise that a model’s prediction is reliable if the sample from which a prediction is made is similar to the training set. The following are examples of AD methods:

Simple distance measures can be used, e.g., the leverage or hat value of a data point.
Similarity measurements, which are preferred when the predictor space consists of all binary predictors. A common metric is the Jaccard index.

Let us dive into some of these methods through the applicable package.

The `applicable` package

The applicable package contains models to analyze binary and continuous data. The Jaccard index – a similarity statistics – is a specialized indicator when working with binary data. On the other hand, for continuous data, both principal component analysis and hat values are employed.

library(applicable)

Binary data: the Jaccard index

Similarity statistics can be used to compare data sets where all of the predictors are binary. One of the most common measures is the Jaccard index. Given sets A and B, the Jaccard similarity between A and B is defined as

$$J(A, B) = \frac{\|A \cap B\|}{\|A \cup B\|}$$

For a training set of size n, there are n similarity statistics for each new sample. These can be summarized via the mean statistic or a quantile. In general, we want similarity to be low within the training set (i.e., a diverse training set) and high for new samples to be predicted.

To analyze the Jaccard metric, applicable provides the following methods:

apd_similarity: analyzes samples in terms of similarity scores. For a training set of n samples, a new sample is compared to each, resulting in n similarity scores. These can be summarized into the median similarity.
autoplot: shows the cumulative probability versus the unique similarity values in the training set.
score: scores new samples using similarity methods. In particular, it calculates the similarity scores and if add_percentile = TRUE, it also estimates the percentile of the similarity scores.

The example data is from two QSAR data sets where binary fingerprints are used as predictors.

data(qsar_binary)

Let us construct the model:

jacc_sim <- apd_similarity(binary_tr)
jacc_sim

## Applicability domain via similarity
## Reference data were 67 variables collected on 4330 data points.
## New data summarized using the mean.

As we can see below, this is a fairly diverse training set:

library(ggplot2)

# Plot the empirical cumulative distribution function for the training set
autoplot(jacc_sim)

We can compare the similarity between new samples and the training set:

# Summarize across all training set similarities
mean_sim <- score(jacc_sim, new_data = binary_unk)
mean_sim

## # A tibble: 5 x 2
##   similarity similarity_pctl
##        <dbl>           <dbl>
## 1     0.376            49.8 
## 2     0.284            13.5 
## 3     0.218             6.46
## 4     0.452           100   
## 5     0.0971            5.59

Samples 3 and 5 are definitely extrapolations based on these predictors. In other words, the new samples are not similar to the training set and so predictions on them may not be very reliable.

library(applicable)

Continuous data: PCA

When working with continuous data, applicable provides the following methods to analyze the applicability domain of your model:

Principal component analysis
Hat values statistics

To see applicable in action, let us look at the principal component analysis of the Ames IA housing data.

library(AmesHousing)
ames <- make_ames()

There are 2,930 properties in the data.

The Sale Price was recorded along with 81 predictors, including:

Location (e.g., neighborhood) and lot information.
House components (garage, fireplace, pool, porch, etc.).
General assessments such as overall quality and condition.
Number of bedrooms, baths, and so on.

More details can be found in De Cock (2011, Journal of Statistics Education).

The raw data are at http://bit.ly/2whgsQM but we will use a processed version found in the AmesHousing package. applicable also contains an update for these data for three new properties (although fewer fields were collected on these).

To pre-process the training set, we will use the recipes package. We first tell the recipes that there is an additional value for the neighborhood in these data, then direct it to create dummy variables for all categorical predictors. In cases where there are no levels observed for a factor, we eliminate predictors with a single unique value, then estimate a transformation that will make the predictor distributions more symmetric. After these, the data are centered and scaled. These same transformations will be applied to the new data points using the statistics estimated from the training set.

library(recipes)
library(dplyr)

ames_cols <- names(ames_new)
ames_new$Neighborhood <- as.factor(ames_new$Neighborhood)

training_data <- 
  ames %>% 
  # For consistency, only analyze the data on new properties
  dplyr::select(one_of(ames_cols)) %>% 
  mutate(
    # There is a new neighborhood in ames_new
    Neighborhood = as.character(Neighborhood),
    Neighborhood = factor(Neighborhood, levels = levels(ames_new$Neighborhood))
  )

training_recipe <-
  recipe( ~ ., data = training_data) %>%
  step_dummy(all_nominal()) %>% 
  # Remove variables that have the same value for every data point.
  step_zv(all_predictors()) %>% 
  # Transform variables to be distributed as Gaussian-like as possible.
  step_YeoJohnson(all_numeric()) %>%
  # Normalize numeric data to have a mean of zero and
  # standard deviation of one.
  step_normalize(all_numeric())

The following functions in applicable are used for principal component analysis:

apd_pca: computes the principal components that account for up to either 95% or the provided threshold of variability. It also computes the percentiles of the principal components and the mean of each principal component.
autoplot: plots the distribution function for pcas. You can also provide an optional set of dplyr selectors, such as dplyr::matches() or dplyr::starts_with(), for selecting which variables should be shown in the plot.
score: calculates the principal components of the new data and their percentiles as compared to the training data. The number of principal components computed depends on the threshold given at fit time. It also computes the multivariate distance between each principal component and its mean.

To see how these functions work, we will borrow the outputs of the shiny application we are currently developing for the package.

Let us apply apd_pca modeling function to our data:

ames_pca <- apd_pca(training_recipe, training_data)

Since no threshold was provided, the function computed the number of principal components that accounted for at most 95% of the total variance. Plotting the distribution function for the PCA scores is also helpful. In the shiny application, we can set the threshold as well as the subset of PCAs displayed.

For illustration, setting threshold = 0.30 or 30%, we now need only 13 principal components:

We can also update the number of PCAs displayed:

Finally, the score function compares the training data to new samples. This is the output of pca_score <- score(ames_pca, ames_new):

Conclusion

The project was ambitious and complex in nature, which made it that much more intereting. I learned a lot from Max and had an amazing experience working for RStudio. As I mentioned before, an application using the shiny package is currently in development. You can take a pick at it here.

RStudio Internships 2020 Preview

Mon, 25 Nov 2019 00:00:00 +0000

We are pleased to announce that RStudio’s summer intern program will run for a third time in 2020. 10 people who are full-time students at accredited institutions of higher education will have the chance to work with an RStudio mentor full-time for 12 weeks starting in May 2020.

The theme of this year’s program is learning: six of the interns will create new online lessons (which will be freely available for all to use under a Creative Commons license), while two others will work on supporting tools. An additional two interns will be embedded with RStudio’s Quality Assurance team to help extend and automate our testing processes. As in previous years, applicants must be US residents, and we hope to have a mix of both graduate and undergraduate students in 2020’s cohort. Please keep an eye on this blog for details—we look forward to hearing from you.

Please note: we originally intended to open applications in January, but have pushed the date back until after rstudio::conf 2020. We will make an announcement here when things get rolling again.

Lesson Developer

Tens of thousands of people have learned basics data science skills from RStudio’s cloud-based primers in class and on their own. In this project, you will work with a member of RStudio’s education team to develop primers on new topics, such as statistical modeling, Shiny, or publishing with R Markdown. Successful candidates will be comfortable programming in R using the RStudio IDE, familiar with the R Markdown toolchain, and enjoy writing and teaching. Your application needs to include a link to a lesson you have created that relates to programming or data science—it’s OK if you create something specifically for this application—and please also briefly describe the lesson you most want to create and explain why.

Learning Tool Developer

Lesson developers can create interactive exercises that run in the RStudio IDE and give learners feedback on their work using a variety of packages. In this project, you will work with RStudio’s developers and education team to extend these packages with new exercise types, add new and better ways to check answers and give feedback. Successful candidates will be fluent in R (including non-standard evaluation and package development) and familiar with either Python or JavaScript. To demonstrate these skills and your ability to work with Git and GitHub, your application needs to include a link to a package, Shiny app, or data analysis repository on GitHub. It’s OK if you create something specifically for this application: we just want to know that you’re already familiar with the mechanics of collaborative development. Please also briefly describe one feature that you think learnr doesn’t have that you would like to add and explain why.

Quality Assurance

Few things are as frustrating as working for hours only to find that the fault lies in your tools. In this project, you will build tests and testing infrastructure to check and maintain the quality of RStudio’s tools. Successful candidates will be familiar with test automation and have some experience with R and Python; familiarity with Selenium, Docker, and Jenkins will be an asset as well. To demonstrate these skills and your ability to work with Git and GitHub, your application needs to include a link to a public Git repository that contains some testing work you have done. It’s OK if you create something specifically for this application: we just want to know that you’re already familiar with version control and modern testing tools. Please also briefly describe some tests you have written to check the correctness of your own software and describe what errors they caught.

My Experience with RStudio Instructor Training

Tue, 19 Nov 2019 00:00:00 +0000

I recently became a certified RStudio Instructor in both Shiny and the Tidyverse. I thought I would write a little about the experience. I haven’t really had any formal pedagogical training, and having some of the state of the art and evidence-based practices were really helpful in extending my approaches to teaching.

Instructor Training

The instructor training is online, but delivered via Zoom. The session themselves are 4 hours apiece and at set times, with a small cohort overall (I think mine was about 14). Greg Wilson delivered a short set of slides for each activity, and depending on the activity, we were sent out into smaller groups to discuss the topic. I liked how the course was paced - I felt like having activities almost every half hour definitely kept me awake.

The training for me (I am on PST) was from 8 AM to 12 PM two days in a row, and my cohort was from all over the US/Canada.

Here are the parts of the instructor training that I found especially useful. Note that since Greg also helped develop the Carpentries instructor training, there is some overlap between the two training programs (in fact, if you’ve taught a Carpentries course and done the Carpentries training, you can waive the instructor training altogether).

Building concept maps. If you can, you should map out the concepts you want to teach, along with how these concepts are related. This concept map is important in helping your students build the mental models that will guide them towards mastery. I did a concept map of Tidy data for my example. Concept maps themselves are a bit tricky to build, but I think they help clarify your understanding of what you are teaching, and thus your lessons will be more understandable.

Thinking about cognitive overload. This was a call to think about limiting the number of concepts and connections covered per unit. Humans have a short term memory of about 5 +/- 2 things at a time. This is an extremely helpful guideline to consider when developing training units, as your course objectives and training should keep these in mind. Also, there are different kinds of cognitive overload, and some of them (like extraneous details), you can remove to help with the other kinds. There are lots of ways to teach coding, such as Parsons Problems (where students have to put lines of code in order), or faded examples (fill in the blank style coding assignments), that can focus on particular aspects of coding. (As an unrelated topic, I have been thinking about reading code as being an essential skill and I try to teach students to learn how to read code.)

Teaching needs to be dynamic. As instructors, part of our value lies in tailoring our training for our students and their previous knowledge. Unlike YouTube videos, we can assess what our students already know, and focus on the concepts that they don’t. In order to do this, though, we need to have ways of assessing what our students know. Formative assessments (assessments during a lesson) are essential in figuring out whether you can proceed, or whether you need to spend more time.

Providing feedback. We were to teach each other a short lesson of our choosing, which was pretty fun. After a test run with a larger group, my partner and I got to teach each other - she taught me about making jam (and the food safety issues) and I taught her about making cornbread. (It was close to lunchtime when we did this, I think we were both hungry.) The exercise was super useful in helping us to not be afraid of giving feedback and to be aware of what kinds of feedback to give.

What demotivates students. This was an important section, and a bit emotionally difficult. I have been guilty of some of the teaching behavior that demotivates students, such as taking over their keyboard, instead of letting them fix it. If we are to be inclusive and welcoming to everyone, we need to be aware of these (sometimes subtle) behaviors that can discourage and demotivate all of our students.

Other tips from other instructors. I really enjoyed hearing other instructor’s experiences and I had a lot of respect for my cohort. There were lots of little tips we shared with each other that were super helpful, such as the types of mics to use. I also thought that it was helpful when we shared our struggles with each other. It made me feel much more as part of a group of instructors, which was very helpful for me.

Instructor Certification Exam

The instructor certification covered the pedagogical techniques we discussed in the instructor training. This exam, like the others, was open book, open note, open internet, but not open person (no lifeline, no talking with others).

As part of the exam, we were required to develop and deliver a lesson. I ended up reworking one of my SQL lessons in my Analytics course. I found it a really useful exercise in rethinking my examples discussing left and inner joins, especially in my table examples. You can see my lesson here: SQL Joins in R.

This part of the exam is only about 10 minutes long, but you should be prepared, especially in figuring out how you will assess the learning of the students.

Tidyverse Certification Exam

After I had done my instructor certification, I had to do the technical qualifications. This was also done online, with Greg delivering the exam over Zoom. Most of the exam had to be done via RStudio on my computer. This exam, like the others, was open book, open note, open internet, but not open person (no lifeline, no talking with others).

What did the exam cover? Roughly, it covered almost all of R for Data Science and was very task-focused. There was a focus on debugging, data transformation, markdown and visualization. The tasks were mostly problem driven, on the order of recreating a figure, or parametrizing a workflow. It was emphasized that we should solve the problems the way we usually work and talk out our problems aloud. For one of the problems, I actually had to search and teach myself on the fly. This was actually a good way to confirm that my conceptual models of the tidyverse were helpful.

One tip: 90 minutes is a long amount of time for an exam, especially where you are actively thinking and talking out loud. You should have something to eat by your side so you can replenish your blood glucose. It is also slightly unnerving to have someone watch you actively solve problems and program. If you get flustered, take a breath. There’s not usually a single way to solve the problems.

Shiny Certification Exam

A few weeks later, I took the Shiny certification. In terms of coverage, there is not currently a good text to study for the Shiny Certification exam ( Mastering Shiny is probably going to be the reference to study when it is finished). In order to prepare, I went over the RStudio articles about Shiny, and looked over the RStudio Shiny Gallery to bone up on the different programming techniques used in Shiny, such as UI elements, reactives, the observe/update pattern, and modules.

Again, the exam covered debugging, including fixing applications, understanding control logic between ui and server, and building an app from scratch. I would say much of the exam covers how well established your own mental model of Shiny progamming is.

One thing to remember: as the technology and code changes, the certification exams will change and you may have to get re-certified. So my experience of these exams may be different than your experience.

Overall Experience

I thought the training was extremely useful, especially in terms of learning more about evidence based methods in effective education. As someone who is thinking about starting a consulting group focusing on training, having the certifications are extremely valuable to me and my future career. I look forward to teaching and training more people in R.

For More Info

Please consult the RStudio Trainer Website for info on how to register for the instructor training.

Full Disclosure: my department paid for the training and two of the certification exams. I did the Shiny exam for free with the stipulation that I would provide feedback on the exam itself. This article was originally published here.

My First Software Engineering Internship

Thu, 07 Nov 2019 00:00:00 +0000

Prior to this internship, my coding abilities were amateur at best. After this internship, I have not only become fluent in R, but also more confident in my software abilities in general. I have my mentors Davis Vaughan and Max Kuhn to thank for helping me build this agency, as well as the 2019 intern cohort and the #rstats community, but long story short, if you’re interested in learning how to contribute to open source, ship production-level code, or build software products, I would highly recommend applying. The training I had was exceptional.

The Application Process

The application is short, and the bulk of it lies in simply having a web presence. I sent my application on the last day of the submission window. Since I did not make it past the interviews last year, I was hesitant about applying, but the desire to intern was still there, so I applied again.

My website at the time was a jenky hand-coded HTML landing page with links to several Shiny apps I made for an introductory stats course. As there are many resources available to quickly get up and running with a beautiful, responsive, mobile-friendly website, please avoid making the same mistake I did. My favorite resource remains Alison Hill‘s summer of blogdown.

I heard back a week after applying and interviewed with Barret Schloerke and Davis Vaughan. The interviews took place on Zoom and lasted 30-45 minutes. They began with introductions and included 10-15 minutes of background questions, 15-20 minutes of technical questions, and a few minutes at the end for me to ask questions. I panicked a little with the technical portion as I hadn’t anticipated it, but I thought out loud and asked clarifying questions along the way. About a week later, I received an email with the great news.

Working Remotely

Interning remotely is not for everyone, but I loved it: I could set my own schedule, so I traveled and saw family and was still productive. Working remotely, however, takes discipline and some getting used to: it’s not like you can turn around, tap your colleague on the shoulder, ask them a question, and get an immediate response.

In my first two weeks, my mentors answered every message I sent them within seconds, but past this initial period, a response might take minutes or hours. (The days where replies came hourly were rare; in fact, on those days, Davis and Max made it explicitly clear that they were either at a conference or in deep work, and would reply at a specific time.)

What I found most effective was asking easy questions in large team Slack channels (where I’d get an immediate response) and hard ones in private channels. Hard questions generally require someone reviewing my code base for a substantial amount of time. To be honest, knowing that I would have to wait to get feedback was great, because that gave me an excuse to either go out for a long coffee date or work on several side projects.

On the whole, my daily routine consisted of logging on around 7am, coding for 4 hours, hitting the gym, eating lunch, coding for another 3-4 hours, and if I had errands to run in the afternoon, I’d just make up those 1-2 hours after dinner. At the end of each work day, I’d log what I accomplished through an internal Achiever app. This not only helped me track my progress, but also let Davis and Max check in occasionally and provide any feedback or resources that could help. I was way more productive than I’ve ever been.

What I Did

The big wins for this summer were (1) building a new R package ( butcher) that reduced the size of modeling objects saved to disk, and (2) getting this package onto CRAN. (If this tool might be of any interest, please check out this overview.) My key takeaway is that I wish I had learned package development earlier. It would have made so much of my research efforts (in grad school) more reproducible, easier to consume, and easier to extend. A lot of the scripts I wrote prior to this internship were single, long-form functions that I simply copy-and-pasted if there were any internal pieces I had to change. Had I developed my research scripts as a package, I would have to modularized my code in such a way that each subunit was designed to be reusable and testable, and thus much more robust.

I cannot stress the importance of unit testing enough. There is some debate around what the optimal level of testing is relative to each line of code, but the general consensus I received (at least internally) was 80%. And for anyone that’s never built a package before, or for anyone like me who still looks up everything up, check out Jenny Bryan’s whole game chapter.

It’s possible to get a skeleton package up and running, with version control, under an hour. Other important milestones, prior to submitting to CRAN, were:

Setting up continuous integration
Styling and documenting my code
Creating an accompanying website with pkgdown (complete with a hex sticker by Allison Horst)

Getting the package onto CRAN was incredibly straightforward: the package underwent 3 iterations before it was finally accepted, but the edits were legitimate and minimal.

In General

My internship was unique (at least for me) because I wasn’t treated like an intern. My contributions mattered, and the relationships I developed with the interns and the employees at RStudio are irreplaceable. In fact, the interns and I still touch base every week or so, and whenever we might be going through something, or hitting any hurdles with our work, we’re there (at least virtually) for each other.

I’ve also learned to live outside my comfort zone. During my internship, I was given approximately a full week to work on anything I wanted. It didn’t necessarily have to open source, but I chose to hone my skills in Shiny and JavaScript. I was constantly breaking things or hammering my head into the proverbial wall, but as my mentor succinctly put it, “If you’re not breaking something, the project is too small.” It was in getting through these moments of discomfort that I’ve grown, as a developer, but really, as an individual. Within the limited time of this internship, I’ve gained not only greater confidence in what I can do, but also a sense of how to lead a creative and productive life.

12 weeks at RStudio

Wed, 30 Oct 2019 00:00:00 +0000

This summer I interned for RStudio’s education team. It was a total departure from my routine as a PhD student, and the perfect brew of the things I enjoy: building stuff, drawing stuff, and teaching stuff.

In this blog post I’ll share a run down of my experience. If you’re considering applying, then I hope this gives you an idea of what to expect.

I started writing a book.

I worked on a project with Alison Hill called “rstudio4edu”, a bookdown book for educators that bundled tutorials and practical advice about how to wrangle RStudio’s tools (e.g. R Markdown, packages, templates, etc.) to make life in the classroom (virtual or physical) easier.

I dove deep into the guts of different R Markdown collections and then wrote up cookbooks about how to customize each of these. The goal was to do this in a way that would make it fun for folks to read–especially for educators (or anyone, really) who might be comfortable in R but might not have a hardcore technical background to want to sink their teeth into a seemingly grizzly piece of documentation.

The book is chock-full of step-by-step guides, illustrations, concept maps, and first-rate metaphors. It pairs well with a rainy Saturday, a cozy pair of socks, and some motivation to get that course website done once and for all.

(It’s still a work in progress, but I’m so excited for it to be shared with y’all soon.)

I figured out what it’s like to work remotely.

I was nervous at first about remote interning. What would it be like to swear off cubicle culture for the summer and trade in my morning drive for a 5 second walk down my apartment hallway? I like going into an office and being around others when I’m getting things done, so I wondered whether it would be isolating to work alone.

Turns out that working remotely did not feel lonely at all. In fact, I felt surprisingly connected to my RStudio team. Alison was only ever a quick Slack message away, and during my first week we chatted daily. I also had a lot of autonomy when it came to how and where I worked. Most of the summer, Alison and I checked-in weekly to talk about progress, goals, and new ideas. The rest of the week I’d spend time creating, building, and troubleshooting those ideas. And if I ever got stuck, there was nothing that a call and a screenshare couldn’t fix.

I was a part of a team.

The education team had calls at least every two weeks. During these I heard about what everyone else was working on, shared my own progress, and also got to see the behind-the-scenes planning for upcoming RStudio events (like rstudio::conf 2020 workshops). Quick and witty banter across different Slack channels was the digital stand-in for coffee breakroom chatter and also made me want to up my emoji and gif game. On Fridays, there was a “virtual coffee” video chat that we interns organized amongst ourselves. By the end of the summer, I became cirque-du-soleil-level proficient at juggling many video conferencing windows and tabs, but more importantly, I felt like I was a part of nice little work family that I could brainstorm and collaborate with.

Things I learned/ got better at

On day 1, Alison’s first assignment to me was to learn something new. R Markdown sites were my comfort zone, but I had no idea about its friends or relatives (bookdown, Distill, etc.) For certain, the bulk of what I learned were the ins-and-outs of these, but throughout the summer there were many added bonuses. Here are a few:

I discovered that R packages are not just for functions.

R packages are as diverse as holiday present boxes, and it turns out you can put almost anything in them. Templates, data, interactive tutorials.

I honed my CSS chops.

CSS has always been a neglected love of mine. Like a rubix cube that you can’t quite give up on, I finally had the reason and the space to spend time manicuring all the *downs to my heart’s content, learning a ton of CSS minutiae in the process.

I discovered many existing R packages that I wish I’d known about years ago.

The janitor package for cleaning data (and data names)
The here package
I witnessed the birth of the ymlthis package, created by a fellow intern.

I finally started to feel comfortable using GitHub.

I used to be a very timid GitHubber. Working at RStudio, by necessity ripped the band-aid off of most things Git. A couple weeks in, I was makin’ repos and filing issues like it was my job (and, technically, it was). Today, I am still not a Git guru, but I learned that most people aren’t and that it’s okay to learn things on the job. What’s more important is that I no longer have qualms about digging in others’ repos or creating pull requests– and that’s the gift that keeps on giving when it comes to learning and growing as an R coder ;)

[![](Tweet.jpg)](https://twitter.com/apreshill/status/1164015060919865344)

What I really appreciated

The work I did at RStudio integrated all my skills–many of which I hadn’t been using in my PhD world. I got to be creative (making art!), code in R, build websites, and spend thinking about user experience and design. In a single summer, I developed a resource that will eventually be read by an audience much larger than what my 5 years of PhD work will ever reach (oof, truth hurts). It was so nice to receive encouragement and support to develop skills that would be useful to me even long after my intern work was over (e.g., blogging, writing abstracts, and actually using twitter).

I also appreciated how generous RStudio employees were to interns with their time and skills: Carl Howe gave a mini-workshop on crafting exemplar elevator pitches, Greg Wilson offered up stellar instructor training, and Alison Hill led us through Summer of Blogdown, where each intern developed their own personal website.

Advice for prospective interns

Apply! If you love R and you love building and making things, then give it a go. I was worried that my technical R coding skills or analytic chops would not be advanced enough to intern–and I almost let this discourage me from applying. If I’d let that get in the way, I would have never realized how much I wanted the type of work I did this summer to continue to be a part of my career path.

More to come

I’ve always been interested in the combo of art, education, and tech– so if you’re interested in learning more about what I’ve gotten up to, then check out my website, follow me on twitter, or come to rstudio conf where I’ll be giving a talk on my and my colleague’s R Markdown project about teacup giraffes (to teach stats and R).

Workshops at rstudio::conf(2020)

Mon, 28 Oct 2019 00:00:00 +0000

rstudio::conf(2020) is fast approaching, and in addition to the many fantastic talks lined up for the conference, we’re very much looking forward to the Training Days, which will feature a whopping 19 2-day workshops!

Below is a closer look at each of these workshops. We hope that this information can help you decide which one to attend. It’s a tough decision!

And once you make up your mind, you can head over to rstd.io/conf register for the conference and sign up for a workshop. Please note that some workshops may fill up; to see how many spots are available, click on the link above and select “Agenda” from the top menu. Also, workshop-only registration for the conference will open up November 1.

What it Was Like Interning for RStudio

Fri, 25 Oct 2019 00:00:00 +0000

I spent the summer creating a series of lessons to teach statistics and data science to software engineers using software engineering data sources and academic research on software engineering practices. It’s nowhere near finished, but I learned a lot that I hope other people will find helpful. If you don’t care about the details, you can check out a first draft of the project at ds4se.tech.

The Interview

Over the past few years I have developed a love for R. I even pleaded with my Quantitative Methods class to give it a chance, reminding them that any new language can be annoying. (It turns out R is, but now I have a more nuanced understanding of why.) So when I applied to RStudio it was in hope that I could combine my love of R with my PhD research in general machine learning literacy.

I get extremely nervous for interviews, which may have something to do with The Needs of Autistic Adults in Video Calling. It might also have to do with my all-over-the-place background and skills: I don’t yet feel like a specialist in any one thing. But the interview went well, covering everything from my research to my activist work. My interviewer (and soon-to-be internship supervisor) emailed me a few days after our interview to try to call me (for goodness sake). I avoid phone calls like a good autistic millennial, but at least I knew what I would be working on several months in advance, which gave me time to rapidly learn everything I could about software engineering.

The Project

“Data Science for Software Engineers” is a set of hour-long RMarkdown lessons (and packaged data) that students can use to learn statistics on software engineering problems. The problems include “how many repositories are on GitHub and how fast is it growing?” and “how bad will your code suffer if you’re sleep deprived?", and the idea is to motivate computer science students and early-career software engineers to learn about data science and research findings using topics they care about.

When the project was first pitched to me I had no idea why anyone cared about Git repos or Agile development or test suites or whatever. What I did get was teaching statistics in a meaningful and gentle way, and when I told software engineers about the project their eyes lit up.

Preparation

I signed up for a Software Engineering Research seminar the second I accepted the internship and vowed to read as much as I could before starting work so that no one would regret hiring me. The first day in that seminar was incredibly frustrating. I hadn’t realized how little I knew about software engineering: I simply did not know the terminology or the practices at all. I’d written a few unit tests before, but that was about it. I had no idea what a “test suite” was (it’s just a bunch of unit tests). We were reading a paper that mentioned the use of “fuzzers” and I felt totally out of my element. (Fuzzing is just throwing random data at a program to try to break it and make sure you didn’t miss any weird edge cases). My RStudio mentor sent me lots of resources and my PhD advisor Amy Ko has a strong background in software engineering and computing education research.

Skills

The first day sucked, in hindsight because I didn’t properly advocate for myself. My mentor tasked me with the first lesson we wanted to make: How many repositories are there on Github? Well, I had basically used one API before and then given up because I didn’t understand permissions, what I had access to, or how to submit queries. I’m now in a course that I call “Bigger Data” (because I already took “Big Data” and this one was next) where I’m learning all the SQL, cloud computing, and API magic for data science. But the first SQL I ever wrote was on my first day of my RStudio internship and I didn’t want to admit how little I knew. I got there eventually, but I should have told my mentor that I needed time to ramp up.

That first week was a sign of things to come: the summer was a skills bootcamp for me as well as an opportunity to create educational materials instead of theorizing how we should teach computing. Some of the things I picked up include:

Introduction to SQL
Waaaaaay better at using Git collaboratively and productively
Also better at video conferencing (if you don’t think this is a skill, you haven’t worked in a distributed company or had a long-distance relationship)
Teaching skills and exercises and how to make hard choices when designing at scale
Some API/cloud work
ggplot2, dplyr, and other data science skills
Software engineering knowledge, both conceptual and practical
Explaining statistics and envisioning how lessons could look like at large scale
Company internals/business things I didn’t know about
How to rid my work of excess exclamation points

Next Steps

I’m back at PhD school now working on interventions for developing machine learning literacy using personal data. The project has a long way to go, but I hope to return to it soon to evaluate some of its effectiveness and finish enough of it so that we can begin to circulate it. I’ll be at rstudio::conf 2020 both as a volunteer (equipped with some gender, accessibility, and sensory guidelines for all) and with a quick lightning talk about the project—I hope to see you there.

A longer form of this post originally appeared here.

My JavaScript Internship at RStudio

Mon, 21 Oct 2019 00:00:00 +0000

This post was written by Maya Gans about her 2019 RStudio internship where she built https://tidyblocks.tech. Maya also documented her project and progress at https://maya.rbind.io/tidyblocks/.

It’s funny to admit, but I applied for the RStudio internship because I wanted to learn JavaScript. I was receiving my Masters in Botany and found myself programstinating, a term I just made up for making plots and Shiny Apps from personal data instead of extracting DNA or writing my manuscript.

But programming was only a byproduct of my Master’s work and I began to realize if I wanted to identify as a programmer, I needed a more holistic understanding beyond the subset of packages and functions I used for my Masters work.

Enter the TidyBlocks project. I remember in my interview telling Greg Wilson my primary goal for the summer: to know more about JavaScript. When applying, I felt comfortable with as much JavaScript as you’d find in the first chapter of any book: arrays, lists, strings, and basic operations. I also had created some d3.js visualizations by Frankenstein-ing open source code snippets together. I was reading a lot about coding but hadn’t written much. I certainly never started a project from nothing.

Starting a project in a language you don’t know sounds daunting, but TidyBlocks hit the failure sweet spot. Failure is an inevitable part of learning new skills, but trying something too far beyond your current ability can be debilitating. The TidyBlocks project was built on Google’s Blockly, a JavaScript library for building programming editors. I wasn’t starting with a completely blank console, I had code to try to understand, and eventually build on.

I spent my first month or so understanding the library, then eventually creating custom blocks to import, transform, and visualize data. I’d go to bed perplexed, and in the morning jump out of bed with a solution. Git allowed me to make code worse before it got better. Eventually I even stopped referring to Happy Git with R. I learned how to work in branches and review code. I no longer questioned my abilities, figuring things out became a matter of when.

A little over halfway through the internship I had a working user interface and a palette of blocks. I found myself looking at the code written at the beginning of the internship and squirming. I could write this again. Better.

TidyBlocks 2.0 began in a fresh repo where I cleaned up and abstracted the code. Once functioning, the webpage was overhauled again to use the React.js framework, a popular tool for front end web developers.

I could talk about the specifics of the tool I developed, but I think what’s more important was that this internship gave me the space to learn tools and concepts I wanted to master by building something I am not only proud of, but know people can benefit from.

Being a self taught programmer can be daunting, so interning for R Studio was the perfect mix of structured learning of core concepts mixed with creative freedom when executing the specifics. In fact, having a mentor who pushed me and believed in me gave me the confidence to apply (and land!) a job where I’ll be writing custom JavaScript for Shiny Apps. And the mentorship at RStudio goes well beyond your assigned instructor. I was initially intimidated by the giants who create the packages I use almost daily, but everyone at RStudio is incredibly approachable and excited to chat over virtual coffee (or communicate on Slack solely through emojis and gifs).

There’s also workshops offered to interact with employees outside of your project – I learned how to be a TidyVerse instructor with Greg Wilson, and created a blogdown website with Alison Hill. I strongly attribute having a professional web presence to my employment and Alison will forever be my mentor AKA #RMom. I also learned a ton from the other interns in the cohort, some of whom I’m sure I’ll be friends with forever.

I wanted to write an objective post where I measured the skills I had going into the internship against the many skills I gained, but I’d be remiss if I didn’t mention how profoundly this internship changed my life. Not only has this job empowered me to become a professional programmer, but it also gave me an insight into what an inclusive tech company looks like and what constitutes a healthy work life balance. I’m so grateful that I had the opportunity to learn from the people I hold so much respect for. I strongly believe anyone who is motivated and excited to learn would gain immensely from interning with RStudio. As much as I try to remain quantitative, what I’ve gained is immeasurable.

Tools for Teaching YAML with ymlthis

Fri, 18 Oct 2019 00:00:00 +0000

R Markdown is one of the most powerful aspects of the R ecosystem, and it’s also surprisingly intuitive. Markdown itself has a simple syntax, and R Markdown handles so many of the tricky details of document creation that the basics will get you a long way. But there’s one area of R Markdown that consistently trips students up: YAML.

YAML (“Yet Another Markup Language” or “YAML Ain’t Markup Language,” depending on who you ask) is the metadata that tells R Markdown, pandoc, and other software exactly how to process or display the document. But YAML looks and smells differently than R. What’s with this white space? Does this need quotation marks? Where’s the documentation? Why doesn’t this work? Often, the simplest solution is to copy and paste the YAML from older documents. (That’s what I did for a long time. At least I knew it would probably work!)

I spent my summer internship at RStudio trying to reckon with this problem. Work my mentor Rich Iannone led to the ymlthis package ( now on CRAN!). ymlthis addresses these issues by documenting YAML options for R Markdown and friends, providing R functions to write YAML for you (in the correct syntax!), and providing new ways of working with R Markdown and YAML files.

ymlthis also includes several tools useful for teaching YAML. Three particularly relevant elements are 1) writing YAML chunks for you in a reproducible, safe way, 2) drawing the nested structure underlying YAML, and 3) the YAML Fieldguide, a comprehensive guide to YAML options in the context of R Markdown. The first two are useful for creating teaching materials, while the third is a great place to point students to during exercises or for future reference.

Writing YAML with ymlthis

One of the main features of ymlthis is that it can write YAML for you.

library(ymlthis)
yml() %>% 
  yml_output(pdf_document(), html_document()) %>% 
  yml_latex_opts(fontsize = "12pt")

---
author: Malcolm Barrett
date: '`r format(Sys.Date())`'
output:
  pdf_document: default
  html_document: default
fontsize: 12pt
---

By default, this simply prints to your console. (You can also write it to files or place it on your clipboard; see the vignette introducing ymlthis). ymlthis includes a function, asis_yaml_output(), that will take the result of yml_*() functions (which all return objects of class yml) and turns them into knitr YAML chunks. YAML chunks display the output as proper YAML (not R output, as above) with correct syntax highlighting. Since ymlthis produces safe, correct YAML, you won’t have to double-guess your teaching materials. For example, Alison Hill uses it in her recent workshop, R Markdown for Medicine.

last_yml() %>% # use the most recent `yml` object
  asis_yaml_output()

---
author: Malcolm Barrett
date: '`r format(Sys.Date())`'
output:
  pdf_document: default
  html_document: default
fontsize: 12pt
---

In an R Markdown document (including slides!), a useful trick is to set a knit_print method for the yml object. Writing knit_print.yml to call asis_yaml_output() and including it in your document will automatically convert all yml objects to YAML chunks.

knit_print.yml <- function(x, ...) {
  ymlthis::asis_yaml_output(x, ...)
}

Drawing the hierarchy in a YAML header

YAML uses whitespace to specify the relationship between fields. This syntax can be quite confusing for R users since R does not use whitespace in this way. To make these relationships more explicit, draw_yml_tree() takes a yml object and draws the underlying connections between the levels of the metadata.

Let’s consider an example using output functions. The output field takes R functions from the rmarkdown package that specify how to produce the document. The default, for instance is rmarkdown::html_document(). While we don’t usually write it this way, the YAML fields nested underneath the output types are just arguments that get passed to the function you’re using (thus you can see the options by reading the help page for the function, e.g. ?rmarkdown::html_document()).

yml() %>% 
  yml_output(html_document(toc = TRUE, toc_float = TRUE))

---
author: Malcolm Barrett
date: '`r format(Sys.Date())`'
output:
  html_document:
    toc: true
    toc_float: true
---

draw_yml_tree() draws this relationship more clearly.

draw_yml_tree() # draws the most recent YAML by default

├── author: Malcolm Barrett
├── date: '`r format(Sys.Date())`'
└── output:
    └── html_document:
        ├── toc: true
        └── toc_float: true

toc and toc_true are nested under html_document, which is, in turn, nested under output. Here’s the structure for more than one output type:

yml() %>% 
  yml_output(
    html_document(toc = TRUE, toc_float = TRUE),
    pdf_document()
  ) %>% 
  draw_yml_tree()

├── author: Malcolm Barrett
├── date: '`r format(Sys.Date())`'
└── output:
    ├── html_document:
    │   ├── toc: true
    │   └── toc_float: true
    └── pdf_document: default

html_document and pdf_document are both nested under output, while the arguments for html_document are still connect to that function. This also explains why missing whitespace will often produce the wrong results: if we misspecify the whitespace, we misspecify the structure of the metadata. Let’s say we write some YAML that looks like this, where both toc and toc_float have the wrong indentation:

---
output:
    html_document:
    toc: true
toc_float: true
---

This document won’t render correctly, because the YAML has this underlying structure:

├── output:
│   ├── html_document: null
│   └── toc: true
└── toc_float: true

R Markdown doesn’t know that toc and toc_float are related to html_document(). It thinks the value of html_document is NULL! This particular example even renders (because, although toc is not an output function, R Markdown only evaluates html_document). Whitespace errors like these often fail silently.

The YAML Fieldguide

Figure 1: The YAML Fieldguide and the types of YAML documented therein. Image by Mara Averick

The final resource I want to talk about is one of the most straightforward but most useful: documentation. YAML that we use for R Markdown is documented in many ways across many pieces of software. It’s often hard to dig up what the options are. A benefit of using R functions to write YAML is that each field is documented in the function’s help page. But ymlthis goes one step further: the YAML Fieldguide, one of the three vignettes included in ymlthis, aggregates every YAML option documented in the package, organized by source Because the options are in a single place, they are easily searchable. They also link back to the help pages for more information.

The Fieldguide thus provides a comprehensive source for finding options to set in YAML and understanding what valid values are.

Learn More

The ymlthis package is still early in its lifecycle, but it can already do a lot, including writing R Markdown and YAML files, creating ad-hoc templates, and creating new R Markdown files using an add-in that helps you write your YAML. See the package website for more. Of particular use may be its three vignettes:

A Summer of RStudio and ggplot2

Tue, 15 Oct 2019 00:00:00 +0000

This post was written by Dewey Dunnington about his work during his 2019 RStudio internship. Dewey’s original post was published on his blog and is published here with some minor edits with Dewey’s consent, as part of our series highlighting the work of RStudio’s summer interns.

This past summer, I had the incredible opportunity to spend the summer as an RStudio intern working with Hadley Wickham on the ggplot2 package. It was a welcome change of pace from writing articles about mud in lakes, and I’m sad the internship is over.

Figure 1: RStudio summer interns and software engineers meet up at the Boston office

I had the opportunity to work alongside a lot of great interns at a fantastic company, prepare tons of issues for tidy-dev-day at UseR!, become an RStudio-certified tidyverse trainer, spiff up my website considerably with blogdown, and of course develop a few humble new features for ggplot2! Here are a few of them:

library(ggplot2)

New vignette on using ggplot2 in packages

I joined as an intern just prior to the release of ggplot2 3.2.0. Before all ggplot2 releases, we run the CMD check on every reverse dependency (there are 2,622 of them as of the last revdep check) with the CRAN version and with the release candidate to make sure we don’t introduce new failures. In sifting through the failures, it became clear that there was no documentation about how to use ggplot2 in a package in a way that wouldn’t be likely to break in the future. Thus, the Using ggplot2 in packages vignette was born! It covers how to refer to ggplot2 functions, how to create a mapping without triggering a CMD check error, and best practices for common ggplot2 uses in packages (like creating a theme or visualizing an object).

coord_trans() improvements

The difference between a ggplot with scale_(x|y)_log10() and a ggplot with coord_trans((x|y) = "log10") is a common reason that issues get opened in ggplot2. In short, scale_(x|y)_log10() applies log10() to the x and/or y aesthetics before anything happens, including computing any statistics. Using coord_trans((x|y) = "log10") applies log10() after everything happens. This means that a geom_boxplot() with scale_(x|y)_log10() is going to have different outliers (say) than a geom_boxplot() with coord_trans((x|y) = "log10").

p <- ggplot(diamonds, aes(cut, price)) + geom_boxplot()

patchwork::wrap_plots(
  p + scale_y_log10(),
  p + coord_trans(y = "log10"),
  nrow = 1
)

It’s common for an issue to be opened for cases where this is non-intuitive (stat_summary() comes to mind - it’s not intuitive that summary statistics are not calculated on the original data), and the response is often that coord_trans() should be used instead of a transformed scale. However, there were problems with the expansion of discrete scales in coord_trans() that prevented coord_trans() from being a viable solution. In the PR fixing this, I also fixed a problem with second axes in coord_trans(), and made sure that the "reverse" trans worked (it didn’t before, but it doesn’t appear that anybody noticed). Hopefully coord_trans() is now ready to serve as a drop-in replacement when scale_(x|y)_log10() gives non-intuitive results!

NA limits in coord_cartesian()

Another common source of confusion in ggplot2 is the difference between scale_(x|y)_continuous(limits = ...) and coord_cartesian((x|y)lim = ...). When setting scale limits (this includes xlim() and ylim()), data is “censored” by default, meaning values outside this range magically turn into NA and disappear; when setting the coordinate system limits, the data are still exist, but data outside the (expanded) limits are not shown.

patchwork::wrap_plots(
  p + scale_y_continuous(limits = c(0, 10000)),
  p + coord_cartesian(ylim = c(0, 10000))
)

## Warning: Removed 5222 rows containing non-finite values (stat_boxplot).

In this example, using scale limits (on the left) leads to displaying spurious information about where the min and max of the data are. When this issue comes up, the response is usually that the user should use coord_cartesian(ylim = ...) (as shown on the right) instead of scale_y_continuous(limits = ...). Scale limits have this awesome feature where you can pass NA as one or more of the limits to refer to the minimum or maximum of the data, but this previously wasn’t possible for coordinate system limits. Now it is! It’s particularly useful with facets where scales = "free":

ggplot(diamonds, aes(color, price)) +
  geom_boxplot() +
  facet_wrap(vars(cut), scales = "free_y") +
  coord_cartesian(ylim = c(0, NA))

Axis guide improvements

When I started my internship, there was a long-standing open issue about overlapping axis text. Previously, it was impossible to do any customization of axes other than change the breaks and/or labels in the scale_*() functions, which could be customized a bit using theme(), and anything else was a crazy workaround. Now that this pull request has been merged, axes will use the same guide system that powers guide_legend() and guide_colourbar(), such that you will be able to customize how axes are drawn (and in the future create custom ones!). This feature comes with a couple improvements for dealing with overlapping text in the new guide_axis() function:

# you'll need the current development version of the package
# remotes::install_github("tidyverse/ggplot2")
ggplot(mpg, aes(hwy, cty)) +
  geom_point() +
  # create closely-spaced breaks that will overlap
  scale_x_continuous(breaks = seq(10, 50, 2)) +
  facet_wrap(vars(drv)) +
  guides(x = guide_axis(check.overlap = TRUE))

Building Tidy Tools Workshop

Mon, 14 Oct 2019 00:00:00 +0000

Welcome to the Tidyverse

Mon, 14 Oct 2019 00:00:00 +0000

Looking for an effective way to learn R? This one-day course will teach you a workflow for doing data science with the R language. It focuses on using R’s Tidyverse, which is a core set of R packages that are known for their impressive performance and ease of use. We will focus on doing data science, not programming. Your instructors will include:

Teon Brooks (Mozilla)
Carl Howe (RStudio)
Christina Koch (University of Wisconsin)

and you will learn to:

Visualize data with R’s ggplot2 package
Wrangle data with R’s dplyr package
Fit models with base R
Document your work reproducibly with R Markdown

Along the way, you will practice using R’s syntax, gaining comfort with R through many exercises and examples. Bring your laptop! And the best news is, a full day of learning is only $20.

(Please note that this workshop is being offered twice, once on Monday Oct 14 and again on Monday Oct 15.)

Remastering 'Master the Tidyverse'

Thu, 26 Sep 2019 00:00:00 +0000

I’ve been teaching people how to use the Tidyverse in a course called Master the Tidyverse, usually in one or two day long conference workshops. Each time I teach, I take notes during class and then polish my material afterwards, gradually honing a better and better set of class materials. The approach has worked well—I’ve gotten great reviews and have even won awards for my teaching. But my course was designed for R users who have never heard of the Tidyverse, and I can’t find them anymore. Now I’m updating the material for modern R beginners; and as I go, I’m making the material accessible for everyone to use. Looking for teaching material for an intro to R with the Tidyverse? Please help yourself!

The content

This github repository contains editable class materials for two separate one day workshops:

Welcome to the Tidyverse

A gentle introduction to R and its Tidyverse that focuses on learning to do Exploratory Data Analysis with the ggplot2, dplyr, broom, modelr, and rmarkdown packages. The course focuses on doing data science, not writing code; but by the end of the day, students will find that they have gained confidence running code with R.
Data Wrangling with the Tidyverse

An introduction to wrangling lists and tabular data in R with the tidyr, stringr, forcats, lubridate, and purrr packages. The course focuses on creating and using tidy tables and is designed to be a sequel to Welcome to the Tidyverse.

The workshops can be taught sequentially as a two day workshop, or spread out to make eight 90 minute classes (more-or-less).

Each course directory contains the editable Apple Keynote slides that I present during class, as well as the R Markdown files that I give to students. The R Markdown files contain the scaffolded exercises that students work through during class. All of the material is copyrighted under the Creative Commons BY-SA 4.0 copyright to make the material easy to reuse. I encourage you to reuse it and adapt it to your own courses as you like! Sorry, I do not work in PowerPoint and will not be providing PowerPoint versions of the slides. But see icloud.com for a free way to work with Keynote slides.

Both courses are ready to teach as is—I’ve taught them several times in this format with pleasing results, but this is my development repository, which means that you can expect slight changes to the courses from time to time. If you plan to use this material, I suggest that you fork a copy of the repository. This will give you your own stable material to work from.

Logistics

I’ve developed an efficient way to deliver the course as a workshop that I encourage you to try:

When scheduling a venue, ensure that the classroom has power strips for the students and wireless internet.
About a week ahead of the class, email the students the workshop set up instructions. These remind students to bring a laptop and a power cord, tell students how to download the free software that we will use in class, and ask students to create a free RStudio Cloud account. I do not tell students this unless they are having severe installation bugs, but we won’t use these local copies during the workshop. They are only backups in case the classroom wireless network fails. I generally do not have students download slides, etc. ahead of time.
Set up an rstudio.cloud project for the students to use on the day of class. Pre-install all of the packages that students will use and upload all of the course materials to the project directory. Be sure to open and knit one of the student exercises to prompt RStudio Cloud to also install all of the packages related to kniting R Markdown documents (if necessary).
Under the settings (gear) icon, click Access and then make the project viewable by everyone.
Copy the project URL and paste it over the analagous URL in the 01-Introduction slide decks.

On the day of the course:

Have students visit the URL when prompted by the slides.
Demonstrate what will happen when they do. It will take ~35 seconds for everyone’s project to open.
Have students immediately click “Save a Permanent Copy” at the top of their project and note the new URL that results. It is personalized to them.

At this point, each student will have an indentical instance of R and RStudio to run their exercises in. They will also have access to all of the course materials, which are included in the project. You can show students how to download these materials to their project locally (if they wish) when prompted by the slides. Students will have access to their permanent copies of the RStudio Cloud project, and the work they did therein, forever. Like most things RStudio Cloud no longer supports Internet Explorer.

Click the links below to see example RStudio Cloud projects for recent versions of each of the workshops:

Why not have students work locally?

I’ve adopted this workflow because it drastically reduces the amount of time I waste at the beginning of class fixing student’s installation bugs.

This may be controversial, but I’ve come to accept that I’m there to teach students a specific, high value skill. Not to be their tech support. I expect students to be able to handle R install issues on their own or with other resources—especially when the install issues are side effects of security settings or OS’s that students choose to use for their own reasons, as many of them are. Also, it is not like I’m asking them to install python (duck!).

A small number of students will not be able to log on to the internet without help, but I’ve found that I or a TA can help these students during one of the many student exercise sections without delaying the whole class.

Other tips

I usually play a looping slide show before class. It can let students know they are in the right place, remind them to connect to the wireless, or do some useful pre-teaching. It’s a bit like arriving early to the movies—but with fewer trivia questions.
Don’t neglect the beginning warm up activity where students talk to each other. A lively discussion at the start of the day will set the tone for the rest of the day. I notice that students are much more engaged, much more talkative, and ask more questions if I begin the day with some sort of free-for-all. In short, it makes class more fun to teach. If you find yourself starting the second day in the middle of an unfinished unit, be sure to insert a warm up meet and re-greet discussion at the start of class—or don’t and see what I’m talking about.
The timers end with a beep. If it is audible, it will help you regain student attention at the end of an exercise, especially if the exercise involves discussion.
Slides are cheap, so I use a lot of them. Don’t feel like you should dwell on each slide—there’s no time for that.
Use the Tower of Babel picture in the intro to point out that there are multiple ways to do many things in R — and that’s OK. The ones you are teaching happen to work well together as a system because they share a common syntax and intuition. Learning one will help students learn the rest. When a student inevitably asks why not do X another way, don’t argue. If the student feels confident doing X the other way, then he or she should; but for today the student should try the new way. He or she might like it, but it is OK if they do not.
Have fun!

Upcoming Instructor Training Events

Wed, 25 Sep 2019 00:00:00 +0000

Over two dozen people are now certified instructors and listed in our trainers’ directory, and more are in the pipeline. If you would like to join them, the first step is to take part in one of our upcoming training classes. We held a full class for people in Europe, the Middle East, and Africa (Sept 16-17), and another full class started today (Sept 25-26) for people in the Americas.

We still have some space in two upcoming classes:

December 9-10, 2019; a two-day online session, and
January 28, 2020; a one-day training workshop that will take place in person at rstudio::conf 2020.

These come on top of a dozen other offerings this year:

one at rstudio::conf 2019
three for people in Europe, the Middle East, and Africa
another four targeting the Americas
one for East Asia and Australia/New Zealand
one for our interns, and
two for specific customers’ teams.

The online course runs 4 hours each day (i.e., two back-to-back half-days); the materials are available online, and a book-length version is also available. After completing the course, participants must do one exam on teaching and one each on the technical topics (tidyverse and/or Shiny). If you would like to take part, please fill in this form to tell us about yourself or mail us if you have questions.

For more about RStudio’s instructor training program, please see:

RStudio Trainer Directory Launches (2019-07-18)
RStudio Instructor Training Updates (2019-05-21)
RStudio Instructor Training (2019-02-28)

Welcome!

Tue, 24 Sep 2019 00:00:00 +0000

Hello and welcome to the RStudio Education website! We hope to make education.rstudio.com a community resource for everyone who wants to learn or teach data science with R and RStudio.

RStudio’s mission is:

“To equip everyone, regardless of means, to participate in a global economy that rewards data literacy.”

Our education team supports this mission broadly by supporting people who want to learn R (or learn new things in R), and those who want to teach them. This site is designed for both.

What is on this site?

There are four main sections, which you’ll always be able to find in the upper navigation bar:

Blog. This is the 🆕 RStudio Education Team blog. Here, we’ll post announcements for events and other resources as they come up, as well as general R education-related content that we are excited about sharing.
Learn. Our advice for how learners can expand their knowledge about R and popular packages from RStudio, like tidyverse and Shiny. You’ll find three learning pathways to help you become productive in the minimum amount of time, based on your experience level: beginner, intermediate, and expert. The content and links on these pages may change as new resources become available and grab our attention. So rest assured — this page will be kept up-to-date, but that also means that our recommendations might change too.
Teach. Our team has trained a lot of learners to use R for data science. Drawing on that experience, we’ve broken down our collective advice and resources into three separable and learnable skills: how to teach (in general), how to create materials to teach R and data science, and how to set up effective learning environments for teaching R and data science.
Certify. In 2019, we launched an instructor training and certification program that aims to help people apply modern evidence-based teaching practices to teach data science using R and RStudio’s products, and to help people who need such training find the trainers they need. On this page, you can meet our Certified Trainers and find out more about the program and the application process.

So, welcome — we are happy you found us!

Figure 1: Art by Desirée De Leon

About the team

Who is the RStudio Education team? We are a small team of data scientists and professional educators. Our team is fully remote, spanning from Scotland to Oregon state. Meet each of us here.

Our team members attend and present at workshops around the world. You can find out who will be where by checking our upcoming events calendar. If you’ll be at the same event too, please come say hi and introduce yourself. Our team loves to talk about all things data science and education, and we’d love to meet you in person.

Figure 2: Art by Desirée De Leon

You can also follow our work at the RStudio Education GitHub Organization. All of our work there, including training materials and workshops, is openly-licensed and freely-available for reuse.

To find out more about the Education team’s goal of adding the next million new R users to our community, you can watch this rstudio::conf 2019 talk from RStudio’s Director of Education, Carl Howe.

About the artist

This site features beautiful original tiny drawings by Desirée De Leon, a former RStudio intern, neuroscientist, data scientist, and Atlanta-based illustrator. See more of Desirée’s tiny drawings on her instagram and twitter , and check out her website for more art and her data science blog.

Figure 3: Art by Desirée De Leon

And don’t miss Teacups, Giraffes, and Statistics created by Desirée and co-author Hasse Walum: a series of illustrated online modules to teach statistics and R coding. Set in a playful narrative about fictional miniature giraffes; created entirely in R Markdown.

About the art

The original art featured on this site is licensed under a Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International License.

You can find a human-readable summary of the license here.

About the site

This site is made with blogdown and the source code is available on GitHub. If you spot a typo or other error, please feel empowered to create an issue or a pull request.

Thank you

In addition to the beautiful art, this site was built with ✨ CSS magic ✨ contributed by Robby Shaver, Greg Swinehart, and Desirée De Leon. Special thanks also to all the members of the RStudio education team, including our summer interns, who have contributed all the content here so far, and much more to come.

Most importantly, huge thanks to the #rstats community for being welcoming, supportive, and inclusive to all learners. You all make our jobs as educators more rewarding.

rstudio::conf 2019

Tue, 15 Jan 2019 00:00:00 +0000

We had a great time at the 2019 rstudio::conf! Many attendees arrived early for 2 days of in-depth workshops, followed by two days of conference sessions. This year’s conference featured 15 workshops on tidyverse, Shiny, R Markdown, modeling and machine learning, deep learning, big data, and what they forgot to teach you about working with R. Some of the new workshops for this year touched on topics like putting Shiny applications into production at scale and R & Tensorflow. The conference also featured certification workshops on RStudio Professional Administrator and Train-the-trainer for tidyverse and Shiny.

Below is a list of all workshops we hosted, with links to materials. Even though the materials alone cannot replace the actual workshop experience, we hope that you’ll find them useful. RStudio regularly hosts workshops throughout the year so please subscribe to training updates. You can also find out more about each of the workshops at the conference repository.

Workshop	Instructor(s)
Introduction to Data Science in the Tidyverse	Amelia McNamara, Hadley Wickham
Building Tidy Tools	Charlotte Wickham, Hadley Wickham
What They Forgot to Teach You About R	Jenny Bryan, Jim Hester
Intro to Shiny and RMarkdown	Danny Kaplan
Advanced R Markdown	Alison Hill, Yihui Xie
Intermediate Shiny	Aimee Gott, Winston Chang
Using Shiny in Production	Kelly O’Briant, Sean Lopp
Applied Machine Learning	Max Kuhn, Alex Hayes, Davis Vaughan
Introduction to Deep Learning + Beyond the Basics	Sigrid Keydana, Kevin Kuo, Rick Scavetta
Big Data with R	Edgar Ruiz, James Blair
Train-the-Trainer Certification Workshop	Greg Wilson
Shiny Train-the-Trainer Certification Workshop	Mine Çetinkaya-Rundel
Tidyverse Train-the-Trainer Certification Workshop	Garrett Grolemund
RStudio Professional Administrator Certification Workshop	Andrie de Vries

Mon, 01 Jan 0001 00:00:00 +0000

Need help?

Mon, 01 Jan 0001 00:00:00 +0000

The RStudio Community is always ready to help with your questions. If your question is about some feature of R itself, please learn how to make a reproduceable example (called a reprex) and then share it with others.

Our latest video

Mon, 01 Jan 0001 00:00:00 +0000

Check out our latest education video below (concept is that this will always be some recent webinar or video).

Watch “What Every Data Scientist Should Know About Education” >

We all want to learn.

Mon, 01 Jan 0001 00:00:00 +0000

No one is born a data scientist. Every person who works with R today was once a complete beginner. No matter how much you know about the R ecosystem already, you’ll always have more to learn.

At RStudio, we know that everyone is at a different stage in learning the vast ecosystem of R, ranging from rank beginner to seasoned data scientists to professional educators. Choose a starting point below, or catch up with us on our blog.

RStudio Education

Beginners

Learn to teach

Intermediates

Materials for teaching

Courses

Workshops

Experts

Tools for teaching

Computing infrastructure

Packages

Reflecting on Mentorship Experience

Debugging and reproducibility

tf-idf and repositioning

What I learned

Online Educational Content Development: Pain Points & the Future

Background

CBDS: Goals

Pain Points

Pain Point #1 - Automated videos: ari

Pain Point #2 - Plain-text compilation

Pain Point #3 - Tracking all the things

Pain Point #4 - Delivering on non-negotiable #1

Pain Point #5 - Bug Fixes

Pain Point #6 - Assessment

The Dream

Distill it down

Introduction

My blogdown fail

Hello R Markdown and Netlify!

An R Markdown site

Distill it down

Learning R Coding by Building Something Cool

Newly certified instructors in December 2020

Building capacities to teach data science in Latin America

What?

Why?

How?

With whom?

Who?

What we learn?

Stay in touch

Supporting the Carpentries

Newly certified instructors in November 2020

#BlackInDataWeek 2020

Events

How to engage in #BlackInDataWeek

Day 1, Monday: #BlackInDataRollCall

Day 2, Tuesday: #BlackInDataJourney

Day 3, Wednesday: #BlackInDataSkills

Day 4, Thursday: #BlackInDataViz

Day 5, Friday: #BlackInDataJustice

Day 6, Saturday: #BlackInDataMentorship

Newly certified instructors in October 2020

Learner Personas

Anya Academic

Celine Certified

Exton Excel

Jacqui Ofalltrades

Katrin Keener

Larry Legacy

M’shelle Manager

Nang Newbie

Toshi Techsupport

Glosario Sprint

Writing Data Science in Education Using R in the Open

Introduction

Collaborate with people from different perspectives to help you identify your blind spots

Write and revise in the open to get feedback from readers

Use the structure provided by a writing project to encounter blind spots

Conclusion

Sample Shiny exam

Question 1

Question 2

Question 3

Question 4

Newly certified instructors in September 2020

How to deliver learnr tutorials in a package

tl;dr

How to make a package for a learnr tutorial

Pain Point #1 - Automated videos: `ari`

How to engage in `#BlackInDataWeek`

Day 1, Monday: `#BlackInDataRollCall`

Day 2, Tuesday: `#BlackInDataJourney`

Day 3, Wednesday: `#BlackInDataSkills`

Day 4, Thursday: `#BlackInDataViz`

Day 5, Friday: `#BlackInDataJustice`

Day 6, Saturday: `#BlackInDataMentorship`