Ari: The Automated R Instructor
CC ONTRIBUTED RESEARCH ARTICLE Ari: The Automated R Instructor by Sean Kross, Jeffrey T. Leek, John Muschelli
Abstract
We present the ari package for automatically generating technology-focused educationalvideos. The goal of the package is to create reproducible videos, with the ability to change andupdate video content seamlessly. We present several examples of generating videos including using RMarkdown slide decks, PowerPoint slides, or simple images as source material. We also discuss how ari can help instructors reach new audiences through programmatically translating materials intoother languages.
Introduction
Videos are a crucial way people learn and they are pervasive in online education platforms (Hsin andCigas, 2013; Hartsell and Yuen, 2006). Producing educational videos with a lecturer speaking overslides takes time, energy, and usually video editing skills. Maintaining the accuracy and relevanceof lecture videos focused on technical subjects like computer programming or data science can oftenrequire remaking an entire video, requiring extensive editing and splicing of new segments. Wepresent ari , the A utomated R I nstructor as a tool to address these issues by creating reproduciblepresentations and videos that can be automatically generated from plain text files or similar artifacts.By using ari , we provide a tool for users to rapidly create and update video content.In its simplest form a lecture video is comprised of visual content (e.g. slides and figures) anda spoken explanation of the visual content. Instead of a human lecturer, the ari package uses atext-to-speech system to synthesize spoken audio for a lecture. Modern text-to-speech systems thattake advantage of recent advancements in artificial intelligence research are available from Google,Microsoft, and Amazon. Many of these synthesizers make use of deep learning methods, such asWaveNet (Van Den Oord et al., 2016) and have interfaces in R (Edmondson, 2019; Muschelli, 2019a;Leeper, 2017). Currently in ari , synthesis of the the audio can be rendered using any of these servicesthrough the text2speech package (Muschelli, 2019b). The default is Amazon Polly, which has text-to-speech voice generation in over twenty one languages, implemented in the aws.polly package (Leeper,2017). In addition to multiple languages, the speech generation services provide voices with severalpitches representing different genders within the same language. We present the ari package withreproducible use case examples and the video outputs with different voices in multiple languages.The ari package relies on the tuneR package for splitting and combining audio files appropriatelyso that lecture narration is synced with each slide (Ligges et al., 2018). Once the audio is generated,it is synced with images to make a lecture video. Multiple open source tools for video editing andsplicing exist; ari takes advantage of the FFmpeg ( ) software, a command-lineinterface to the libav library. These powerful tools have been thoroughly tested with a developmenthistory spanning almost 20 years. ari has been built with presets for FFmpeg which allow output videosto be compatible with multiple platforms, including the YouTube and Coursera players. These presetsinclude specifying the bitrate, audio and video codecs, and the output video format. The numerousadditional video specifications for customization can be applied to command-line arguments FFmpegthrough ari .We have developed a workflow with ari as the centerpiece for automatically generating educationalvideos. The narration script for lecture videos is stored in a plain text format, so that it can besynthesized into audio files via text-to-speech services. By storing lecture narration in plain text itcan be updated, tracked, and collaboratively or automatically updated with version control softwarelike Git and GitHub. If the figures in the lecture slides are created in a reproducible framework, suchas generated using R code, the entire video can be reproducibly created and automatically updated.Thus, ari is the Automated R Instructor. We will provide examples of creating videos based on thefollowing sets of source files: a slide deck built with R Markdown, a set of images and a script, or apresentation made with Google Slides or PowerPoint. The overview of the processes demonstratedin this paper are seen in Figure 1. We will also demonstrate the ariExtra package, which containsfunctions that connect ari to applications outside of the R ecosystem (Muschelli, 2020).
Configuring Ari
Ari relies on several software packages including FFmpeg, one of the most popular libraries forprocessing audio, video, and image files. Configuring FFmpeg can be challenging, therefore wehave provided a Docker image so that Ari users can start producing videos quickly. A guide togetting started with Docker and using our Docker image is included with Ari as a vignette which canbe accessed via vignette("Simple-Ari-Configuration-with-Docker") . Users who are interested in
The R Journal Vol. XX/YY, AAAA ISSN 2073-4859
ONTRIBUTED RESEARCH ARTICLE PNGs + ScriptRmd+ Script
PowerPoint Speaker Notes
Ari
Video
YouTubeCoursera
Figure 1:
Ari is designed to fit into several existing workflows for creating lectures and presentations.Videos can be created with Ari from a series of images and a narrative script, from an R Markdowndocument, or from a PowerPoint presentation with speaker notes. Ari is pre-configured so that videosare ready to be uploaded to popular platforms like YouTube or Coursera.configuring Ari on their own may find the Dockerfile associated with the guide useful, and it is beingactively developed at https://github.com/seankross/ari-on-docker . Making videos with ari : ari_stitch The main workhorse of ari is the ari_stitch function. This function requires an ordered set of imagesand an ordered set of audio objects, either paths to wav files or tuneR
Wave objects, that correspond toeach image. The ari_stitch function sequentially “stitches” each image in the video for the durationof its corresponding audio object using FFmpeg. FFmpeg must be installed so that ari can combine theaudio and images, much like packages such as animation which have a similar requirement (Xie, 2013;Xie et al., 2018b). Moreover, on shinyapps.io, a dependency on the animation package will trigger aninstallation of FFmpeg so ari can be used on shinyapps.io. In the example below, 2 images (packagedwith ari ) are overlaid with white noise for demonstration. This example also allows users to check ifthe output of FFmpeg works with a desired video player. library(tuneR)library(ari)result <- ari_stitch(ari_example(c("mab1.png", "mab2.png")),list(noise(), noise()),output = "noise.mp4")isTRUE(result)[1] TRUE
The output indicates whether the video was successfully created, but additional attributes areavailable, such as the path of the output file: attributes(result)$outfile[1] "noise.mp4"
The video for this output can be seen at https://youtu.be/3kgaYf-EV90 . Synthesizer authentication
The above example uses tuneR::noise() to generate audio and to show that any audio object can beused with ari . In most cases however, ari is most useful when combined with synthesizing audio usinga text-to-speech system. Though one can generate the spoken audio in many ways, such as fitting a
The R Journal Vol. XX/YY, AAAA ISSN 2073-4859
ONTRIBUTED RESEARCH ARTICLE custom deep learning model, we will focus on using the aforementioned services (e.g. Amazon Polly)as they have straightforward public web APIs. One obstacle in using such services is that users mustgo through steps to provide authentication, whereas most of these APIs and the associated R packagesdo not allow for interactive authentication such as OAuth.The text2speech package provides a unified interface to these 3 text-to-speech services, and wewill focus on Amazon Polly and its authentication requirements. Polly is authenticated using the aws.signature package (Leeper, 2019). The aws.signature documentation provides options and stepsto create the relevant credentials; we have also provided an additional tutorial. Essentially, the usermust sign up for the service and retrieve public and private API keys and put them into their R profileor other areas accessible to R. Running text2speech::tts_auth(service = "amazon") will indicate ifauthentication was successful (if using a different service, change the service argument). NB: TheAPIs are generally paid services, but many have free tiers or limits, such as Amazon Polly’s free tierfor the first year ( https://aws.amazon.com/polly/pricing/ ). Creating speech from text: ari_spin
After Polly has been authenticated, videos can be created using the ari_spin function with an orderedset of images and a corresponding ordered set of text strings. This text is the “script” that is spokenover the images to create the output video. The number of elements in the text needs to be equalto the number of images. Let us take a part of Mercutio’s speech from Shakespeare’s Romeo andJuliet (Shakespeare, 2003) and overlay it on two images from the Wikipedia page about Mercutio( https://en.wikipedia.org/wiki/Mercutio ): speech <- c("I will now perform part of Mercutio s speech from Shakespeare s Romeo and Juliet.","O, then, I see Queen Mab hath been with you.She is the fairies midwife, and she comesIn shape no bigger than an agate-stoneOn the fore-finger of an alderman,Drawn with a team of little atomiesAthwart men s noses as they lies asleep;")mercutio_file <- "death_of_mercutio.png"mercutio_file2 <- "mercutio_actor.png"shakespeare_result <- ari_spin(c(mercutio_file, mercutio_file2),speech,output = "romeo.mp4", voice = "Joanna")isTRUE(shakespeare_result)[1] TRUE The speech output can be seen at https://youtu.be/SFhvM9gI0kE .We chose the voice “Joanna” which is designated as a female sounding US-English speaker for thescript. Each voice is language-dependent; we can see the available voices for English for AmazonPolly at https://docs.aws.amazon.com/polly/latest/dg/SupportedLanguage.html .Though the voice generation is relatively clear, we chose a Shakespearean example to demonstratethe influence and production value of the variety of dialects available from these text-to-speechservices. Compare the video of “Joanna” to the same video featuring “Brian” who “speaks” with aBritish English dialect: gb_result <- ari_spin(c(mercutio_file, mercutio_file2),speech,output = "romeo_gb.mp4", voice = "Brian")isTRUE(gb_result)[1] TRUE
The resulting video can be seen at https://youtu.be/fSS0JSb4VxM .The output video format is MP4 by default, but several formats can be specified via specifyingthe appropriate “muxer” for FFmpeg (see the function ffmpeg_muxers ). Supported codecs can be
The R Journal Vol. XX/YY, AAAA ISSN 2073-4859
ONTRIBUTED RESEARCH ARTICLE founded using the functions ffmpeg_audio_codecs and ffmpeg_video_codecs . Additional optionscan be passed to FFmpeg from ari_stitch and ari_spin to customize the video to the necessaryspecifications.We now discuss the number of image and script inputs that ari is designed to work with, includingtext files and a series of PNG images, presentations made with Google Slides or PowerPoint withthe script written in the speaker notes section, or an HTML slide presentation created from an RMarkdown file, where the script is written in the HTML comments. Creating videos from R Markdown documents
Many R users have experience creating slide decks with R Markdown, for example using the rmark-down or xaringan packages (Allaire et al., 2019; Xie et al., 2018a; Xie, 2018). In ari , the HTML slidesare rendered using webshot (Chang, 2018) and the script is located in HTML comments (i.e. between ). For example, in the file ari_comments.Rmd included in ari , which is an ioslides typeof R Markdown slide deck, we have the last slide: x <- readLines(ari_example("ari_comments.Rmd"))tail(x[x != ""], 4)[1] " The first words spoken on this example slide are "Thank you" . This setup allows for one plain text,version-controllable, integrated document that can reproducibly generate a video. We believe thesefeatures allow creators to make agile videos, that can easily be updated with new material or changedwhen errors or typos are found. Moreover, this framework provides an opportunity to translate videosinto multiple languages, a feature that we will discuss in the future directions.Using ari_narrate , users can create videos from R Markdown documents that create slide decks.An R Markdown file can be passed in, and the output will be created using the render function from rmarkdown (Allaire et al., 2019). If the slides are already rendered, the user can pass these slides andthe original document, where the script is extracted. Passing rendered slides allows with the optionfor a custom rendering script. Here we create the video for ari_comments.Rmd , where the slides arerendered inside ari_narrate : The output video is located at https://youtu.be/rv9fg_qsqc0 . In our experience with severalusers we have found that some HTML slides take more or less time to render when using webshot ;for example they may be tinted with gray because they are in the middle of a slide transition whenthe image of the slide is captured. Therefore we provide the delay argument in ari_narrate which ispassed to webshot . This can resolve these issues by allowing more time for the page to fully render,however this means it may take more time to create each video. We also provide the argument capture_method to allow for finely-tuned control of webshot . When capture_method = "vectorized" , webshot is run on the entire slide deck in a faster process, however we have experienced slide render-ing issues with this setting depending on the configuration of an individual’s computer. Howeverwhen capture_method = "iterative" , each slide is rendered individually in webshot , which solvesmany rendering issues, however it causes videos to be rendered more slowly.In the future, other HTML headless rendering engines ( webshot uses PhantomJS) may be used if theyachieve better performance, but we have found webshot to work well in most of our applications.With respect to accessibility, ari encourages video creators to type out a script by design. Thisprovides an effortless source of subtitles, rather than relying on other services such as YouTube toprovide speech-to-text subtitles. When using ari_spin , if the subtitles argument is TRUE , then anSRT file for subtitles will be created with the video.One issue with synthesis of technical information is that changes to the script are required forAmazon Polly or other services to provide a correct pronunciation. For example, if you want theservice to say “RStudio” or “ggplot2”, the phrases “R Studio” or “g g plot 2” must be written exactlythat way in the script. These phrases will then appear in an SRT subtitle file, which may be confusingto a viewer. Thus, some post-processing of the SRT file may be needed.
The R Journal Vol. XX/YY, AAAA ISSN 2073-4859
ONTRIBUTED RESEARCH ARTICLE Creating videos from other documents
We created the ariExtra ( https://github.com/muschellij2/ariExtra ) package to augment the corefunctionality of ari by extending it to software applications outside of the R ecosystem. Theseextensions require many additional dependencies, and considering the significant amount of setupalready required for ari , we believed that this additional functionality should be in a separate package.To create a video from a presentation made with Google Slides or PowerPoint, the slides shouldbe converted to a set of images. We recommend using the PNG format for these images. To getthe script for the video, we suggest putting the script for each slide in the speaker notes section ofthat slide. Several of the following features for video generation are in our package ariExtra . Thespeaker notes of slides can be extracted using rgoogleslides (Noorazman, 2018) for Google Slides viathe API or using readOffice / officer (Gohel, 2019; Ewing, 2017) to read from PowerPoint documents.Google Slides can be downloaded as a PDF and converted to PNGs using the pdftools package (Ooms,2019). The ariExtra package also has a pptx_notes function for reading PowerPoint notes. ConvertingPowerPoint files to PDF can be done using LibreOffice and the docxtractr package (Rudis and Muir,2019) which contains the necessary wrapper functions.To demonstrate this, we use an example PowerPoint is located on Figshare ( https://figshare.com/articles/Example_PowerPoint_for_ari/8865230 ). We can convert the PowerPoint to a PDF,then to a set of PNG images, then we extract the speaker notes. pptx <- "ari.pptx"download.file(paste0("https://s3-eu-west-1.amazonaws.com/","pfigshare-u-files/16252631/ari.pptx"),destfile = pptx)pdf <- docxtractr::convert_to_pdf(pptx) The ariExtra package also can combine these processes and take multiple input types (GoogleSlides, PDFs, PPTX) and harmonize the output. The pptx_to_ari function combines the above steps: doc <- ariExtra::pptx_to_ari(pptx)Converting page 1 to /var/folders/1s/wrtqcpxn685_zk570bnx9_rr0000gr/T//Rtmpo6aD9u/filede6236136195.png... done!Converting page 2 to /var/folders/1s/wrtqcpxn685_zk570bnx9_rr0000gr/T//Rtmpo6aD9u/filede62326b98ef.png... done!doc[c("images", "script")]$images[1] "/private/var/folders/1s/wrtqcpxn685_zk570bnx9_rr0000gr/T/Rtmpo6aD9u/filede6236058cc5_files/slide_1.png"[2] "/private/var/folders/1s/wrtqcpxn685_zk570bnx9_rr0000gr/T/Rtmpo6aD9u/filede6236058cc5_files/slide_2.png"$script[1] "Sometimes it’s hard for an instructor to take the time to record their lectures.For example, I’m in a coffee shop and it may be loud."[2] "Here is an example of a plot with really small axes. We plot the x versus they-variables and a smoother between them."
This output can then be passed to ari_spin .We will now demonstrate rendering the video with the “Kimberly” voice while using the divisible_height argument to forcibly scale the height of the images to be divisible by 2. This is required by the x264 (default) codec which we have specified as a preset:
The R Journal Vol. XX/YY, AAAA ISSN 2073-4859
ONTRIBUTED RESEARCH ARTICLE pptx_result <- ari_spin(pngs, notes,output = "pptx.mp4", voice = "Kimberly",divisible_height = TRUE, subtitles = TRUE)isTRUE(pptx_result) You can see the output at https://youtu.be/TBb3Am6xsQw . Here we can see the first few lines ofthe subtitle file: [1] "1"[2] "00:00:00,000 --> 00:00:02,025"[3] "Sometimes it’s hard for an instructor to"[4] "2"[5] "00:00:02,025 --> 00:00:04,005"[6] "take the time to record their lectures."
For Google Slides, the slide deck can be downloaded as a PowerPoint and the previous steps canbe used, however it can also be downloaded directly as a PDF. We will use the same presentation, butuploaded to Google Slides. The ariExtra package has the function gs_to_ari to wrap this functionality(as long as link sharing is turned on), where we can pass the Google identifier: gs_doc <- ariExtra::gs_to_ari("14gd2DiOCVKRNpFfLrryrGG7D3S8pu9aZ")Converting page 1 to/var/folders/zw/l4fv__6n4tnbk3xb31dnbt5m0000gn/T//RtmpphWBAj/filebd69651ed561.png...done!Converting page 2 to/var/folders/zw/l4fv__6n4tnbk3xb31dnbt5m0000gn/T//RtmpphWBAj/filebd694b4b0724.png...done!
Note, as Google provides a PDF version of the slides, this obviates the LibreOffice dependency.Alternatively, the notes can be extracted using rgoogleslides via the Google Slides API, howeverthis requires authentication so we will omit it here. Thus, we should be able to create videos using RMarkdown, Google Slides, or PowerPoint presentations in an automatic fashion.
Summary
The ari package combines multiple open-source tools and APIs to create reproducible workflowsfor creating videos. These videos can be created using R Markdown documents, Google Slides,PowerPoint presentations, or simply a series of images. The audio overlaid on the images can beseparate or contained within the storage of the images. These workflows can then be reproduced in thefuture and easily updated. As the current voice synthesis options are somewhat limited in the tenacityand inflection given, we believe that educational and informational videos are the most applicablearea.
Future directions
The ari package is already being used to build data science curricula (Kross and Guo, 2019) and welook forward to collaborating with video creators to augment ari according to their changing needs. Inthe following section we outline possible directions for the future of the project.Since ari is designed for teaching technical content, we plan to provide better support for thepronunciation of technical terms like the names of popular software tools. These names are usually notpronounced correctly by text-to-speech services because they are not words contained in the trainingdata used in the deep learning models that these services are built upon. To address this concern weplan to compile a dictionary of commonly used technical terms and the phonetic phrasing and spellingof these terms that are required to achieve the correct pronunciation from text-to-speech services.In addition to still images and synthesized voices, we would like to develop new technologiesfor incorporating other automatically generated videos into lectures generated by ari . As computerprogramming, statistics, and data science instructors we often rely on live coding (Chen and Guo,2019) to demonstrate software tools to our students. Live coding videos suffer from many of the sameproblems as other kinds of technical videos as we addressed in the introduction. Therefore we plan tobuild a system for automating the creation of live coding videos. These videos would also be createdusing plain text documents like R Markdown. They would integrate synthesized narration with codechunks that would be displayed and executed according to specialized commands that would specify
The R Journal Vol. XX/YY, AAAA ISSN 2073-4859
ONTRIBUTED RESEARCH ARTICLE when code should be executed in an IDE like RStudio. These commands could also control whichpanes and tabs of the IDE are visible or emphasized.As programmatic video creation software improves, we plan to extend ari so it can expandits compatibility with different technologies. For example we believe the heavy reliance on anFFmpeg installation can be mitigated in the future with advances in the av package. Though the av package has powerful functionality and is currently porting more from libav and therefore FFmpeg,it currently does not have the capabilities required for ari . Although third party installation from https://ffmpeg.org/ can be burdensome to a user, package managers such as brew for OSX and choco for Windows provide an easier installation and configuration experience.Although we rely on Amazon Polly for voice synthesis, other packages provide voice synthesis,such as mscstts for Microsoft and googleLanguageR for Google. We created the text2speech packageto harmonize these synthesis options for ari . Thus, switching from one voice generation service toanother simply involves switching the service and voice arguments in ari , assuming the service isproperly authenticated. This ease of switching allows researchers to compare and test which voicesand services are most effective at delivering content.We see significant potential in how ari could expand global learning opportunities. Video narrationscripts can be automatically translated into other languages with services like the Google TranslationAPI, where googleLanguageR provides an interface. Amazon Polly can speak languages otherthan English, meaning that one can write a lecture once and generate lecture videos in multiplelanguages. Therefore this workflow can greatly expand the potential audience for educational videoswith relatively little additional effort from lecture creators. We plan to flesh out these workflows sothat video creators can manage videos in multiple languages. We hope to add functionality so thatcommunities of learners with language expertise can easily suggest modifications to automaticallytranslated videos, and tooling so suggestions can be incorporated quickly. Bibliography
J. Allaire, Y. Xie, J. McPherson, J. Luraschi, K. Ushey, A. Atkins, H. Wickham, J. Cheng, W. Chang, andR. Iannone. rmarkdown: Dynamic Documents for R , 2019. URL https://rmarkdown.rstudio.com . Rpackage version 1.12. [p4]W. Chang. webshot: Take Screenshots of Web Pages , 2018. URL https://CRAN.R-project.org/package=webshot . R package version 0.5.1. [p4]C. Chen and P. J. Guo. Improv: Teaching programming at scale via live coding. In
Proceedings of theSixth Annual ACM Conference on Learning at Scale , L@S ’19, New York, NY, USA, 2019. ACM. doi:10.1145/3330430.3333627. URL https://doi.org/10.1145/3330430.3333627 . [p6]M. Edmondson. googleLanguageR: Call Google’s ’Natural Language’API, ’Cloud Translation’ API, ’Cloud Speech’ API and ’Cloud Text-to-Speech’ API , 2019. http://code.markedmondson.me/googleLanguageR/,https://github.com/ropensci/googleLanguageR. [p1]M. Ewing. readOffice: Read Text Out of Modern Office Files , 2017. URL https://CRAN.R-project.org/package=readOffice . R package version 0.2.2. [p5]D. Gohel. officer: Manipulation of Microsoft Word and PowerPoint Documents , 2019. URL https://CRAN.R-project.org/package=officer . R package version 0.3.5. [p5]T. Hartsell and S. C.-Y. Yuen. Video streaming in online learning.
AACE Journal , 14(1):31–43, 2006. [p1]W.-J. Hsin and J. Cigas. Short videos improve student learning in online education.
Journal of ComputingSciences in Colleges , 28(5):253–259, 2013. [p1]S. Kross and P. J. Guo. End-user programmers repurposing end-user programming tools to fosterdiversity in adult end-user programming education. In
Proceedings of VL/HCC 2019: IEEE Symposiumon Visual Languages and Human-Centric Computing , VL/HCC ’19, 2019. ISBN 978-1-4503-5886-6. [p6]T. J. Leeper. aws.polly: Client for AWS Polly , 2017. R package version 0.1.5. [p1]T. J. Leeper. aws.signature: Amazon Web Services Request Signatures , 2019. R package version 0.5.1. [p3]U. Ligges, S. Krey, O. Mersmann, and S. Schnackenberg. tuneR: Analysis of Music and Speech , 2018. URL https://CRAN.R-project.org/package=tuneR . [p1]
The R Journal Vol. XX/YY, AAAA ISSN 2073-4859
ONTRIBUTED RESEARCH ARTICLE J. Muschelli. mscstts: R Client for the Microsoft Cognitive Services ’Text-to-Speech’ REST API , 2019a. URL https://CRAN.R-project.org/package=mscstts . R package version 0.5.1. [p1]J. Muschelli. text2speech: Text to Speech , 2019b. URL https://github.com/muschellij2/text2speech .R package version 0.2.4. [p1]J. Muschelli. ariExtra: Tools for Creating Automated Courses , 2020. URL https://CRAN.R-project.org/package=ariExtra . R package version 0.2.7. [p1]H. B. Noorazman. rgoogleslides: R Interface to Google Slides , 2018. URL https://CRAN.R-project.org/package=rgoogleslides . R package version 0.3.1. [p5]J. Ooms. pdftools: Text Extraction, Rendering and Converting of PDF Documents , 2019. URL https://CRAN.R-project.org/package=pdftools . R package version 2.2. [p5]B. Rudis and C. Muir. docxtractr: Extract Data Tables and Comments from Microsoft Word Documents , 2019.URL http://gitlab.com/hrbrmstr/docxtractr . R package version 0.6.2. [p5]W. Shakespeare.
Romeo and Juliet . Cambridge University Press, 2003. [p3]A. Van Den Oord, S. Dieleman, H. Zen, K. Simonyan, O. Vinyals, A. Graves, N. Kalchbrenner, A. W.Senior, and K. Kavukcuoglu. WaveNet: A generative model for raw audio.
SSW , 125, 2016. [p1]Y. Xie. animation: An R package for creating animations and demonstrating statistical methods.
Journalof Statistical Software , 53(1):1–27, 2013. URL . [p2]Y. Xie. xaringan: Presentation Ninja , 2018. URL https://CRAN.R-project.org/package=xaringan . Rpackage version 0.8. [p4]Y. Xie, J. Allaire, and G. Grolemund.
R Markdown: The Definitive Guide . Chapman and Hall/CRC, BocaRaton, Florida, 2018a. URL https://bookdown.org/yihui/rmarkdown . ISBN 9781138359338. [p4]Y. Xie, C. Mueller, L. Yu, and W. Zhu. animation: A Gallery of Animations in Statistics and Utilities toCreate Animations , 2018b. URL https://yihui.name/animation . R package version 2.6. [p2]
Sean KrossDepartment of Cognitive Science, University of California, San Diego9500 Gilman Dr.La Jolla, CA 92093 [email protected]
Jeffrey T. LeekDepartment of Biostatistics, Johns Hopkins Bloomberg School of Public Health615 N Wolfe StreetBaltimore, MD 21231 [email protected]
John MuschelliDepartment of Biostatistics, Johns Hopkins Bloomberg School of Public Health615 N Wolfe StreetBaltimore, MD 21231 [email protected]@jhu.edu