What makes a great Shiny app? Anything that helps your users explore and find answers from data. And it helps when your apps is beautiful and fast. It is now easier than ever for Shiny developers to create these beautiful, dynamic, quick-reacting, multipage shiny apps. In this episode of the Shiny Developer Serie -- the first of two parts -- Eric Nantz hosts Herman Sontrop and Kenton Russell as they introduce the tools behind their Movie Vue R Shiny application. They submitted this application to the 2021 Shiny Contest and have shared the code and documentation with the Shiny developer community. Part 1 is a high-level tour of what is inside the Movie Vue R Shiny application and how the Vue javascript framework is used to offer R and Shiny components really nice user interface elements.Resources mentioned in the episodeMovie Vue R Shiny App: friss.shinyapps.io/shiny-vue-rContest Submission Post on RStudio CommunityApp GitHub repository: github.com/FrissAnalytics/shiny-vue-rDiscussion slides available at this linkVue.js - Progressive JavaScript framework: vuejs.orgVuetify - Material design framework for Vue: vuetifyjs.comHTML templates article: shiny.rstudio.com/articles/templates.htmlMaterial design icons: materialdesignicons.comhttp-vue-loader - load .vue files from your HTML/JS: github.com/FranckFreiburger/http-vue-loaderVuex getting started guide: vuex.vuejs.org/guideVue Router - The official router for Vue.js: router.vuejs.orgUI component for Globe Data Visualization using ThreeJS/WebGL: globe.glLodash - A modern JavaScript utility library delivering modularity, performance & extras: lodash.comd3.js - Data-Driven Documents: d3js,orgMitt - Tiny 200b functional event emitter / pubsub: github.com/developit/mittOverlay Scrollbars - A javascript scrollbar plugin which hides native scrollbars, provides custom styleable overlay scrollbars and keeps the native functionality and feeling: kingsora.github.io/OverlayScrollbarsKent's listviewer HTML widget for viewing lists: cran.r-project.org/package=listviewerplumber - Turn your R code into a web API: www.rplumber.ioEpisode Timestamps00:00:00 Episode Introduction 00:01:00 Introduction to Herman Sontrop 00:06:10 Introduction to Kenton Russell 00:10:00 High-level walkthrough of Movie Vue R 00:19:25 Diving into the code that drives Movie Vue R 00:22:35 Overview and motivation behind Vue 00:38:30 Vue instance example 00:40:00 Vue reactivty examples 00:46:10 Vue.js components are like Shiny modules 00:49:50 Single file components 00:54:16 Breaking down a Vue component into useful parts; props, data, methods, computed, and watch 00:57:20 Vuetify, tap into many pre-built components, styles, and more 01:10:00 Covid Globe Example in Shiny app 01:12:40 Rendering a ggplot 01:15:15 Summarizing parts of the Movie Vue R app 01:19:10 A look at template.html. A detailed walk through the organization of the app's HTML and files 01:26:30 Where R and Shiny are added to a Vue app. And how your app can send messages back to Shiny and R 01:31:20 Loading images and ggplots 01:38:00 Episode wrapup 

In this special live recording of the Shiny Developer Series held at the first-ever Appsilon Shiny Conferenbce, host Eric Nantz welcomed back an all-star panel of Dean Attali, Tanya Cashorali, Pedro Silva, and Mike Thomas to share their unique perspectives on the life of a Shiny application developer in the world of consulting. The panel discussed topics such as their favorite techniques used across production apps, advice for becoming a Shiny consultant, and ways Shiny can integrate seamlessly with other tech stacks.Resources mentioned in the episodeShiny Modules: shiny.rstudio.com/articles/modules.htmlOverview of the {sass} package: rstudio.github.io/sass/articles/sass.html{waiter} Loading screens for Shiny: github.com/JohnCoene/waiterTooltips with {shinyBS}: ebailey78.github.io/shinyBS/docs/Tooltips_and_Popovers.htmlInteractive web-based data visualization with R, {plotly}, and {shiny}: plotly-r.com{shinyjs} Easily improve the user experience of your Shiny apps in seconds: deanattali.com/shinyjs/{reactable} Interactive data tables for R: glin.github.io/reactableClean Code: A Handbook of Agile Software CraftsmanshipEpisode Timestamps00:00:00 Panelist introductions 00:03:20 What are key skills to build production-quality Shiny apps 00:10:05 Creating an app that doesn't feel like a standard Shiny app 00:17:15 Getting started with consulting/freelancing Shiny development 00:27:00 Advice for teams to increase Shiny dev skills 00:36:10 Tools/packages used every day 00:45:15 App development workflows 00:49:30 Underrated techniques 00:58:20 Episode wrapup shinydevseries::session_info()📽 Find previous interviews at https://shinydevseries.com📋 Feedback is more than welcome! Please send your comments or suggestions on our contact form at shinydevseries.com/contactIf you enjoyed this video or got value from it, then consider dropping something in the tip jar. Any money raised will be used to improve the channel and invest in additional equipment and resources to make the content even better!💰 https://bit.ly/sdstip📨 Help shape the future direction of the Shiny Developer Series live streams by completing this very short surveyMedia production for the Shiny Developer Series is made possible by these outstanding projects and platforms:OBS Studio: https://obsproject.com/OBS Fully Loaded install script by Martin Wimpress: https://github.com/wimpysworld/obs-fully-loadedVDO Ninja: https://vdo.ninjaStreamElements: https://streamelements.comShotCut: https://shotcut.org/Pop@_OS by System76: https://pop.system76.com/Ubuntu: https://ubuntu.com/

The Shiny Developer Series continues our spotlight on the COVID-19 Test Spotter application created by renowned data scientist and entrepreneur Mike Thomas! In this episode we learn how Mike implemented robust database techniques and logic to manage user-supplied data, navigating the use of multiple mapping APIs, and achieving a practical development-to-production strategy for releasing the application to the public. Plus we have a great discussion on what production means in the space of Shiny development, and much more. Resources mentioned in the episodeCOVID-19 At-Home Test Spotter (App) - ketchbrookanalytics.shinyapps.io/covid_test_spotterCOVID-19 At-Home Test Spotter (Code) - github.com/ketchbrookanalytics/covid_test_spotterApp blog post - www.ketchbrookanalytics.com/post/ketchbrook-analytics-launches-website-to-help-connecticut-residents-find-covid-19-test-kits{googleWay} Shiny vignette - symbolixau.github.io/googleway/articles/googleway-vignette.html#shiny{mongolite} user manual - jeroen.github.io/mongolite{reactable} Interactive data tables for R - glin.github.io/reactableEpisode Timestamps00:00:00 Episode Introduction 00:00:46 CRUD workflow and flowchart, with MongoDB database updates 00:09:41 Diving into the Google Maps and Places API 00:15:55 Geographic fencing, and dealing with unexpected user behavior. 00:22:35 Deploying with a dev and production branch. 00:28:15 Future plans for the app 00:30:50 Advice for building Shiny apps in production 00:31:20 Production apps is all about reproducibility: OS, dependencies, and the code. 00:33:15 Pay attention to warning messages in your console. 00:34:22 Modularization and Golem 00:38:08 You can have too much reactivity, such as overextending uiOutput() / renderUI() 00:40:10 Episode wrapup shinydevseries::session_info()📽 Find previous interviews at https://shinydevseries.com📋 Feedback is more than welcome! Please send your comments or suggestions on our contact form at shinydevseries.com/contactIf you enjoyed this video or got value from it, then consider dropping something in the tip jar. Any money raised will be used to improve the channel and invest in additional equipment and resources to make the content even better!💰 https://bit.ly/sdstip📨 Help shape the future direction of the Shiny Developer Series live streams by completing this very short surveyMedia production for the Shiny Developer Series is made possible by these outstanding projects and platforms:OBS Studio: https://obsproject.com/OBS Fully Loaded install script by Martin Wimpress: https://github.com/wimpysworld/obs-fully-loadedVDO Ninja: https://vdo.ninjaStreamElements: https://streamelements.comShotCut: https://shotcut.org/Pop@_OS by System76: https://pop.system76.com/Ubuntu: https://ubuntu.com/

After a terrific showing of the eye-opening Movie Vue R in episode 26, Kent Russell and Herman Sontrop reveal the fundamental cast of R packages and workflows bringing the app to life. Kent leads us through live demonstrations of his R packages binding to Vue.js, illustrating the seamless way you can link existing HTML widgets to the Vue framework, as well as the mechanics of incorporating Shiny into existing Vue templates to unlock immense potential. Later in the episode we learn revolutionary techniques for adapting the popular crosstalk package to Vue apps, as well as a unique way of tracking application state. Each of these demonstrations reveal many nuggets of development wisdom straight from a true pioneer in bridging the amazing worlds of JavaScript and R together!Resources mentioned in the episodeKent's packages and examples used in the live coding demonstrations: vue.js for R - github.com/vue-r/vueRvue-cli-r - github.com/timelyportfolio/vue-cli-rvite vue3 and Shiny - github.com/timelyportfolio/vite-vue-rvaltio vanilla with utils as standalone using browserify - github.com/timelyportfolio/valtio_standaloneKent's listviewer HTML widget for viewing lists: cran.r-project.org/package=listviewerLinking vue to crosstalk - github.com/vue-r/vueR/issues/12Episode Timestamps00:00:00 Episode Introduction 00:01:00 The vueR package and introductory examples 00:06:55 Live coding example with vuetify 00:13:55 vueR example, adding a calendar date selector and other mint-ui elements to your Shiny app 00:21:00 htmlwidget leaflet map example 00:24:10 Example of a sunburst plot 00:33:15 Example of a checkbox selector for hierarchical element trees 00:36:00 JavaScript build steps with Vue CLI 00:59:30 vite vue 3 build example 01:09:30 A call to the community to help with vueR development goals 01:10:30 Integrating crosstalk 01:14:30 Using vuex as a store of state. Time travel through the state of your Shiny app 01:20:24 Example of valtio 01:27:08 Episode wrapup 

One of my biggest joys of the Shiny Developer Series is watching the journeys of many innovations in the Shiny ecosystem from the brilliant community of developers and practitioners. It is my great pleasure in episode 25 to welcome back data scientist & software engineer Colin Fay! Picking up from his last appearance almost three years ago, Colin takes us through the journey of authoring the recently-published Engineering Production Shiny and his favorite principles covered in the book. We also discuss the uptake of golem in the R community, his new approaches to starting development of a Shiny app integrating customized HTML templates, and even a little real-time consulting on using his brand-new brochure package for a fun learning project!Resources mentioned in the episodeEngineering Production-Grade Shiny AppsW3.CSS Templates{golem}: Opinionated framework for building production-grade Shiny applications{brochure} : Natively multipage Shiny appsgolemexamples: Gathering in one place some {golem} examplesEpisode Timestamps00:00:00 Episode Introduction 00:01:15 Engineering Production-Grade Shiny Apps 00:11:00 The current state and future of golem 00:11:20 'Once you go golem, you never go back!' 00:26:09 HTML Template Demo 00:37:35 brochure package discussion 01:04:10 Advice for Shiny developers seeking to get their apps in shape for production 

Whether in a sports pickup game or a different friendly competition, we often strive for balancing the distributions of skills so everyone can have fun. What does this have to do with Shiny? In episode 29, our coverage of the 2021 Shiny contest continues as I am joined by Douglas Mesquita and Luis Gustavo Silve e Silve who created the novel FairSplit Shiny application! Motivated by regular football pickup games, Douglas and Luis developed a novel algorithm to balance the distribution of individuals incorporating multiple traits that eventually wound up into a snazzy Shiny app that easily has something for everyone. This is yet another example of the many use cases Shiny brings at your fingertips.Resources mentioned in the episodeFairSplit App - voronoys.shinyapps.io/fairsplitFairSplit Code - github.com/voronoys/fairsplitContest submission post - community.rstudio.com/t/fairsplit-shiny-contest-submission/104752Episode Timestamps00:00:00 Episode & Douglas' introduction 00:02:50 Luis' introduction 00:07:30 Fairsplit Shiny app 00:17:10 Application walkthrough 00:27:20 Sidenote: Statistical bias introduced into the system 00:47:47 Code discussion 01:12:25 Episode wrapup 

In episode 24 of the Shiny Developer Series, we kick off a series of episodes that spotlight amazing Shiny applications submitted in the 2021 RStudio Shiny Contest! David Barkemeyer joins Eric to uncover the technical achievements and design philosophy of his myPaintings application, complete with many innovative capabilities that greatly enhance the user experience and backend infrastructure. Throughout the episode, you will hear David's perspectives on effective techniques to manage application state, integration of custom javascript, and much more!Resources mentioned in the episodeDavid on GitHub: https://github.com/DavidBarkemyPaintings - Painting Trading PlatformShiny app: https://mypaintings.davidbarke.comGitHub Repo: https://github.com/DavidBarke/mypaintings{shinyjs}{bs4Dash}Episode Timestamps00:00:00 Episode Introduction 00:03:24 How David got started with R & Shiny 00:05:40 Introduction to myPaintings 00:24:15 Infinite scroll feature 00:30:22 Design UI & UX of myPaintings 00:34:15 User management & helper functions 00:46:51 Overall app & file organization 00:49:28 Using .values to store & update user state and environment 00:53:40 R6 classes as another option 01:00:20 Recap and conclusion 

Episode 30 of the Shiny Developer Series reveals just how the power of open source software can be used to provide meaningful improvement to our daily lives. In the first of a two-part series, chief data scientist Mike Thomas reveals the motivation behind his brilliant COVID-19 test locator Shiny application, empowering a local community in Connecticut to efficiently report and track availability of test kits in a huge time of need. After a tour of the application interface, Mike shares his favorite techniques to bring an efficient user experience and the backend integrations with APIs to bring production-grade features to life.Resources mentioned in the episodeCOVID-19 At-Home Test Spotter (App) - ketchbrookanalytics.shinyapps.io/covid_test_spotterCOVID-19 At-Home Test Spotter (Code) - github.com/ketchbrookanalytics/covid_test_spotterApp blog post - www.ketchbrookanalytics.com/post/ketchbrook-analytics-launches-website-to-help-connecticut-residents-find-covid-19-test-kitsOlivia Adams' interview with CNN - www.cnn.com/videos/health/2021/02/08/software-developer-builds-simple-massachusetts-covid-19-vaccine-website-olivia-adams-intv-newday-vpx.cnnR Packages by Hadley Wickham and Jenny Bryan - r-pkgs.org{googleWay} Shiny vignette - symbolixau.github.io/googleway/articles/googleway-vignette.html#shinyEpisode Timestamps00:00:00 Episode Introduction 00:01:31 Mike's introductiona and journey with R & Shiny 00:07:20 Data science consulting and Ketchbrook Analytics 00:11:40 Olivia Adams' inspiring story 00:17:40 Demo of Mike's COVID-19 At-Home Test Spotter App 00:31:55 App code introduction 00:32:10 googleway package integrating the Google Maps API 00:36:25 Pulling addresses from map searches 00:41:10 Using MongoDB for records collection 00:43:15 bslib to simulate the multi-page app experience 00:46:20 Episode wrapup shinydevseries::session_info()📽 Find previous interviews at https://shinydevseries.com📋 Feedback is more than welcome! Please send your comments or suggestions on our contact form at shinydevseries.com/contactIf you enjoyed this video or got value from it, then consider dropping something in the tip jar. Any money raised will be used to improve the channel and invest in additional equipment and resources to make the content even better!💰 https://bit.ly/sdstip📨 Help shape the future direction of the Shiny Developer Series live streams by completing this very short surveyMedia production for the Shiny Developer Series is made possible by these outstanding projects and platforms:OBS Studio: https://obsproject.com/OBS Fully Loaded install script by Martin Wimpress: https://github.com/wimpysworld/obs-fully-loadedVDO Ninja: https://vdo.ninjaStreamElements: https://streamelements.comShotCut: https://shotcut.org/Pop@_OS by System76: https://pop.system76.com/Ubuntu: https://ubuntu.com/

One of the common themes seen throughout the Shiny Developer Series is that effective Shiny development is much more than just getting an application to work! Other important considerations include applying Shiny to high-profile projects, ensuring a production-grade code base, and even building robust tooling to assist with development. I have the pleasure of discussing these with Appsilon software engineer and Shiny frontend developer Pedro da Silva! You will hear Pedro's practical advice on the many developer-friendly packages and tools he uses for production Shiny development, a detailed walkthrough of his (Shiny contest) award-winning Shiny Decisions application, and his recommendations for taking your Shiny development skills to the next level.Resources mentioned in the episodePedro's website with links to posts and webinnars: https://www.pedrocsilva.comAppsilon: https://appsilon.comShiny Decisions repo: https://github.com/pedrocoutinhosilva/shiny.decisionsDeployed Shiny Decisions app: https://sparktuga.shinyapps.io/ShinyDecisionsR6 chapter from Advanced R: adv-r.hadley.nz/r6.html{glue} for interpreted string literals: https://glue.tidyverse.org/{tidymodules}: https://opensource.nibr.com/tidymodules/index.html{sass} for R and Shiny: https://rstudio.github.io/sass/index.html{bslib}: https://rstudio.github.io/bslib/John Coene's "Javascript for R" book: https://book.javascript-for-r.com/David Granjon's "Outstanding Shiny UI" book: https://unleash-shiny.rinterface.com/{renv}: https://rstudio.github.io/renv/articles/renv.html{testthat}: https://testthat.r-lib.org/{shinyloadtest}: https://rstudio.github.io/shinyloadtest/Tidyverse style guide: https://style.tidyverse.org/An lintr, which performs automated checks to confirm that you https://appsilon.com/conform to the style guide, https://github.com/jimhester/lintrMastering Shiny: https://mastering-shiny.org/Pedro's recommended Chrome extensions for development: Resolution Test: Test web pages in different screen resolutionsColorPick Eyedropper: A zoomed eyedropper & color chooser toolScreenshotting: Web page screen captureCSS Peeper: Extract CSS and build beautiful styleguidesEpisode Timestamps00:00:05 Episode Introduction 00:02:49 Appsilon, Shiny consulting 00:07:49 The wonderful 'black magic' of Shiny 00:09:55 Custom Shiny apps in the enterprise. Number one theme: migrating from excel 00:17:45 Demo of Shiny app game Shiny Decisions 00:22:55 A code walkthrough of Shiny Decisions <//br> 00:32:55 On styling Shiny Decisions 00:50:45 The value of learning a little javascript to improve your Shiny apps 00:51:55 Book recommendations for integrating Javascript into your Shiny app and improving UI 00:52:55 Pedro on jQuery for Shiny 00:56:05 Advice for building Shiny apps in production 01:10:05 Advice for people seeking a career in data science with R and Shiny

The Shiny Developer Series spotlight on the 2021 Shiny Contest continues with episode 28! Eric is joined by statistics lecturer Dr. Kate Saunders to share her unique coronaSweeper Shiny application which merges a well-known mini-game in the Windows world with modelling the spread of COVID19. On the surface it might seem straight-forward, but Kate walks us through her extensive design ideas of the algorithms and user experience of the application frontend. This was a very inspiring conversation that demonstrates the ways Shiny can be transformative to teaching real principles in mathematics, statistics, and beyond!Resources mentioned in the episodecoronaSweeper App - katerobsau.shinyapps.io/Corona_SweepercoronaSweeper Code - github.com/katerobsau/coronaSweeperKate's contest submission post: community.rstudio.com/t/coronasweeper-shiny-contest-submission/104767Follow Kate on Twitter - @katerobsauEpisode Timestamps00:00:00 Episode Introduction 00:04:45 Inspiration behind coronaSweeper 00:08:15 Demo of coronaSweeper 00:14:35 Code walkthrough 00:43:10 Shiny for teaching? 00:50:20 Episode wrapup 

Earlier this year at RStudio Global, a lot of excitement among the Shiny enthusiasts centered on the brand new bslib and thematic packages for radically changing the style of typical Shiny app user interfaces. I am thrilled to get the inside story on this amazing development with the brilliant author, RStudio software engineer Carson Sievert! In this episode you will hear Carson's recommendations on getting started with bslib for both Shiny applications and even R-Markdown documents, why SASS (no, not that one) rules empower a Shiny developer to make sweeping changes in CSS, as well as the major milestone release of shinymeta, a package that directly addresses a huge need for traceable and reproducible analyses from Shiny apps in many industries such as life sciences. I hope you enjoy this episode and don't forget to subscribe to our channel so you can be first to know when future episodes are available!Resources mentioned in the episodeInteractive web-based data visualization with R, plotly, and shinybslib: Tools for theming shiny and rmarkdown from R via Bootstrap (3 or 4) Sass rstudio.github.io/bslibthematic: Simplified theming of ggplot2, lattice, and base R graphics rstudio.github.io/thematicshinymeta: Record and expose Shiny app logic using metaprogramming rstudio.github.io/shinymetaflexdashboard: Easy interactive dashboards for R pkgs.rstudio.com/flexdashboardEpisode Timestamps00:00:00 Episode Introduction 00:02:00 Joining the Shiny team at RStudio and Carson's book on plotly 00:06:39 Introducing bslib and how it makes custom theming of your Shiny app as easy as possible 00:08:47 Introducing thematic for simplified theming of ggplot2, lattice, and base R graphics 00:14:28 Getting started with bslib 00:23:45 Real-time theming wizard, a tool to play interactively with the theming customization of your shiny app or R Markdown document 00:29:25 Development version of flexdashboard supports bslib now 00:36:38 On the advantages of working with sass over css. bslib helps you work with a front end web developer, writing sass rules and css styles while not having to dive into your Shiny app or R Markdown document 00:46:30 The origins of shinymeta and the ability to fully extract an app's reactive processing to produce a fully self-contained analysis script or report 00:57:40 Getting started with shinymeta 01:01:20 Shinymeta example of producing reproducible Shiny code 01:05:36 How does Carson recommend to Shiny developers who want to get better at cusotmizing the look and feel of their Shiny app? See Shiny’s Build articles 01:15:35 Attaching metadata to graphical markers in plotly 01:19:47 Episode wrapup

The R-Podcast has risen again! After sharing the story of my R adventures since the last episode, we focus on a very important initiative that could pave the way for the next generation of developers contributing to the future of R itself. I am joined by research software engineer Heather Turner and statistician Saranjeet Kaur Bhogal to share the story of how the new R Development Guide brings a new and accessible approach for learning how to contribute to the R project itself, along with their vision of the upcoming Collaborative Campfires to inspire and grow the community around this imporant effort. Links Update on the RWeekly and 2021 Reflections: https://rweekly.fireside.fm/70 (https://rweekly.fireside.fm/70) Collaboration Campfires: contributor.r-project.org/events/collaboration-campfires (https://contributor.r-project.org/events/collaboration-campfires) R Contribution Working Group: contributor.r-project.org/working-group (https://contributor.r-project.org/working-group) R Development Guide: contributor.r-project.org/rdevguide/ (https://contributor.r-project.org/rdevguide) Digital Infrastructure Icubator: incubator.codeforscience.org/cohort (https://incubator.codeforscience.org/cohort) Feedback Email the show: thercast[at]gmail.com Use the R-Podcast contact page: https://r-podcast.org/contact

I take a quick minute to announce that the R-Podcast is coming back! And to check that the feeds are still working ...

In episode 21 of the Shiny Developer Series, I have the pleasure of welcoming back the newest member of the Shiny team, Nick Strayer! We discuss the road Nick traveled to join RStudio full time, as well as the motivation behind the terrific Shiny App Stories, complete with a hands-on demonstration of new features in Shiny 1.6 such as bindCache and dynamic theming in the fun explore your weather application. All of that plus Nick\'s perspectives on the growing Shiny ecosystem and creating powerful data visualizations make this a must-see episode!Resources mentioned in the episodeShiny App Stories example - The "Why" documentation, plus demonstrations of new and advanced features in the context of real-world applications.bindCache() - To speed up your app's reloading of previously accessed data. Dynamic theming with bslib - bslib helps you theme your app really easily. session objectgetCurrentOutputInfoData visualization innovators Nick follows: Nadieh Bremer (@NadiehBremer), Shirley Wu (@sxywu), Amelia Wattenberger (@Wattenberger).Episode Timestamps00:00:00 Episode Introduction 00:06:15 Nick's journey since episode 5 00:08:10 Shiny app stories - an experimental form of documentation. Most documentation focuses on the How to do something, Shiny App Stories focuses on the Why 00:13:15 App Stories in action 00:16:25 bindCache() discussion on speeding up your Shiny app 00:22:57 Dynamic theming with {bslib} 00:27:00 The usefulness of the session object in an Shiny app 00:32:30 Including web-technologies (like custom js, css, incorporating better design philosiphies) in your Shiny app 00:39:50 On the Shiny Ecosystem. Nick only recently moved from being an active Shiny developer to being on the core-Shiny team itself 00:43:35 On Creating great data visualizations and offering data consumers an excellent user experience 00:56:25 What's the best way to give feedback to the Shiny team? 01:05:22 Episode wrapup 

Episode 20 of the Shiny Developer series is here! As someone who has authored many production grade Shiny applications, I have come to realize that sophisticated backend functionality is not the only area one needs to address, it is also the end-user experience and how the application is presented. I am thrilled to welcome back David Granjon to the Shiny Developer Series to discuss the journey and key topics addressed in his brand-new textbook Outstanding User Interfaces with Shiny! Plus David leads us through a comprehensive demonstration of amazing new capabilities of the awesome bs4Dash package, part of the RinteRface project. I hope you enjoy this episode!Resources mentioned in the episodeOutstanding User Interfaces with Shiny (online){bs4Dash}: Bootstrap 4 shinydashboard using AdminLTE3Episode Timestamps0:00 Episode Introduction 3:47 What's new in RinteRface 4:43 Demo of {bs4Dash} 24:09 David's new book: Outstanding User Interfaces with Shiny 38:15 Creating custom dashboard templates 43:53 Moving away from renderUI using custom handlers, and why you should manage content with handlers 46:50 Shiny UI advice, tips for balancing UX with backend performance of the app 54:40 Episode wrapup

A brand new season of the Shiny Developer Series kicks off with RStudio\'s chief scientist Hadley Wickham! Hadley joins Eric in episode 19 to discuss his exciting new book, Mastering Shiny. As author of many Tidyverse packages and long time contributor to the data science community, he has poured his wealth of experience into this book dedicated to helping you become a better Shiny developer. We talk about the origins of Shiny and advice for those just starting out. For those already familiar with Shiny we discuss debugging, how to level up your skills, and best practices for seeking help and contributing to the community.Resources mentioned in the episodeMastering Shiny (online)Advanced R: Second EditionR for Data ScienceEpisode Timestamps0:00 Episode introduction 2:05 Hadley's involvement with Shiny's early development 5:22 Writing Mastering Shiny 8:30 Shiny touches on data analysis alongside software engineering and programming 12:41 Best ways to get started with Shiny 14:53 Value of tidy evaluation with Shiny 19:41 Importance & challenge of reactivity 24:30 Getting help with Shiny 28:43 Becoming a better Shiny developer and collaborator 33:51 Shiny community engagement 38:12 Where to find Mastering Shiny 40:01 How to level-up your skills as a Shiny developer 41:53 Recap and closing remarks

In episode 18 of the Shiny Developer Series, we chat about how Shiny has brought significant value to projects of all scales with the founder of TCB Analytics Tanya Cashorali! You will see hands-on demonstrations of applications Tanya built to achieve rapid prototypes and production-level dashboards ready for customers across a wide range of industries. We also hear Tanya's advice on development techniques and which skills she recommends developers level up with. I hope you enjoy this excellent episode!Resources mentioned in the episodeTCB Analytics: tcbanalytics.comAbout TCB Analytics: tcbanalytics.com/aboutEpisode Timestamps0:00 Episode introduction 7:50 As a consultant, how do you see Data Scientist create value for their team? 9:20 Data scientist provide a lot more value when you bring them on early. 11:50 On rapid prototyping 14:50 Demo 1: Sports Innovation Lab - Anomaly Detection 21:45 Demo 2: Rapid Blood Testings - Monitoring Streaming Alerts 28:40 Advice for people that need to integrate Shiny with different systems. 31:30 Arrow is fast and makes connecting with other systems easy. 36:00 Demo 3: Study Tracking for Life Sciences firm - Show deviations by study. 40:47 On the practical side, how do you work as a consultant with teams who hire you? 42:20 Suggestions for finding or leveling up the skills of shiny developers on a team? 45:05 What is your ideal way to build a shiny app? 51:15 Advice for people looking to become freelance shiny developers. 52:40 Advice for folks getting more involved with Shiny development, jobs, or learning more. 55:30 Episode conclusion

In episode 17 of the Shiny Developer Series, we welcome one of the earliest contributors to the Shiny ecosystem and the founder of AttaliTech, Dean Attali! In this illuminating conversation, you will hear all about how Dean arrived to the world of Shiny, updates to his excellent open-source packages like {shinyalert} and the brand-new {shinyscreenshot}, the origins of Attali Tech, and his new journey to becoming a full-time open-source R and Shiny developer!Resources mentioned in the episodeHelp sponsor Dean's move to full-time open-source development via GitHub Sponsors: github.com/sponsors/daattaliDean's website: deanattali.comAttali Tech: attalitech.com/Dean's YouTube channel: youtube.com/channel/UCR3No6pYhA1S7FZ0PbLKlgQ`{shinyscreenshot} - Capture screenshots of entire paggs or parts of pages in Shiny apps: daattali.com/shiny/shinyscreenshot-demo{shinyalert} - Easily create pretty popup messages (modals) in Shiny: daattali.com/shiny/shinyalert-demo{shinyjs} - Easily improve the user experience of your Shiny apps in seconds: deanattali.com/shinyjs{timevis} - An R package for creating timeline visualizations: daattali.com/shiny/timevis-demo{htmlwidghts}: www.htmlwidgets.org{reactR} - React for R: react-r.github.io/reactRClean Code - A Handbook of Agile Software Craftsmanship: www.oreilly.com/library/view/clean-code-a/9780136083238Episode Timestamps0:00 Episode introduction (with a special guest) 1:42 Dean's Introduction 3:52 Getting started with R and Shiny 7:57 shinyjs and custom JavaScript in Shiny apps. Tooling to create developer tools for Shiny apps. htmlwidgets, reactR 11:17 shinyscreenshot, released 2020-11-05, allows you to capture screenshots of entire pages or parts of pages in Shiny apps, and have the image downloaded as a PNG automatically. 18:42 Shiny Alert update 21:07 Attali Tech and becoming a Shiny Consultant. 22:37 teaser “go full shiny, full time” 23:42 Who Uses Shiny? 24:37 Where Attali Tech is headed. 2019 was dominated by a large set of clients, and Dean didn’t have enough time to contribute more to open source Data Science and Shiny in particular. Moving forward, Dean’s goal is to spend more time on his open source projects. He is seeking sponsorship to help pay for his open-source work. 28:21 How are people using and find value with Shiny? 35:32 Advice for building more robust Shiny applications. 39:02 Tips for debugging, with demo. 47:42 Tips for dealing with grid layouts. 51:17 shinyjs::runcodeUI, learn more at shinyjs 56:52 Advice to Shiny developers taking their shiny skills to the next level 60:53 Episode wrapup (with the same special guest)

In episode 16 of the Shiny Developer Series, we welcome software developer Jiena McLellan! Jiena shares how she has created many useful packages and Shiny applications to help not only with her day job, but for fun personal projects benefiting her friends and family too! We dive deep into her innovative DT-Editor Shiny module, as well as how she developed packages based on htmlwidgets such as the flashCard package for teaching yourself new concepts.Resources mentioned in the episodeJiena's website: www.jienamclellan.comDT Editor module demonstration app: appforiarteam.shinyapps.io/DT_editor_shiny_moduleDT Editor GitHub repository: github.com/jienagu/DT-Editor{noteMD} Print text from a Shiny UI with support for markdown to pdf or word reports: github.com/jienagu/noteMDDemo app integrating DT Editor and noteMD: github.com/jienagu/Shiny_Full_Flow{faq} Create a Frequenty Asked Questins page for Shiny apps: github.com/jienagu/faq{flashCard} R package to create flash cards: github.com/jienagu/flashCardDemo app for flashcards teaching Python syntax: appforiarteam.shinyapps.io/flashCard_demoJiena's codepen for practice flash card syntax: codepen.io/Jienagu/pen/qBdNbVy{forestry} R package with utility functions to help with reshaping hierarchy of data trees: github.com/jienagu/forestryEpisode Timestamps0:00 Episode introduction 0:43 Introducing Jiena 4:18 DT-editor - A shiny module that allows your Shiny app users to edit and update DT tables in your shiny app https://github.com/jienagu/DT-Editor 13:23 DT-editor shiny module https://github.com/jienagu/DT_editor_shiny_module 18:33 noteMD, Add a textfield to your shiny app, which may then be printed to pdf or word. 23:23 Example blending DT editor and noteMD together https://github.com/jienagu/Shiny_Full_Flow 25:33 FAQ https://github.com/jienagu/faq 32:38 Htmlwidget flip - flashcard https://github.com/jienagu/flashCard 42:28 Demo, showing the experience of developing htmlwidgets and js code bases. 60:13 Advice for Shiny developers 63:53 Episode conclusion

We have another fun installment of the Shiny Developer Series in episode 15! Our guest is statistical programmer and data scientist Maya Gans, and she tells us about her unique journey to R, her experience as a summer intern at RStudio, and the ways she has wielded some magical integrations of Shiny and javascript to create powerful applications in life sciences. Plus you will not want to miss the inside story behind the shinykeyboard widget!Resources mentioned in the episodeTidyBlocks (A block-based tool for teaching basic data science): [https://tidyblocks.tech/](tidyblocks.tech)shinyBody A custom Shiny input widget built with HTML and CSS that lets you select a body part and will return that body part's name.You can also color limbs based on data by specifying high and low color values: [https://github.com/MayaGans/shinyBody](github.com/MayaGans/shinyBody)JavaScript for Data Science: [https://js4ds.org/](js4ds.org)TidyCDISC application demonstration at the R/Medicine 2020 Virtual Conference: [https://www.youtube.com/watch?v=QeHSjw-vU3U](youtube.com/watch?v=QeHSjw-vU3U)Interactive web-based data visualization with R, plotly, and Shiny: [https://plotly-r.com/](plotly-r.com)timevis R package for creating timeline visualizations: [https://daattali.com/shiny/timevis-demo/](daattali.com/shiny/timevis-demo)ggkeyboard: [https://github.com/sharlagelfand/ggkeyboard](github.com/sharlagelfand/ggkeyboard)shinykeyboard R package to create an on-screen keyboard as a custom R Shiny input binding: [https://github.com/willdebras/shinykeyboard](github.com/willdebras/shinykeyboard)dreamRs Shiny gallery: [http://shinyapps.dreamrs.fr/](shinyapps.dreamrs.fr)Episode Timestamps0:00 Episode introduction 4:30 TidyBlocks tidyblocks.tech. A block-based tool for teaching basic data science. 7:00 Garrick Aden-Buie, https://www.garrickadenbuie.com/ 7:45 shinyBody. Everyone asks, “What are good ways to level up on R and Shiny?”, the shinyBody Shiny app is a relatively simple, focused Shiny app that helps you get JavaScript started talking to R. 14:20 David Granjon’s Outstanding User Interfaces 14:35 R + Shiny for JS Visualizations. JavaScript for Data Science, website. Find it on Google Books, amazon 15:25 tidyCDISC Shiny App. tidyCDISC CDISC is a file format for clinical trials. This app helps you explore your CDISC data, following common patterns and at least as a first pass, helping you produce standard tables and figures the FDA will want to see. 17:18 golem, not just a nice tool for Shiny app development , but also for multi-developer, collaborative Shiny app development. “golem: If you’re working with a team of people, I highly recommend it, for easier collaboration.” 19:00 CDISC table generator. 25:20 plot.ly in shiny apps. Carson’s Book on ploy.ly with R. 27:15 shiny timevis by Dean Attali. On github. 29:15 Extending Sharla Gelfand’s ggkeyboard into shinykeyboard made with Will Bonnell. A visual keyboard, a tool for added accessibility with R. 33:50 “What advice do you have for Shiny developers in our audience who want to take their skills to the next level?” 36:20 Episode conclusion

In episode 13 of the Shiny Developer Series, we continue our conversation with RStudio software engineer Barrett Schloerke to highlight how you can integrate Shiny apps with custom APIs written in R via the plumber package! You’ll see awesome demonstrations of the key features that are part of the brand new plumber 1.0 release, including brand new serializers and parsers for custom objects, a new tidy API compliant with magrittr pipelines, utilizing asynchronous execution, and more.Resources mentioned in the episodeplumber allows you to create a web API by merely decorating your existing R source code with roxygen2 style comments. Site: https://www.rplumber.io/Demos:NEW - Hex logo and website!NEW - pipe-able programatic interface Demo: plumb(dir = "plumber/pipe") %>% pr_run()NEW - POST body parsing Process incoming POST body dataEx: HTML forms, multipart forms, csv, tsv, json, yaml, feather and rds.Like serializers, register new POST body parsersSite: https://www.rplumber.io/reference/parsers.htmlMore Serializers! Serialize outgoing route dataEx: plain text, json, yaml, csv, tsv, rds, featherNEW - Register image serializers: svg, tiff, bmp, pdf. (Pre existing: png, jpeg)Site: https://www.rplumber.io/reference/serializers.htmlNEW - Download return values as attachments! Site: https://www.rplumber.io/reference/as_attachment.htmlDemo: plumb_api("plumber", "16-attachment") %>% pr_run()NEW - Async / promises Demo: plumb("plumber/plumber-future.R") %>% pr_run()NEW - API UIs (rapidoc) Register new User Interfaces to look at your APIDemo: plumb(dir = "plumber/rapidoc") %>% pr_run()Thank you to Bruno Tremblay (@meztez) for his heavy contributions to plumber!Recent conference talks about plumber: Democratizing R with plumber APIs (James Blair): rstudio.com/resources/rstudioconf-2019/democratizing-r-with-plumber-apisPractical plumber patterns (James Blair): rstudio.com/resources/rstudioconf-2020/practical-plumber-patterns/Bike Prediction example application with plumber API and Shiny: solutions.rstudio.com/tour/bike_predict/Episode Timestamps0:00 - Intro 1:14 - Introduction to plumber 4:14 - Example of plumber API 7:14 - Pipeable interface for plumber 9:19 - plumber's new hex logo! 9:24 - Serializers in plumber 13:04 - Parsers in plumber 14:30 - as_attachment for serializers 15:50 - Demo of downloading an attachment from API 16:07 - A consistent way to check for plumber APIs with available_apis() 18:50 - Async processing in plumber 24:23 - Demo of the plumber documentation UI 29:20 - Example of decoupling data source from Shiny app 29:50 - Episode wrapup

We conclude our multi-part series with RStudio software engineer Barret Schloerke with an in-depth look at the learnr package and how Shiny plays a huge role in powering the many features and extensibility available! Barret walks us through two showcases of learnr in action with the RStudio primer tutorials as well as the eye-catching naniar missing values tutorial by Allison Horst. Plus we get a preview of the great features coming up in the next release, and advice for Shiny developers looking to bring their skills to the next level.Resources mentioned in the episodelearnrThe learnr package makes it easy to turn any R Markdown document into an interactive tutorial. Tutorials consist of content along with interactive components for checking and reinforcing understanding.Site: https://rstudio.github.io/learnr/Demos:RStudio Primers: https://rstudio.cloud/learn/primersAllison Horst Post: https://education.rstudio.com/blog/2020/05/learnr-for-remote/Demo: https://allisonhorst.shinyapps.io/missingexplorer/Source: https://github.com/allisonhorst/explore-naSortable Site: https://rstudio.github.io/sortable/Demo: https://rstudio.github.io/sortable/tutorials/tutorial_question_rank.htmlEpisode Timestamps0:00- Episode Introduction 0:48- Introduction to learnr 2:10- Examples of learnr tutorials, rstudio.com/learn/primers 5:26- A very nice learnr tutorial example from Alison Horst 7:10- Getting started with learnr 9:10- {sortable} for questions that require ranking/sorting questions. 12:40 - Working on multi-language support. Including SQL, Python, and more. 14:16 - Advice for Shiny users 18:34 - Episode wrap-up

In episode 12 of the Shiny Developer Series, we begin a multi-part series with RStudio software engineer on the Shiny team Barret Schloerke! In part 1 we learn more about Barret’s journey to the Shiny team and take a deep dive into the very powerful reactlog framework to help users shed some light on what can be a confusing world of reactivity in their applications. Barret leads us through interactive demonstrations of reactlog applied to simple and complex applications to pinpoint various issues on reactive logic and the flow of information from inputs to outputs.Resources mentioned in the episode{rbokeh} - R interface for Bokeh: hafen.github.io/rbokeh{trelliscopejs} - Create interactive trelliscope displays: hafen.github.io/trelliscopejs{autocogs}: github.com/schloerke/autocogs{reactlog} - Provides a visual insight into that black box of Shiny reactivity: rstudio.github.io/reactlogDemos: (Launch reactlog: cmd + F3 or ctrl + f3)shiny::runApp("reactlog/reactlog-pythagorus.R")shiny::runApp("reactlog/reactlog-pythagorus-broken.R")shiny::runApp("reactlog/reactlog-cranwhales.R")shiny::runApp("reactlog/reactlog-anti-pattern.R")Episode Timestamps0:00 - Intro 0:42 - Barret’s background, how he got started with R, Shiny, and RStudio. 3:41 - Bokey, Trelliscope, Ryan Hafen 4:36 - Autocogs 5:56 - Starting with RStudio 7:31 - Introduction to reactlog 9:31 - Demonstration of reactlog 10:51 - How reactlog can help diagnose issues 11:11 - Diagnosing a Shiny app's output example 13:30 - Demo of using reactlog with a larger application 14:31 - Zooming in example 15:00 - Using the search bar 17:25 - Finding anti-patterns 23:27 - Wrapup

In episode 11 of the Shiny Developer Series, we are joined by R package author and Shiny enthusiast Yoni Sidi. We discuss Yoni\'s stories of how Shiny brought immediate and positive impact to his daily work across industries such as life sciences, the origins of his popular ggedit package, a new package to drill deeper into testing reactivity in Shiny apps, and much more!Resources mentioned in the episode{ggedit} - Interactively edit ggplot layer aesthetics and theme definitons: yonicd.github.io/ggeditLightning talk on {ggedit} at rstudio::conf 2017 (timestamp 13:35-19:35): rstudio.com/resources/rstudioconf-2017/lightning-talks-users{ggedit} video series on YouTube: www.youtube.com/playlist?list=PLruc2EmpfX8Vceb2rE4uwbWV3CrkTlwLj{reactor} - Unit testing for Shiny reactivity (likely will be renamed): github.com/yonicd/reactor{reactor} demonstration YouTube video: youtu.be/RW5hYtXxmCA{qibble} - Tidy framework to manage jobs on the Open Grid Scheduler: github.com/yonicd/qibble{shinyHeatmaply} - Shiny application and Shiny gadget for the {heatmaply} package: yonicd.github.io/shinyHeatmaplyIsrael Election Polls Analysis Depot Shiny application: yonicd.github.io/ElectionsTrack NONMEM (Nonlinear Mixed Effects Modelling) progress while model evaluates with Shiny: github.com/yonicd/NMTracker{streamline} - Utilities to work with NONMEM Control Stream files: github.com/yonicd/streamline{lintr} - Static code analysis for R: github.com/jimhester/lintrThe slackverse family of packages to interact with Slack: {slackteams} - Manage and interact with multiple Slack teams in R: yonicd.github.io/slackteams{slackcalls} - Generic package to call slack API from R: github.com/yonicd/slackcalls{slackthreads} - Wrangle Slack conversations, replies, and threads in R: github.com/yonicd/slackthreads{slackblocks} - Slack Blocks in R: github.com/yonicd/slackblocks{slackreprex} - reprex + slack: yonicd.github.io/slackreprexEpisode Timestamps0:00 - Intro 3:10 - Breaking R into Israel's central bank 6:25 - First Shiny app and growing as a Shiny developer 11:35 - On working with Tal Galili & heatmaply 12:45 - The story of ggedit 23:30 - The value of Shiny in Yoni's work 32:50 - Advice on learning Shiny 36:22 - reactor package for unit testing reactivity 43:30 - Closing thoughts

In this packed episode of the Shiny Developer Series, we are joined by the very talented John (JP) Coene to explore tools and skills that can ease your journey in creating production-grade Shiny applications! We examine the backstory of John's highly-regarded Coronavirus mobile-first Shiny application, how you can use his excellent {waiter} and {server} packages to improve user experience, and much more!Resources mentioned in the episodeCovid19 tracker - A popular Coronavirus tracker application built upon {shinyMobile}: johncoene.shinyapps.io/contest-coronavirusJohn's blog post about the application: blog.john-coene.com/posts/2020-02-08-ncov-2019/RStudio Community post: community.rstudio.com/t/coronavirus-2020-shiny-contest-submission/53061{waiter} - Loading screens for Shiny: shiny.john-coene.com/waiter/{sever} - Good-looking problems by customizing your Shiny disconnected screen and error messages: sever.john-coene.com/{echarts4r} - Interactive visualizations for R: echarts4r.john-coene.com/How to build htmlwidgets (e-Rum 2020 virtual workshop): htmlwidgets.john-coene.com/Blog post on building htmlwidgets for Shiny apps: blog.john-coene.com/posts/2018-01-01-widgetEngineering Production-Grade Shiny Apps by Colin Faye: engineering-shiny.org/Episode Timestamps0:00 - Intro2:37 - Covid19 tracker - A popular Coronavirus Tracker app, built on shiny mobile: https://johncoene.shinyapps.io/contest-coronavirus5:37 - Golem - Within the Covid19 Tracker discussion, on the usefulness of golem for building shiny apps with best practices. 8:57 - On working with shinyMobile https://rinterface.github.io/shinyMobile, Maintainer; David Granjon12:47 - Shiny with R in Production and at scale. 17:27 - Waiter package. A key, simple way to improve the experience of your shiny app is giving the user clear information about how quickly app-components will take to load. https://shiny.john-coene.com/waiter/32:57 - On the importance of ensuring your shiny apps looks and feels good to the end user34:10 sever. More pleasing and better handling of shiny app error & disconnection messages. https://sever.john-coene.com38:57 - Building htmlwidgets for shiny apps https://blog.john-coene.com/posts/2018-01-01-widget/44:14 echarts4r. A package for powerful visualizations with R. It is a good showcase for how htmlwidgets can interact with your shiny-app, sending messages between your user and your server to improve the types of interactions possible with your visualizations. https://echarts4r.john-coene.com57:27 Advice for Shiny developers that want to take that “next step” in building complex applications for production use. Hadley Wickham’s Mastering-shiny.org (still under development)Divad nojnarg - outstanding shiny ui, https://divadnojnarg.github.io/outstanding-shiny-ui/intro.htmlColin Fay’s “Engineering Production-Grade Shiny Apps” at https://engineering-shiny.org/1:00:46 Wrapup

The Shiny Developer Series is back! In our first session of 2020, we are joined by professional educator and data scientist Mine Cetinkaya-Rundel to get the inside story of the newly updated Shiny Dev Center (including a major revision of the Shiny Gallery) and the insights RStudio gained from the Shiny Contest. Also Mine shares her advice on developing educational material for Shiny users and where she sees future opportunities in this evolving space.ResourcesShiny Gallery: shiny.rstudio.com/galleryShiny Tutorials: shiny.rstudio.com/tutorialReprex guide for Shiny questions on RStudio Community: community.rstudio.com/100012020 Shiny Contest information: blog.rstudio.com/2020/02/12/shiny-contest-2020-is-hereMastering Shiny by Hadley Wickham: mastering-shiny.orgEpisode Timestamps00:56 Mine Introduction. 03:01 Shiny Gallery - walkthrough and recent revamp. 04:15 Shiny Demos - live examples and deep-dive into shiny's features. 05:20 Shiny User Showcase - A large set of example shiny apps, by the Shiny community. Including code on github, and interactive code on rstudio.cloud. 06:10 Shiny Contest 2019 lead to the revamp of the showcase. 09:00 Example running an app on the Shiny Showcase interactively with rstudio.cloud. 12:40 Shiny Gallery walkthrough - Mine's learnings from reviewing the Shiny apps on the gallery. There's a lot to learn from, but Mine highlighted just a few: 13:40 1. BYOD Apps - Bring your own data shiny app best practices. 14:42 2. App Walkthroughs and jintrojs package. iSEE Shiny App. 17:15 3. Apps that don't look like Shiny apps. 17:30 Example 1. 69 Love Songs by the Magnetic Fields. 18:25 Example 2. Uber explorer app - another example that doesn't look like a standard shiny app. 19:04 Example 3. CRAN Explorer. 19:55 Example 4. Hex memory game. An example of a game Shiny app. 22:15 Teaching and Educational Materials for Shiny - Shiny development has its own set of challenges and Mine spends a lot of time thinking about teaching Shiny. 23:45 Learn Shiny tutorial - a nice short intro to Shiny. Includes written articles, videos, and code examples. shiny.rstudio.com/tutorial. 24:30 Asking good questions about the issues you're having with your Shiny app. What are good workflows for seeking help? Barret's Shiny debugging and reprex guide http://community.rstudio.com/t/10001 26:17 Materials for intermediate Shiny users. Articles on shiny.rstudio.com, workshop and conference videos, and a call to the Shiny Community. 28:00 Also for advanced Shiny developers, Hadley's Mastering Shiny book. Coming late 2020 mastering-shiny.org. 30:10 Shiny Contest 2020 - learnings from last year's contest, and advice to folks submitting to the next contest. https://blog.rstudio.com/2020/02/12/shiny-contest-2020-is-here/ 39:12 Shiny Dev Series Outtro

About this Episode This is the second of multiple episodes covering the recent rstudio::conf 2020! In this episode, Eric shares the backstory behind his Shiny Community e-poster and welcomes data scientist Garrick Aiden-Buie to discuss his spectacular JavaScript for Shiny Users course, the mind-blowing features of the package accompanying the course, and much more. Plus takeaways from Shiny-related presentations at the conference and a fresh batch of listener feedback. Links rstudio::conf(2020L) recordings: resources.rstudio.com/rstudio-conf-2020 (https://resources.rstudio.com/rstudio-conf-2020) Reaping the benfits of the Shiny community e-poster: rpodcast.shinyapps.io/highlights-shiny (https://rpodcast.shinyapps.io/highlights-shiny) Poster source code: github.com/rpodcast/highlights.shiny (https://github.com/rpodcast/highlights.shiny) Javascript for Shiny Users: js4shiny.com/ (https://js4shiny.com/) Garrick's GitHub: github.com/gadenbuie (https://github.com/gadenbuie) js4shiny package: pkg.js4shiny.com/ (https://pkg.js4shiny.com/) Styling Shiny apps with Sass and Bootstrap 4 (Joe Cheng): resources.rstudio.com/rstudio-conf-2020/styling-shiny-apps-with-sass-and-bootstrap-4-joe-cheng (https://resources.rstudio.com/rstudio-conf-2020/styling-shiny-apps-with-sass-and-bootstrap-4-joe-cheng) Reproducible Shiny apps with shinymeta (Carson Sievert): resources.rstudio.com/rstudio-conf-2020/reproducible-shiny-apps-with-shinymeta-dr-carson-sievert (https://resources.rstudio.com/rstudio-conf-2020/reproducible-shiny-apps-with-shinymeta-dr-carson-sievert) Getting things logged (Gergely Daroczi): resources.rstudio.com/rstudio-conf-2020/getting-things-logged-gergely-daroczi (https://resources.rstudio.com/rstudio-conf-2020/getting-things-logged-gergely-daroczi) Listener Ricardo's R & tidyverse tutorial: predictcrypto.org/tutorials (https://predictcrypto.org/tutorials) xaringan package's infinite moon reader: https://bookdown.org/yihui/rmarkdown/xaringan-preview.html (bookdown.org/yihui/rmarkdown/xaringan-preview.html) My appearance on Michael Dominick Show: https://www.automator.show/8 (https://www.automator.show/8) NSSD 101 interview with JJ Allaire: nssdeviations.com/101-special-guest-jj-allaire (http://nssdeviations.com/101-special-guest-jj-allaire) Feedback Leave a comment on this episode's post (https://r-podcast.org/33) Email the show: thercast[at]gmail.com Use the R-Podcast contact page (https://r-podcast.org/contact) Episode Timestamps 00:00:00.000 Intro 00:01:48.000 Shiny community e-poster 00:20:12.000 Garrick Aiden-Buie 00:38:10.000 Styling Shiny apps 00:40:56.000 Shinymeta 00:44:20.000 logger 00:49:49.000 listener feedback 00:57:25.000 Wrapup Music Credits Opening and closing themes: Training Montage by WillRock (http://ocremix.org/artist/5043/willrock) from the Return All Robots Remix Album (http://ocremix.org/events/returnallrobots/) at ocremix.org (http://ocremix.org/)

About this Episode This is the first of multiple episodes covering the recent rstudio::conf 2020! In this episode, Eric shares his take on the big news made by RStudio and has a great interview with RStudio software engineer Kevin Ushey. Links RStudio becomes a Public Benefit Corporation: blog.rstudio.com/2020/01/29/rstudio-pbc (https://blog.rstudio.com/2020/01/29/rstudio-pbc) RStudio changes structure to focus on public benefit: www.infoworld.com/article/3518390/rstudio-changes-structure-to-focus-on-public-benefit.html (https://www.infoworld.com/article/3518390/rstudio-changes-structure-to-focus-on-public-benefit.html) JJ Allaire's keynote slides: rstudio.com/slides/rstudio-pbc/ (https://rstudio.com/slides/rstudio-pbc/) A corporate paradign shift - Public Benefit Corporations https://www.gibsondunn.com/a-corporate-paradigm-shift-public-benefit-corporations/ (www.gibsondunn.com/a-corporate-paradigm-shift-public-benefit-corporations) renv: Project Environments for R kevinushey-2020-rstudio-conf.netlify.com/slides.html (https://kevinushey-2020-rstudio-conf.netlify.com/slides.html) renv GitHub repository: github.com/rstudio/renv (https://github.com/rstudio/renv) Emil Hvitfeldt's repository with rstudio::conf links to slides and other materials: github.com/EmilHvitfeldt/RStudioConf2020Slides (https://github.com/EmilHvitfeldt/RStudioConf2020Slides) Residual Snippets app: rpodcast.shinyapps.io/rsnippets (https://rpodcast.shinyapps.io/rsnippets) Feedback Leave a comment on this episode's post (https://r-podcast.org/32) Email the show: thercast[at]gmail.com Use the R-Podcast contact page (https://r-podcast.org/contact) Episode Timestamps 00:00:00.000 Intro 00:01:25.000 RStudio PBC 00:14:50.000 RWeekly Curators Unite! 00:18:45.000 RStudio's Kevin Ushey 00:42:26.000 Residual Snippets 00:47:52.000 Wrapup Music Credits Opening and closing themes: Training Montage by WillRock (http://ocremix.org/artist/5043/willrock) from the Return All Robots Remix Album (http://ocremix.org/events/returnallrobots/) at ocremix.org (http://ocremix.org/)

In this last webinar of the Shiny Developer Series for 2019, we are joined by Nathan Teetor of ZevRoss Spatial Analysis for an illuminating conversation about his yonder package! Nathan shares how yonder is not a full-on replacement of Shiny, but rather a collection of new functionality built on the Shiny engine. Plus some great demonstrations of key user interface features and plans for future development. Visit the follow-up thread on RStudio Community! to continue the discussion!Resources mentioned in the episodeVideo version of recording available at shinydevseries.com/ep6Follow-up thread for the episode on RStudio CommunityZevRoss Spatial Analysis - Know your Data: www.zevross.com{yonder} - A reactive framework built on Shiny: nteetor.github.io/yonderyonder-examples gallery: github.com/nteetor/yonder-examples

In this webinar originally broadcast live in partnership with RStudio Community, Victor Perrier and Fanny Meyer join Eric and Curtis to share the origins of their dreamRs consulting, their journey to becoming Shiny experts, and the many innovations that their open-source packages such as {shinyWidgets} can bring to any Shiny application user interface. Victor highlights a tour of the many features of this and other great packages. Visit the follow-up thread on RStudio Community! to continue the discussion!Resources mentioned in the episodeVideo version of recording available at shinydevseries.com/ep7Follow-up thread for the episode on RStudio CommunitydreamRs - Conseil, Expertise et Formation en data science Spécialisé en R: www.dreamrs.fr/{shinyWidgets} - Extend widgets available in Shiny: dreamrs.github.io/shinyWidgets{esquisse} - RStudio add-in to make plots with ggplot2: dreamrs.github.io/esquisse{shinylogs} - Logs for Shiny apps: dreamrs.github.io/shinylogsHow to build a JavaScript based widget (tutorial by Hermann Sontrop and Erwin Schuijtvlot): shiny.rstudio.com/articles/js-build-widget.html

In this webinar originally broadcast live in partnership with RStudio Community, Yang Tang joins Eric and Curtis to discuss his journey with learning R and shares his motivation for creating the powerful {shinyjqui} package that unlocks the power of JQuery for Shiny. Enjoy a comprehensive demonstration of the package features and visit the follow-up thread on RStudio Community! to continue the discussion!Resources mentioned in the episodeVideo version of recording available at shinydevseries.com/ep6Follow-up thread for the episode on RStudio CommunityYang's R-markdown demonstration of shinyjqui: github.com/Yang-Tang/shinydevseries/blob/master/demo.Rmd{shinyjqui} - Help Shiny sense the world around it: yang-tang.github.io/shinyjquiR Packages second edition: r-pkgs.orgAdvanced R second edition: adv-r.hadley.nz{pkgdown} - Build websites for R packages: pkgdown.r-lib.org

In this webinar originally broadcast live in partnership with RStudio Community, Nick Strayer joins Eric and Curtis to share the awesome possibilities when combining the power of javascript with Shiny! Nick shares the origins of his amazing {shinysense} package for linking many mobile device interactions with Shiny, and we go hands-on with practical demonstrations of leveraging {r2d3} to quickly prototype D3 javascript visualizations directly in R. If you would like to continue the discussion please visit the dedicated thread at the RStudio Community!.Resources mentioned in the episodeVideo version of recording available at shinydevseries.com/ep5Follow-up thread for the episode on RStudio CommunityNick's interactive javascript notebooks: observablehq.com/@nstrayer{shinysense} - Help Shiny sense the world around it: nickstrayer.me/shinysense{r2d3} - R interface to D3 visualizations: rstudio.github.io/r2d3Interactive Data Visualization for the Web (2nd edition): shop.oreilly.com/product/0636920026938.do

In this webinar originally broadcast live in partnership with RStudio Community, David Granjon joins Eric and Curtis to discuss the RinteRface suite of Shiny user interface packages! We learned the origins of the project and see how {shinydashboardPlus}, {bs4Dash}, and others bring excellent capabilities for building state-of-the-art Shiny user interfaces. If you would like to continue the discussion please visit the dedicated thread at the RStudio Community!Resources mentioned in the episodeVideo version of recording available at shinydevseries.com/ep4Follow-up thread for the episode on RStudio CommunityDavid's slides from the webinar: [https://github.com/DivadNojnarg/shinyDevSeriesEp4](github.com/DivadNojnarg/shinyDevSeriesEp4)RinteRface: rinterface.com/David's virtual patient simulator Shiny contest submission: community.rstudio.com/t/shiny-contest-submission-a-virtual-lab-for-teaching-physiology/25348

About this Episode In this episode, Eric shares insights gained from the JSM 2019 conference, including an excellent panel discussion on the use of javascript in statistics. In addition, Eric is joined by RStudio's education team members Alison Hill & Mine Cetinkaya-Rundel to discuss new ideas for teaching data science effectively, as well as how tools like R-Markdown are opening many new possibilities for both students and teachers. Episode Shownotes Why Javascript? JSM panel discussion: Karl Broman's slides (https://www.biostat.wisc.edu/~kbroman/presentations/JSM2019) Carson Sievert's slides (https://talks.cpsievert.me/20190730/#1) Data Science in a Box: datasciencebox.org (https://datasciencebox.org) RStudio Learner Personas: rstudio-education.github.io/learner-personas (https://rstudio-education.github.io/learner-personas/) Advanced R-Markdown workshop from rstudio::conf 2019: arm.rbind.io/ (https://arm.rbind.io/) learnr - Interactive tutorials in R: rstudio.github.io/learnr (https://rstudio.github.io/learnr/) Project Kickstart-R - Create a project/team website and knowledge sharing platform with R-Markdown: github.com/sourcethemes/project-kickstart-r (https://github.com/sourcethemes/project-kickstart-r) lullabyr - Generate children's songs with random words: github.com/mine-cetinkaya-rundel/lullabyr (https://github.com/mine-cetinkaya-rundel/lullabyr) Feedback Leave a comment on this episode's post (https://r-podcast.org/31) Email the show: thercast[at]gmail.com Use the R-Podcast contact page (https://r-podcast.org/contact) Episode Timestamps 00:00:00.000 Intro 00:01:22.000 JSM Memories 00:07:16.000 Why Javascript recap 00:13:04.000 Shinymeta advice 00:19:54.000 Conversation with Alison & Mine 01:01:50.000 Takeaways & Wrapup Music Credits Opening and closing themes: Training Montage by WillRock (http://ocremix.org/artist/5043/willrock) from the Return All Robots Remix Album (http://ocremix.org/events/returnallrobots/) at ocremix.org (http://ocremix.org/)

In this webinar originally broadcast live in partnership with RStudio Community, Mark Edmondson from IIH Nordic joins us to discuss how he incorporated Shiny components such as modules with {googleAnalyticsR} and his other excellent packages. We dive in to some of the technical challenges he had to overcome to provide a clean interface to many Google APIs, the value of open-source contributions to both his work and personal projects, and much more. If you would like to continue the discussion please visit the dedicated thread at the RStudio Community!ResourcesFollow-up thread for the episode on RStudio CommunityMark's GitHub and Twitter accountsMark's coding blog: code.markedmondson.me{googleAnalyticsR} - R library for working with Google Analytics data: code.markedmondson.me/googleAnalyticsR/Example of modules in {googleAnalyticsR}: code.markedmondson.me/googleAnalyticsR/articles/models.html#shiny-modules{googleAuthR}: code.markedmondson.me/googleAuthRAuthentication Shiny module in {googleAuthR}: github.com/MarkEdmondson1234/googleAuthR/blob/master/R/shiny-auth.RMark's video tutorial on creating a talking Google Analytics Shiny app: www.youtube.com/watch?v=4Ht_vEXJ4wo

ResourcesSlides used in first part of episodeEric's recent conference presentations covering Shiny: Developing Powerful Shiny Applications in an Enterprise Environment (R-Pharma 2018)Effective use of Shiny Modules (rstudio::conf 2019)Assorted Shiny apps out in the open: Ames Housing Data Explorer and GitHub repoUnconference issue explorer and GitHub repo co-authored with Sharla GelfandShiny LEGO Mosaic Creator (see Shiny contest post and GitHub repo)Visit shinydevseries.com for all previous episodesSign up for the 2019 live webinars in partnership with RStudio Community at pages.rstudio.net/shiny_dev_series.htmlPackage Highlightshinyhelper: Add markdown help files to Shiny apps by Chris Mason-Thom.

ResourcesFollow-up thread for the episode on RStudio Community{golem} - A Framework for Building Robust Shiny Apps: thinkr-open.github.io/golemThinkR - R Engineering, training, and consulting: thinkr.frBuilding Big Shiny Apps - A Workflow: thinkr-open.github.io/building-shiny-apps-workflowDon't make me think, Steve Krug: en.wikipedia.org/wiki/Don%27t_Make_Me_ThinkThe Design of Everyday things: en.wikipedia.org/wiki/The_Design_of_Everyday_ThingsRefactoring UI: refactoringui.comfreeCodeCamp: learn.freecodecamp.orgWeb Fundamentals - Google's opinionated reference for building amazing web experiences: developers.google.com/web/fundamentalsCorecursive Podcast episode 19 - Test in Production with Charity Majors: corecursive.com/019-test-in-production-with-charity-majorsVisit shinydevseries.com for all previous episodesSign up for the 2019 live webinars in partnership with RStudio Community at pages.rstudio.net/shiny_dev_series.html

ResourcesRelease notes for shiny version 1.3.2: blog.rstudio.com/2019/04/26/shiny-1-3-2/reactR package for using the React javascript framework directly with R: react-r.github.io/reactR/index.htmlIt depends: A dialog about dependencies by Jim Hester (rstudio::conf 2019)Follow-up thread for the episode on RStudio CommunityVisit shinydevseries.com for all previous episodesSign up for the 2019 live webinars in partnership with RStudio Community at pages.rstudio.net/shiny_dev_series.html

About this Episode Eric is joined by RStudio's president Tareef Kawaf and they cover a wide variety of topics including Tareef's journey to RStudio, building a robust organization structure, and how an open-core model drives RStudio's vision for the present and future. Episode Shownotes RStudio 1.2 release highlights: blog.rstudio.com/2019/04/30/rstudio-1-2-release (https://blog.rstudio.com/2019/04/30/rstudio-1-2-release/) Tareef's opening keynote at rstudio::conf 2019: Welcome and RStudio Vision (https://resources.rstudio.com/rstudio-conf-2019/opening-keynote-tareef-kawaf) Reproducible Environments: environments.rstudio.com (https://environments.rstudio.com/) RStudio Community: community.rstudio.com (https://community.rstudio.com/) RStudio Cloud (currently in alpha): rstudio.cloud (https://rstudio.cloud/) Introducing RStudio Team: blog.rstudio.com/2019/05/09/introducing-rstudio-team (https://blog.rstudio.com/2019/05/09/introducing-rstudio-team/) Feedback Leave a comment on this episode's post (https://r-podcast.org/30) Email the show: thercast[at]gmail.com Use the R-Podcast contact page (https://r-podcast.org/contact) Get in touch on Twitter: @theRcast Music Credits Opening and closing themes: Training Montage by WillRock (http://ocremix.org/artist/5043/willrock) from the Return All Robots Remix Album (http://ocremix.org/events/returnallrobots/) at ocremix.org (http://ocremix.org/)

Chicago R Unconference Unconf website: https://chirunconf.github.io/ (chirunconf.github.io/) Issue board: github.com/chirunconf/chirunconf19/issues (https://github.com/chirunconf/chirunconf19/issues) #chirunconf (Sharla Gelfand): sharla.party/posts/chirunconf/ (https://sharla.party/posts/chirunconf/) Discover and share your supeR powers (Mauro Lepore): maurolepore.github.io/confs/articles/2019chirunconfexperience.html (https://maurolepore.github.io/confs/articles/2019_chirunconf_experience.html) Joshua Goldberg's awesome unconf photo album (https://photos.google.com/share/AF1QipPJmgx7AVbz_ELCTEPz583dK1m_nwQNIVnN4yDNVN7LHCQ9olWQBw7TSCeA1QwDxA?key=MmVHT1hLQ1ZoeGJzUHhuc0VMTXo1YzFDNDFNSkd3) footrulr package repo: github.com/kanishkamisra/footrulr (https://github.com/kanishkamisra/footrulr) Fixed-Choice Design Simulation drake workflow (Ben Listyg): github.com/wlandau/drake-examples/tree/master/fcd (https://github.com/wlandau/drake-examples/tree/master/fcd) drake v7.0.0 package release notes: ropensci.org/technotes/2019/03/18/drake-700/ (https://ropensci.org/technotes/2019/03/18/drake-700/) electricShine package repo: github.com/chasemc/electricShine (https://github.com/chasemc/electricShine) 25 gt examples: frm1789.github.io/gt_examples/ (https://frm1789.github.io/gt_examples/) The Unconference Toolbox: github.com/unconf-toolbox/ (https://github.com/unconf-toolbox/) The Unconf Issue Explorer Shiny app: rpodcast.shinyapps.io/unconfissues/ (https://rpodcast.shinyapps.io/unconfissues/) Unconf Twitter bot repo: github.com/unconf-toolbox/unconf-bot (https://github.com/unconf-toolbox/unconf-bot) How to Organize an R Unconference: unconf-toolbox.github.io/unconf-guide/ (https://unconf-toolbox.github.io/unconf-guide/) Unconf attendee application repo: github.com/unconf-toolbox/unconf-apps (https://github.com/unconf-toolbox/unconf-apps) Unconf review Shiny app repo: github.com/unconf-toolbox/Shinyreviewapp (https://github.com/unconf-toolbox/Shiny_review_app) rlangtip package repo: github.com/revodavid/rlangtip (https://github.com/revodavid/rlangtip) broom package repo: github.com/tidymodels/broom (https://github.com/tidymodels/broom) workflowr package repo: github.com/jdblischak/workflowr (https://github.com/jdblischak/workflowr) Package Pick brickr 3D LEGO models and mosaics from images using R and tidyverse: github.com/ryantimpe/brickr (https://github.com/ryantimpe/brickr) My ShinyLEGO app: rpodcast.shinyapps.io/shinylego/ (https://rpodcast.shinyapps.io/shinylego/) Community News Highlights Powered by R Weekly issue 2019-11 (https://rweekly.org/#RWeekly2019-11R3.5.3,RConsortium,chirunconf) R 3.5.3 now available: blog.revolutionanalytics.com/2019/03/r-353-now-available.html (https://blog.revolutionanalytics.com/2019/03/r-353-now-available.html) R Consortium 2019 Update: www.r-consortium.org/blog/2019/03/12/2019-update-one-r-consortium-and-isc-announce-the-newest-funded-projects-for-the-r-community (https://www.r-consortium.org/blog/2019/03/12/2019-update-one-r-consortium-and-isc-announce-the-newest-funded-projects-for-the-r-community) Feedback Leave a comment on this episode's post (https://r-podcast.org/29) Email the show: thercast[at]gmail.com Use the R-Podcast contact page (https://r-podcast.org/contact) Leave a voicemail at +1-269-849-9780 Music Credits Opening and closing themes: Training Montage by WillRock (http://ocremix.org/artist/5043/willrock) from the Return All Robots Remix Album (http://ocremix.org/events/returnallrobots/) at ocremix.org (http://ocremix.org/)

Conversation with Max Kuhn Tidy models: github.com/tidymodels (https://github.com/tidymodels) parsnip - A tidy interface to models: tidymodels.github.io/parsnip/ (https://tidymodels.github.io/parsnip/) caret package: topepo.github.io/caret/index.html (http://topepo.github.io/caret/index.html) Conventions for R Modeling Packages: tidymodels.github.io/model-implementation-principles/ (https://tidymodels.github.io/model-implementation-principles/) Additional rstudio::conf gems Empowering a data team with RStudio addins (Hao Zhu): resources.rstudio.com/rstudio-conf-2019/empowering-a-data-team-with-rstudio-addins (https://resources.rstudio.com/rstudio-conf-2019/empowering-a-data-team-with-rstudio-addins) pak: A fresh approach to package installation: pak.r-lib.org/ (https://pak.r-lib.org/) Gabor Csardi's rstudio::conf presentation: resources.rstudio.com/rstudio-conf-2019/pkgman-a-fresh-approach-to-package-installation (https://resources.rstudio.com/rstudio-conf-2019/pkgman-a-fresh-approach-to-package-installation) Democratizing R with Plumber APIs (James Blair): resources.rstudio.com/rstudio-conf-2019/democratizing-r-with-plumber-apis (https://resources.rstudio.com/rstudio-conf-2019/democratizing-r-with-plumber-apis) Configuration management tools for the R admin (Kelly O'Briant): resources.rstudio.com/rstudio-conf-2019/configuration-management-tools-for-the-r-admin (https://resources.rstudio.com/rstudio-conf-2019/configuration-management-tools-for-the-r-admin) The lazy and distracted report writer - using rmarkdown and parameterised reports (Mike K Smith): resources.rstudio.com/rstudio-conf-2019/the-lazy-and-easily-distracted-report-writer-using-rmarkdown-and-parameterised-reports (https://resources.rstudio.com/rstudio-conf-2019/the-lazy-and-easily-distracted-report-writer-using-rmarkdown-and-parameterised-reports) Modernizing the Clinical Trial Analysis Pipeline with R and JavaScript: github.com/RhoInc/RStudioConf2019-ePoster/ (https://github.com/RhoInc/RStudioConf2019-ePoster/) Feedback Leave a comment on this episode's post (https://r-podcast.org/28) Email the show: thercast[at]gmail.com Use the R-Podcast contact page (https://r-podcast.org/contact) Leave a voicemail at +1-269-849-9780 Music Credits Opening and closing themes: Training Montage by WillRock (http://ocremix.org/artist/5043/willrock) from the Return All Robots Remix Album (http://ocremix.org/events/returnallrobots/) at ocremix.org (http://ocremix.org/)

In this episode I share the advice and tips I used to prepare my talk on Shiny Modules at rstudio::conf 2019. Plus I sit down with RStudio software engineer Rich Iannone to learn about his journey from atmospheric science to creating a collection of awesome R packages like DiagrammeR and gt for creating tables with a tidy syntax. As always thank you so much for listening and hope you enjoy this episode! Conversation with Rich Iannone DiagrammeR package: visualizers.co/diagrammer/ (http://visualizers.co/diagrammer/) gt package: gt.rstudio.com/ (https://gt.rstudio.com/) blastula package: github.com/rich-iannone/blastula (https://github.com/rich-iannone/blastula) Preparing for the Shiny Modules talk Karl Browman's rstudio::conf 2019 resources repo: github.com/kbroman/RStudioConf2019Slides (https://github.com/kbroman/RStudioConf2019Slides) Slides: bit.ly/modules2019 (https://bit.ly/modules2019) Recording: resources.rstudio.com/rstudio-conf-2019/effective-use-of-shiny-modules-in-application-development (https://resources.rstudio.com/rstudio-conf-2019/effective-use-of-shiny-modules-in-application-development) Communication between modules article: shiny.rstudio.com/articles/communicate-bet-modules.html (http://shiny.rstudio.com/articles/communicate-bet-modules.html) Ames Housing Explorer application: gallery.shinyapps.io/ames-explorer (https://gallery.shinyapps.io/ames-explorer) shinypod package by Ian Lyttle: github.com/ijlyttle/shinypod (https://github.com/ijlyttle/shinypod) shinysense package by Nick Strayer: github.com/nstrayer/shinysense (https://github.com/nstrayer/shinysense) Giving your first data science talk by Emily Robinson: hookedondata.org/giving-your-first-data-science-talk/ (https://hookedondata.org/giving-your-first-data-science-talk/) The Unreasonable Effectiveness of Public Work (David Robinson): slides (https://www.dropbox.com/s/jk7216yr30ztpdp/DavidRobinson-RStudio-2019-old.pdf?dl=0) and recording (https://resources.rstudio.com/rstudio-conf-2019/the-unreasonable-effectiveness-of-public-work) Additional resources Tips on designing hex stickers for R packages (Hao Zhu): zhuhao.org/post/tips-on-designing-a-hex-sticker-for-rstats-packages/ (https://zhuhao.org/post/tips-on-designing-a-hex-sticker-for-rstats-packages/) Feedback Leave a comment on this episode's post (https://r-podcast.org/27) Email the show: thercast[at]gmail.com Use the R-Podcast contact page (https://r-podcast.org/contact) Leave a voicemail at +1-269-849-9780 Music Credits Opening and closing themes: Training Montage by WillRock (http://ocremix.org/artist/5043/willrock) from the Return All Robots Remix Album (http://ocremix.org/events/returnallrobots/) at ocremix.org (http://ocremix.org/)

Another spectacular rstudio::conf is in the books and the R-Podcast has tons of insights to share! We kick off our coverage with a three-podcast crossover as I am joined by Credibly Curious co-host Nick Tierny and Not So Standard Deviations co-host Hilary Parker! We discuss our impressions of the conference and where we'd like to see R go in 2019. Plus I share how my journey to the Advanced R-Markdown workshop is a testament to the welcoming and openness that the R community offers. This is just the beginning of our coverage and I hope you enjoy this episode! Conversation with Hilary Parker and Nick Tierney Credibly Curious podcast: soundcloud.com/crediblycurious (https://soundcloud.com/crediblycurious) Not So Standard Deviations podcast: nssdeviations.com (http://nssdeviations.com/) Apache Arrow: arrow.apache.org (https://arrow.apache.org/) Tidy Evaluation online book: tidyeval.tidyverse.org (https://tidyeval.tidyverse.org/) Tidy models family of packages: github.com/tidymodels (https://github.com/tidymodels) The magick package by Jeroen Ooms: github.com/ropensci/magick (https://github.com/ropensci/magick) pagedown package (paginate HTML output of R Markdown) by Yihui Xie: github.com/rstudio/pagedown (https://github.com/rstudio/pagedown) Advanced R Markdown workshop highlights Course website: arm.rbind.io (https://arm.rbind.io/) (powered by blogdown (https://bookdown.org/yihui/blogdown/)!) Course GitHub repository: github.com/rstudio-education/arm-workshop-rsc2019 (https://github.com/rstudio-education/arm-workshop-rsc2019) My slides on using the officer package to create PowerPoint slides: rpodcast.github.io/officer-advrmarkdown (https://rpodcast.github.io/officer-advrmarkdown) The officer package documenation: davidgohel.github.io/officer (https://davidgohel.github.io/officer/) MegaMan slide generator Shiny app: rpodcast.shinyapps.io/megaman (https://rpodcast.shinyapps.io/megaman/) GitHub repo for slides and app: github.com/rpodcast/officer-advrmarkdown (https://github.com/rpodcast/officer-advrmarkdown) Feedback Leave a comment on this episode's post: r-podcast.org/26 (https://r-podcast.org/26) Email the show: thercast[at]gmail.com Use the R-Podcast contact page: r-podcast.org/contact (https://r-podcast.org/contact) Leave a voicemail at +1-269-849-9780 Music Credits Opening and closing themes: Training Montage by WillRock (http://ocremix.org/artist/5043/willrock) from the Return All Robots Remix Album (http://ocremix.org/events/returnallrobots/) at ocremix.org (http://ocremix.org/)

Conversation with Ian Lyttle Twitter: @ijlyttle (https://twitter.com/ijlyttle) | Github: github.com/ijlyttle (https://github.com/ijlyttle/) Ian's presentation at rstudio::conf 2018 recording: www.rstudio.com/resources/videos/how-i-learned-to-stop-worrying-and-love-the-firewall/ (https://www.rstudio.com/resources/videos/how-i-learned-to-stop-worrying-and-love-the-firewall/) bsplus package: ijlyttle.github.io/bsplus/ (https://ijlyttle.github.io/bsplus) shinychord package: github.com/ijlyttle/shinychord (https://github.com/ijlyttle/shinychord) ghenter package: github.com/ijlyttle/ghentr (https://github.com/ijlyttle/ghentr) Rstudio::conf 2018 takeaways and insights Advanced R 2nd Edition new chapters: Expressions: adv-r.hadley.nz/expressions.html (https://adv-r.hadley.nz/expressions.html) Quasiquotation: adv-r.hadley.nz/expressions.html (https://adv-r.hadley.nz/expressions.html) Evaluation: adv-r.hadley.nz/evaluation.html (https://adv-r.hadley.nz/evaluation.html) Translating R Code: adv-r.hadley.nz/translation.html (https://adv-r.hadley.nz/translation.html) lobstr package: github.com/r-lib/lobstr (https://github.com/r-lib/lobstr) Recordings from all sessions on RStudio site: rstudio.com/resources/webinars/#rstudioconf2018 (https://www.rstudio.com/resources/webinars/#rstudioconf2018) Collection of presentation links: github.com/simecek/RStudioConf2018Slides/ (https://github.com/simecek/RStudioConf2018Slides/) Presentations by RStudio staff: github.com/rstudio/rstudio-conf/tree/master/2018/ (https://github.com/rstudio/rstudio-conf/tree/master/2018/) rstudio::conf 2018 summary (Paul van der Laken): paulvanderlaken.com/2018/02/08/rstudioconf-2018-summary (https://paulvanderlaken.com/2018/02/08/rstudioconf-2018-summary/) Rewriting the R organism at rstudio::conf 2018 (John David Smith): goo.gl/rGfqip (https://goo.gl/rGfqip) David Miller's slides on rstudio::conf 2018: github.com/dill/rstudioconf2018-summary/blob/master/talk.Rmd (https://github.com/dill/rstudioconf2018-summary/blob/master/talk.Rmd) Recap of rstudio::conf 2018 (Colby Ford): www.blue-granite.com/blog/rstudio-conference-2018-recap (https://www.blue-granite.com/blog/rstudio-conference-2018-recap) Highlights from rstudio::conf 2018 (Methods Consultants blog): blog.methodsconsultants.com/posts/highlights-from-rstudio-conf-2018/ (https://blog.methodsconsultants.com/posts/highlights-from-rstudio-conf-2018/) lobstr package: github.com/r-lib/lobstr (https://github.com/r-lib/lobstr) Listener feedback A completely subjective ranking of data science podcasts: tonyelhabr.rbind.io/posts/data-science-podcasts (https://tonyelhabr.rbind.io/posts/data-science-podcasts/) Feedback Leave a comment on this episode's post (https://r-podcast.org/25) Email the show: thercast[at]gmail.com Use the R-Podcast contact page (https://r-podcast.org/contact) Leave a voicemail at +1-269-849-9780 Music Credits Opening and closing themes: Training Montage by WillRock (http://ocremix.org/artist/5043/willrock) from the Return All Robots Remix Album (http://ocremix.org/events/returnallrobots/) at ocremix.org (http://ocremix.org/)

Our coverage of rstudio::conf 2018 continues! In this episode I reconnect with the first-ever guest of the R-Podcast, RStudio software engineer Yihui Xie. In our conversation you'll hear about Yihui's journey since joining RStudio, his vision of how blogdown and bookdown could lead to a streamlined publishing worflow, and much more. I hope you enjoy this episode! Conversation with Yihui Xie Yihui's supplemental post: yihui.name/en/2018/02/r-podcast/ (https://yihui.name/en/2018/02/r-podcast/) Rbind project: support.rbind.io/about/ (https://support.rbind.io/about/) The New and Improved R-Podcast Site: support.rbind.io/2017/04/27/r-podcast-website/ (https://support.rbind.io/2017/04/27/r-podcast-website/) REWORK: basecamp.com/books/rework (https://basecamp.com/books/rework) blogdown: Creating websites with R Markdown (available online and print): bookdown.org/yihui/blogdown/ (https://bookdown.org/yihui/blogdown/) Keeping up with blogdown (Mara Averick): maraaverick.rbind.io/2017/10/keeping-up-with-blogdown/ (https://maraaverick.rbind.io/2017/10/keeping-up-with-blogdown/) Feedback Leave a comment on this episode's post ({{}}) Email the show: thercast[at]gmail.com Use the R-Podcast contact page ({{}}) Leave a voicemail at +1-269-849-9780 Music Credits Opening and closing themes: Training Montage by WillRock (http://ocremix.org/artist/5043/willrock) from the Return All Robots Remix Album (http://ocremix.org/events/returnallrobots/) at ocremix.org (http://ocremix.org/)

The R-Podcast's coverage of rstudio::conf 2018 begins! I have the pleasure of speaking with Romain Francois and Thomas Lin Pedersen. You'll hear Romain's thoughts on the growth of Rcpp and the project that helped him become closer to the R community. We also learn about Thomas' journey to enhancing ggplot2 and the new packages he's developed covering network analyses and dynamic APIs from R. I hope you enjoy episode 23 of the R-Podcast!

In this episode of the R-Podcast I have a conversation with my colleague Will Landau about his new R package drake (https://cran.rstudio.com/web/packages/drake/) that provides a powerful build system for analysis pipelines. In addition we have a fun R community roundup, listener feedback, and a couple of package picks to give you a gentle nod and a fun way to explore interpolation. If you have ideas for topics, questions, or other types of feedback, get in touch with me by heading over to the R-Podcast site at www.r-podcast.org (https://www.r-podcast.org), sending a note to thercast[at]gmail.com, or contacting me at @thercast on Twitter. As always thanks for tuning in and I hope you enjoy episode 22 of the R-Podcast!

The R-Podcast concludes its coverage of rstudio::conf by chatting with R Foundation member and Rcpp author Dirk Eddelbuettel! We cover a variety of topics including the state of Rcpp, how the integration of Rcpp in RStudio came about, and his perspective on Linux in the R community. Plus a new batch of listener feedback and a package pick that gives your shiny apps and rmarkdown reports a little more bootstrap polish. Enjoy episode 21 of the R-Podcast!

In episode 20 I'm happy to bring you more great interviews with members of RStudio from rstudio::conf! I had the pleasure of chatting with software engineer Javier Luraschi to discuss Apache Spark and the new sparklyr package that allows R users to connect directly to a Spark cluster for high-performance data analyses. In addition you will hear from RStudio's master instructor Garret Grolemund to get his recommendations for teaching R and the highly-acclaimed R for Data Science book. All of this plus a package pick that could enable me to use R in my podcast workflow in episode 20 of the R-Podcast!

The R-Podcast has landed in Orlando for the first ever rstudio::conf! Our coverage begins with two excellent interviews: First I talk with Bárbara Borges Ribeiro, software engineer at RStudio about her journey to using R and her advice for developing Shiny apps. Then Dean Attali makes his return to the show and we discuss R's role in his graduate research and his experiences as a Shiny consultant. All of this plus a package pick that can give Shiny app users a helping hand. I hope you enjoy episode 19 of the R-Podcast!

The R-Podcast concludes its series on the Shiny Developer Conference with a jam-packed episode featuring two interviews with members of the RStudio team! In part one I have a panel discussion with JJ Allaire, Jeff Allen, and Hadley Wickham to get their impressions of the conference and some exciting new features in the latest version of the RStudio IDE. In part two I have an extended conversation with Joe Cheng to discuss the origins of Shiny, how the conference came together, and ideas for future enhancements of shiny. All of this and more on episode 18 of the R-Podcast!

The R-Podcast continues its series on Shiny and the first-ever Shiny Developer Conference by catching up with Vincent Nijs, associate professor of marketing at UC San Diego and one of the earliest adopters of Shiny. Some of the topics we cover include his journey to using R, his motivation and process for developing the Radiant Shiny application used by his students to perform business analytics, and how he would like to involve the community to add new capabilities to Radiant. I hope you enjoy this episode and thanks for listening!

Direct from the first-ever Shiny Developer conference, here is episode 16 of the R-Podcast! In this episode I sit down with Dean Attali for an engaging conversation about his journey to using R, his motivation for creating the innovative shinyjs package, and his perspective on teaching others about R through his support of the innovative and highly-praised Stats 545 course at UBC. In addition you'll hear about how his previous work prepared him well for using R, his collaboration with the RStudio team, and much more. I hope you enjoy this episode and thanks for listening!

Just in time for the new year is a new episode of the R-Podcast! I give a brief introduction to the Shiny package for creating web applications using R code, provide some of my tips and tricks I have learned (sometimes the hard way) when creating applications, and point to excellent resources and example apps in the community that show the immense potential at your fingertips. You will see that r-podcast.org has gotten a major overhaul, and as a consequence the RSS feeds have changed slightly. Be sure to check out the Subscribe page for the updated feeds, but all of the previous episodes have been migrated successfully. As always you can provide your feedback in multiple ways: - New Feature: Provide a comment on this episode post directly (powered by the Disqus commenting system) - Email the show at thercast[at]gmail.com - Use the new Contact Form directly on the site. - Leave a voicemail at at +1-269-849-9780 Happy New Year and I hope you enjoy the episode!

The R-Podcast is back up and running! In this episode I discuss some useful resources and helpful tips/extensions that have greatly enhanced my work flow in creating reproducible analysis documents via R-Markdown. I also highlight some exciting new endeavors in the R community as well as provide my take on two key events that further illustrate the rapidly growing use of R across many industries. A big thank you to all who expressed their support during the extended hiatus, and please don't hesitate to provide your feedback and suggestions for future episodes. I hope you enjoy this episode!

It's an episode of firsts on the R-Podcast! In this episode recorded on location I had the honor and privilege of interviewing Yihui Xie, author of many innovative packages such as knitr and animation. Some of the topics we discussed include: - Yihui's motivation for creating knitr and some key new features - How markdown plays a key role in making reproducible research more accessible - An innovative approach for publishing and maintaining reproducible statistical results online And much more on this “lucky” episode 13 of the R-Podcast!

This is not an April Fool's joke ... The R-Podcast is back once again! In this episode, I discuss the concept of version control and how you can get started with using the Git VCS right now with your R projects. Also I discuss a big batch of listener feedback, and highlight a couple of great visualization applications from the community using ggplot2. All of that and more on episode 12 of the R-Podcast!

Season 2 of the R-Podcast is up and running! This episode begins a multi-part series on reproducible analysis using R. In this episode I discuss the usage of Sweave and LaTeX for producing reproducible reports, an introduction to the capabilities of the knitr package (more episodes will be coming dedicated to this package), and my motivation for adapting reproducible analysis techniques and tools into my workflow. In our listener feedback segment I discuss a new means of providing feedback to the R-Podcast using our new sub-reddit page and introduce new segments highlighting interesting stories around the R community and useful packages. This promises to be an exciting season of the R-Podcast, and I hope you enjoy this episode!

I'm happy to present episode 10 of the R-Podcast! Season 1 of the R-Podcast concludes with part 2 of my series on data munging, in which I discuss issues surrounding importing data sets contained in HTML tables. I share how I used the XML and RCurl packages to validate and import data from hockey-reference.com for storage into a MySQL database. Our listener feedback segment contains another installment on the Pitfalls of R contributed by listener Frans. I want to thank everyone who has provided such positive feedback throughout the season, and I'm looking forward to providing some exciting new content for season 2. I hope you enjoy the episode and check out our new contact page if you would like to provide any feedback. Thanks for listening!

It’s great to be back with a new episode after an eventful break! This episode begins a series on my adventures in data munging, a.k.a data processing. I discuss three issues that demonstrate the flexibility and versatility R brings for recoding messy values, important inconsistent data files, and pinpointing problematic observations and variables. We also have an extended listener feedback segment with an audio installment of the “pitfalls” of R contributed by listener Frans. I hope you enjoy this episode and keep passing along your feedback to theRcast(at)gmail.com and stop by the forums as well!

I'm happy to present this jam-packed episode of the R-Podcast dedicated to using the ggplot2 package for visualization. This episode will have a companion screencast released in the next few days. I use data from the Hockey Summary Project to demonstrate how to create a series of boxplots of NHL regular season attendance for each team. The R code used in this episode will be available via GitHub. I also extend my thanks to the Going Linux podcast for plugging the R-Podcast.

Hello everybody, I am finally back with a new episode! In this episode: Hardware issues, major update to RStudio, new forums, and discussion on managing your workflow for projects. I discuss useful functions for executing R scripts and saving/loading R objects for future sessions, and summarize different solutions for organizing R code based on task and via the ProjectTemplate package, along with the importance of version control.

In this episode: Listener feedback and importing data from external sources into R. We dive into the basics of importing delimited text files using read.table and its varients. We also discuss recommendations for importing MS Excel spreadsheet files, relational databases such as MySQL, data from HTML tables, and files produced by other statistical computing packages.

After a brief delay here's episode 5 of the R-Podcast. In this episode: R 2.15.0 released, listener feedback, and discussion on basic package management. I discuss helpful resources for finding packages, installation procedures, and how to determine what packages are installed in your R system, among other considerations.

In this episode: Site updates, additional screencasts about R from other sites, listener feedback, and discussion on the fundamental data structures for R: vectors, matrices, lists, and data frames. The R code discussed in this episode is available in our GitHub repository, see the show notes for details.

In this episode: New versions of R and ggplot2 available, listener feedback, and an interactive session with R. The R code discussed in this episode will be available in our GitHub repository, see the show notes for details.

In this episode: A couple of site updates, our first listener feedback, an overview of installing R on each major platform, and an overview of R IDEs and helpful resources for getting started with R.

Here is the inaugural episode of the R-Podcast! In this episode, I take a few minutes to introduce myself and to explain the main goals of this podcast. I also define what R is and give an overview of R's history of development and features that distinguish it from other statistical software.