Shiny Developer Series

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 episode Interactive web-based data visualization with R, plotly, and shiny bslib: Tools for theming shiny and rmarkdown from R via Bootstrap (3 or 4) Sass rstudio.github.io/bslib thematic: Simplified theming of ggplot2, lattice, and base R graphics rstudio.github.io/thematic shinymeta: Record and expose Shiny app logic using metaprogramming rstudio.github.io/shinymeta flexdashboard: Easy interactive dashboards for R pkgs.rstudio.com/flexdashboard Episode Timestamps 00: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

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 episode Kent's packages and examples used in the live coding demonstrations: vue.js for R - github.com/vue-r/vueR vue-cli-r - github.com/timelyportfolio/vue-cli-r vite vue3 and Shiny - github.com/timelyportfolio/vite-vue-r valtio vanilla with utils as standalone using browserify - github.com/timelyportfolio/valtio_standalone Kent's listviewer HTML widget for viewing lists: cran.r-project.org/package=listviewer Linking vue to crosstalk - github.com/vue-r/vueR/issues/12 Episode Timestamps 00: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

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 episode Movie Vue R Shiny App: friss.shinyapps.io/shiny-vue-r Contest Submission Post on RStudio Community App GitHub repository: github.com/FrissAnalytics/shiny-vue-r Discussion slides available at this link Vue.js - Progressive JavaScript framework: vuejs.org Vuetify - Material design framework for Vue: vuetifyjs.com HTML templates article: shiny.rstudio.com/articles/templates.html Material design icons: materialdesignicons.com http-vue-loader - load .vue files from your HTML/JS: github.com/FranckFreiburger/http-vue-loader Vuex getting started guide: vuex.vuejs.org/guide Vue Router - The official router for Vue.js: router.vuejs.org UI component for Globe Data Visualization using ThreeJS/WebGL: globe.gl Lodash - A modern JavaScript utility library delivering modularity, performance & extras: lodash.com d3.js - Data-Driven Documents: d3js,org Mitt - Tiny 200b functional event emitter / pubsub: github.com/developit/mitt Overlay Scrollbars - A javascript scrollbar plugin which hides native scrollbars, provides custom styleable overlay scrollbars and keeps the native functionality and feeling: kingsora.github.io/OverlayScrollbars Kent's listviewer HTML widget for viewing lists: cran.r-project.org/package=listviewer plumber - Turn your R code into a web API: www.rplumber.io Episode Timestamps 00: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 episode Shiny Modules: shiny.rstudio.com/articles/modules.html Overview of the {sass} package: rstudio.github.io/sass/articles/sass.html {waiter} Loading screens for Shiny: github.com/JohnCoene/waiter Tooltips with {shinyBS}: ebailey78.github.io/shinyBS/docs/Tooltips_and_Popovers.html Interactive 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/reactable Clean Code: A Handbook of Agile Software Craftsmanship Episode Timestamps 00: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/contact If 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 survey Media 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-loaded VDO Ninja: https://vdo.ninja StreamElements: https://streamelements.com ShotCut: https://shotcut.org/ Pop@_OS by System76: https://pop.system76.com/ Ubuntu: https://ubuntu.com/

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 episode COVID-19 At-Home Test Spotter (App) - ketchbrookanalytics.shinyapps.io/covid_test_spotter COVID-19 At-Home Test Spotter (Code) - github.com/ketchbrookanalytics/covid_test_spotter App blog post - www.ketchbrookanalytics.com/post/ketchbrook-analytics-launches-website-to-help-connecticut-residents-find-covid-19-test-kits Olivia 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.cnn R Packages by Hadley Wickham and Jenny Bryan - r-pkgs.org {googleWay} Shiny vignette - symbolixau.github.io/googleway/articles/googleway-vignette.html#shiny Episode Timestamps 00: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/contact If 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 survey Media 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-loaded VDO Ninja: https://vdo.ninja StreamElements: https://streamelements.com ShotCut: https://shotcut.org/ Pop@_OS by System76: https://pop.system76.com/ Ubuntu: https://ubuntu.com/

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 episode David on GitHub: https://github.com/DavidBarke myPaintings - Painting Trading Platform Shiny app: https://mypaintings.davidbarke.com GitHub Repo: https://github.com/DavidBarke/mypaintings {shinyjs} {bs4Dash} Episode Timestamps 00: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

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 episode Pedro's website with links to posts and webinnars: https://www.pedrocsilva.com Appsilon: https://appsilon.com Shiny Decisions repo: https://github.com/pedrocoutinhosilva/shiny.decisions Deployed Shiny Decisions app: https://sparktuga.shinyapps.io/ShinyDecisions R6 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/lintr Mastering Shiny: https://mastering-shiny.org/ Pedro's recommended Chrome extensions for development: Resolution Test: Test web pages in different screen resolutions ColorPick Eyedropper: A zoomed eyedropper & color chooser tool Screenshotting: Web page screen capture CSS Peeper: Extract CSS and build beautiful styleguides Episode Timestamps 00: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

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 episode Engineering Production-Grade Shiny Apps W3.CSS Templates {golem}: Opinionated framework for building production-grade Shiny applications {brochure} : Natively multipage Shiny apps golemexamples: Gathering in one place some {golem} examples Episode Timestamps 00: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

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 episode COVID-19 At-Home Test Spotter (App) - ketchbrookanalytics.shinyapps.io/covid_test_spotter COVID-19 At-Home Test Spotter (Code) - github.com/ketchbrookanalytics/covid_test_spotter App 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/reactable Episode Timestamps 00: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/contact If 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 survey Media 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-loaded VDO Ninja: https://vdo.ninja StreamElements: https://streamelements.com ShotCut: https://shotcut.org/ Pop@_OS by System76: https://pop.system76.com/ Ubuntu: https://ubuntu.com/

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 episode FairSplit App - voronoys.shinyapps.io/fairsplit FairSplit Code - github.com/voronoys/fairsplit Contest submission post - community.rstudio.com/t/fairsplit-shiny-contest-submission/104752 Episode Timestamps 00: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

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 episode coronaSweeper App - katerobsau.shinyapps.io/Corona_Sweeper coronaSweeper Code - github.com/katerobsau/coronaSweeper Kate's contest submission post: community.rstudio.com/t/coronasweeper-shiny-contest-submission/104767 Follow Kate on Twitter - @katerobsau Episode Timestamps 00: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

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 episode Shiny 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 object getCurrentOutputInfo Data visualization innovators Nick follows: Nadieh Bremer (@NadiehBremer), Shirley Wu (@sxywu), Amelia Wattenberger (@Wattenberger). Episode Timestamps 00: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 episode Outstanding User Interfaces with Shiny (online) {bs4Dash}: Bootstrap 4 shinydashboard using AdminLTE3 Episode Timestamps 0: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 episode Mastering Shiny (online) Advanced R: Second Edition R for Data Science Episode Timestamps 0: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 episode TCB Analytics: tcbanalytics.com About TCB Analytics: tcbanalytics.com/about Episode Timestamps 0: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 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 episode Jiena's website: www.jienamclellan.com DT Editor module demonstration app: appforiarteam.shinyapps.io/DT_editor_shiny_module DT 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/noteMD Demo 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/flashCard Demo app for flashcards teaching Python syntax: appforiarteam.shinyapps.io/flashCard_demo Jiena'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/forestry Episode Timestamps 0: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

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 episode Help sponsor Dean's move to full-time open-source development via GitHub Sponsors: github.com/sponsors/daattali Dean's website: deanattali.com Attali 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/reactR Clean Code - A Handbook of Agile Software Craftsmanship: www.oreilly.com/library/view/clean-code-a/9780136083238 Episode Timestamps 0: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)

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 episode TidyBlocks (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 Timestamps 0: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

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 episode learnr The 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/primers Allison Horst Post: https://education.rstudio.com/blog/2020/05/learnr-for-remote/ Demo: https://allisonhorst.shinyapps.io/missingexplorer/ Source: https://github.com/allisonhorst/explore-na Sortable Site: https://rstudio.github.io/sortable/ Demo: https://rstudio.github.io/sortable/tutorials/tutorial_question_rank.html Episode Timestamps 0: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 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 episode plumber 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 data Ex: HTML forms, multipart forms, csv, tsv, json, yaml, feather and rds. Like serializers, register new POST body parsers Site: https://www.rplumber.io/reference/parsers.html More Serializers! Serialize outgoing route data Ex: plain text, json, yaml, csv, tsv, rds, feather NEW - Register image serializers: svg, tiff, bmp, pdf. (Pre existing: png, jpeg) Site: https://www.rplumber.io/reference/serializers.html NEW - Download return values as attachments! Site: https://www.rplumber.io/reference/as_attachment.html Demo: 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 API Demo: 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-apis Practical 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 Timestamps 0: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