Shiny Developer Series

Shiny Developer Series

By Eric NantzTechnologyEducationHow To
Download on the App Store

Shiny Developer Series episodes

  • Episode 22: A fresh coat of Shiny theming with Carson Sievert
    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
    1 hr 20 min
  • Episode 34: Enriching the Next Generation of R-Core Development

    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
    • Collaboration Campfires: contributor.r-project.org/events/collaboration-campfires
    • R Contribution Working Group: contributor.r-project.org/working-group
    • R Development Guide: contributor.r-project.org/rdevguide/
    • Digital Infrastructure Icubator: incubator.codeforscience.org/cohort
      • Feedback
      • Email the show: thercast[at]gmail.com
      • Use the R-Podcast contact page: https://r-podcast.org/contact
        • 42 min
      • Episode 21: Shiny App Stories with Nick Strayer
        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 
        1 hr 8 min
      • Episode 20: Outstanding User Interfaces with David Granjon
        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
        58 min
      • Episode 19: Climbing the Ladder of Shiny Mastery with Hadley Wickham
        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
        45 min
      • Episode 18: Tanya Cashorali
        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
        59 min
      • Episode 17: Dean Attali
        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)
        1 hr 8 min
      • Episode 16: Jiena Gu McLellan
        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
        1 hr 8 min
      • Episode 14: Shining a Light on learnr (Barret Schloerke Part 3)
        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
        21 min

      About Shiny Developer Series

      From the publisher's feed

      The goals of the Shiny Developer Series are to showcase the innovative applications and packages in the ever-growing Shiny ecosystem, as well as the brilliant developers behind them! This is the…