Shiny Team

dplyr

dplyr: A grammar of data manipulation

ggplot2

An implementation of the Grammar of Graphics in R

gt

Easily generate information-rich, publication-quality tables from R

plumber

Turn your R code into a web API

rmarkdown

Dynamic Documents for R

shinychat

Chat UI component for Shiny

usethis

Set up commonly used components

air

R formatter and language server

rstudio

RStudio is an integrated development environment (IDE) for R

ellmer

Call LLM APIs from R

querychat

Chat with your data in R and Python

chatlas

Your friendly guide to building LLM chat apps in Python with less effort and more clarity

leaflet

R Interface to Leaflet Maps

plumber2

Easy and Powerful Webservers in R

R6

Encapsulated object-oriented programming for R

rlang

Low-level API for programming with R

rstudio-conf

Materials for rstudio::conf

testthat

An R to make testing

crosstalk

Inter-htmlwidget communication for R (with and without Shiny)

vetiver-r

Version, share, deploy, and monitor models

shinylive

Run Shiny on Python and R (compiled to wasm) in the browser

bslib

Tools for theming Shiny and R Markdown via Bootstrap 3, 4, or 5

py-shiny-templates

Templates for Shiny for Python

r-shinylive

shinytest2

shinydashboard

Shiny Dashboarding framework

rsconnect

Publish Shiny Applications, RMarkdown Documents, Jupyter Notebooks, Plumber APIs, and more

thematic

Theme ggplot2, lattice, and base graphics based on a few simple settings

fontawesome

Easily insert FontAwesome icons into R Markdown docs and Shiny apps

httpuv

HTTP and WebSocket server package for R

flexdashboard

Easy interactive dashboards for R

learnr

Interactive Tutorials with R Markdown

profvis

Visualize R profiling data

htmltools

Tools for HTML generation and output

reactlog

Shiny Reactivity Visualizer

shinyloadtest

Tools for load testing Shiny applications

connectapi

An R package for interacting with the Posit Connect server API

chromote

Chrome Remote Interface for R

webshot2

Take screenshots of web pages from R

shinymeta

Record and expose Shiny app logic using metaprogramming

gradethis

Tools for teachers to use with learnr

lintr

Static Code Analysis for R

cheatsheets

Posit Cheat Sheets - Can also be found at https://posit.co/resources/cheatsheets/

actions

GitHub Actions for the R community

cachem

Key-value caches for R

evaluate

A version of eval for R that returns more information about what happened

fastmap

Fast map implementation for R

hex-stickers

RStudio hex stickers

later

Schedule an R function or formula to run after a specified period of time

packrat

Packrat is a dependency management system for R

pool

Object Pooling in R

promises

A promise library for R

py-shinylive

Python package for deploying Shinylive applications

py-shinyswatch

Bootswatch themes for py-shiny

py-shinywidgets

Render ipywidgets inside a PyShiny app

r-system-requirements

System requirements for R packages

r2d3

R Interface to D3 Visualizations

rstudio-conf-2022-program

rstudio::conf(2022, "program")

sass

Sass compiler package for R

scales

Tools for ggplot2 scales

Shiny

Easy interactive web applications with R

Shiny for Python

Easy interactive web applications with Python

shiny-examples

shinyapps-package-dependencies

Collection of bash scripts that install R package system dependencies

shinycoreci

Application-level automated tests for Shiny

shinycoreci-apps

SUPERSEDED - Apps for Shiny continuous integration testing

shinytest

Automated testing for shiny apps

shinyvalidate

Input validation package for the Shiny web framework

skills

A collection of Claude Skills from Posit

sortable

R htmlwidget for Sortable.js

swagger

Swagger is a collection of HTML, Javascript, and CSS assets that dynamically generate beautiful documentation from a Swagger-compliant API

tidytemplate

A pkgdown template for core tidyverse packages

webdriver

WebDriver client in R

websocket

WebSocket client for R

Quarto

Open-source scientific and technical publishing system built on Pandoc

webinars

Code and slides for RStudio webinars

dbplyr

Database (DBI) backend for dplyr

shinytableau

Extend Tableau dashboards using Shiny

shiny-assistant

Chat assistant for Shiny

DT

R Interface to the jQuery Plug-in DataTables

bookdown

Authoring Books and Technical Documents with R Markdown

shinythemes

Themes for Shiny

ggsql

A experimental SQL extension for declarative data visualisation based on the Grammar of Graphics

shinymodels

vdiffr

Visual regression testing and graphical diffing with testthat

ymlthis

write YAML for R Markdown, bookdown, blogdown, and more

education.rstudio.com

open-source-website

Posit Open Source Website

shiny-vscode

Shiny VS Code Extension

supported-by-posit

Add a "Supported by Posit" badge to a package website

devtools

Tools to make an R developer's life easier

positron

Positron, a next-generation data science IDE

stringr

A fresh approach to string manipulation in R

pkgdown

Generate static html documentation for an R package

shinyapps

Deploy Shiny applications to ShinyApps

mirai

Minimalist Async Evaluation Framework for R

nanonext

R binding for NNG (Nanomsg Next Gen)

httr2

Make HTTP requests and process their responses. A modern reimagining of httr

shiny-server

Host Shiny applications over the web

googlesheets4

Google Spreadsheets R API (reboot of the googlesheets package)

rsconnect-python

The Posit Connect command-line interface

blastula

Easily send great-looking HTML email messages from R

bigrquery

An interface to Google's BigQuery from R

plumbertableau

R package for creating Plumber APIs that function as Tableau Analytics Extensions

pagedown

Paginate the HTML Output of R Markdown with CSS for Print

cranwhales

addinexamples

An R package showcasing how RStudio addins can be registered and used

gargle

Infrastructure for calling Google APIs from R, including auth

ggbot2

gmailr

Access the Gmail RESTful API from R

googledrive

Google Drive R API

leaflet.mapboxgl

Extends the R Leaflet package with a Mapbox GL JS plugin to allow easy drawing of vector tile layers

markdown

The first generation of Markdown rendering for R (born in 2012), based on commonmark. Note that this package is markdown, not *rmarkdown*

miniUI

pins-r

Pin, discover, and share resources

R-Websockets

HTML 5 Websockets implementation for R

shiny-incubator

Examples and ideas that don't belong in the core Shiny package and aren't officially supported

ShinyDeveloperConference

Materials collected from the First Shiny Developer Conference Palo Alto, CA January 30-31 2016

Great Tables

Make awesome display tables using Python

plotnine

A Grammar of Graphics for Python

pointblank

Data validation toolkit for assessing and monitoring data quality

pins-python

vetiver-python

Version, share, deploy, and monitor models

shinyuieditor

A GUI for laying out a Shiny application that generates clean and human-readable UI code

gridlayout

Package for setting up CSS grid layouts in Shiny apps or RMarkdown documents

lobstr

Understanding complex R objects with tools similar to str()

lubridate

Make working with dates in R just that little bit easier

mcptools

Model Context Protocol For R

fs

Provide cross platform file operations based on libuv

callr

Call R from R

diffviewer

HTML widget to visually compare files

gtable

The layout packages that powers ggplot2

memoise

Easy memoisation for R

pkgload

Simulate installing and loading a package

processx

Execute and Control Subprocesses from R

shiny-gallery

Code and other documentation for apps in the Shiny Gallery

R/Pharma 2025

R/Pharma is a scientifically & industry oriented online conference focused on the use of R in the development of pharmaceuticals

Polars: The Blazing Fast Python Framework for Modern Clinical Trial Data Exploration

Polars: The Blazing Fast Python Framework for Modern Clinical Trial Data Exploration - Michael Chow, Jeroen Janssens Abstract: Clinical trials generate complex and standards driven datasets that can slow down traditional data processing tools. This workshop introduces Polars, a cutting-edge Python DataFrame library engineered with a high-performance backend and the Apache Arrow columnar format for blazingly fast data manipulation. Attendees will learn how Polars lays the foundation for the pharmaverse-py, streamlining the data clinical workflow from database querying and complex data wrangling to the potential task of prepping data for regulatory Tables, Figures, and Listings (TFLs). Discover the 'delightful' Polars API and how its speed dramatically accelerates both exploratory and regid data tasks in pharmaceutical drug development. The workshop is led by Michael Chow, a Python developer at Posit who is a key contributor to open-source data tools, notably helping to launch the data presentation library Great Tables, and focusing on bringing efficient data analysis patterns to Python. Resources mentioned in the workshop: * Polars documentation: https://docs.pola.rs/ * Plotnine documentation: https://plotnine.org/ * pyreadstat: https://github.com/Roche/pyreadstat * Examples of Great Tables and Pharma TFLs: https://github.com/machow/examples-great-tables-pharma * UV Python package manager: https://docs.astral.sh/uv

Jeroen Janssens, Michael Chow

What even is dbt? An Analytics engineer explains | Laurie Merrell & Michael Chow | Data Science Lab

The Data Science Lab is a live weekly call. Register at pos.it/dslab! Discord invites go out each week on lives calls. We'd love to have you! The Lab is an open, messy space for learning and asking questions. Think of it like pair coding with a friend or two. Learn something new, and share what you know to help others grow. On this call, Libby Heeren is joined by Jarvis Innovations Lead Analytics Engineer Laurie Merrell and Posit Principal Software Engineer Michael Chow as they walk us through a beginner dbt project and let us ask as many questions as we like (and we do, we ask all the questions, including, WHAT EVEN IS dbt??). This is a super friendly, MESSY, collaborative, and curious peek at dbt. It's is a tool that's often mysterious to data scientists and it's a big enough framework that it can feel tough to get started with. Walking through the basics makes it way easier to get into! Hosting crew from Posit: Libby Heeren, Isabella Velasquez Laurie's LinkedIn: https://www.linkedin.com/in/laurie-merrell/ Michael's socials and urls: LinkedIn: https://www.linkedin.com/in/michael-a-chow/ Bluesky: https://bsky.app/profile/mchow.com GitHub: https://github.com/machow Resources from the hosts and chat: Michael Chow's talk about dbt at the Coalesce Conference in 2022: https://www.youtube.com/watch?v=EYdb1x1cO9U Beginner dbt project Michael is using: https://github.com/dbt-labs/jaffle_shop_duckdb Laurie's Coalesce talk with Ian and Jenna: https://www.youtube.com/watch?v=6aX7tAfMmIM Link to installation page for the DuckDB CLI: https://duckdb.org/install/?platform=macos&environment=cli "Why is dbt so important" shared by Jenna in the chat: https://highgrowthengineering.substack.com/p/why-is-dbt-so-important- dbtplyr: https://hub.getdbt.com/emilyriederer/dbtplyr/latest/ Parquet: https://parquet.apache.org/ From stored procedures to dbt: A modern migration playbook: https://www.getdbt.com/blog/stored-procedures-dbt-migration-playbook How to structure our dbt projects: https://docs.getdbt.com/best-practices/how-we-structure/1-guide-overview Jenna Jordan's blog on dbt mesh: https://jennajordan.me/blog/data-mesh-dbt ► Subscribe to Our Channel Here: https://bit.ly/2TzgcOu Follow Us Here: Website: https://www.posit.co The Lab: https://pos.it/dslab Hangout: https://pos.it/dsh LinkedIn: https://www.linkedin.com/company/posit-software Bluesky: https://bsky.app/profile/posit.co Thanks for learning with us! Timestamps 00:00 Introduction 01:09 Guest introductions: Michael Chow and Laurie Merrell 04:15 Overview of today's session 05:51 Setting up the GitHub Codespace 07:00 The data science workflow vs. organizational needs 10:06 Why dbt is hard to learn in the abstract 13:34 "Could we back up and explain what dbt is again?" 19:12 Running 'dbt build' 20:00 Inspecting the database with DuckDB CLI 26:21 "Does dbt have concurrency or dependency capabilities?" 27:37 Understanding the 'ref' macro 29:52 "Is dbt an orchestrator?" 31:14 "Starting a project from scratch with just SQL?" 32:04 "How is this better than writing Python scripts?" 35:46 "Is data source detection dynamic with dbt?" 38:36 Generating and serving dbt docs 46:51 "Is dbt an IDE like RStudio, but for SQL?" 52:32 Branching and development environments 53:57 "Where would you begin on a brand new project?" 56:38 "How would you validate dependencies and downstream impacts?" 57:48 Defining a view versus a table

Michael Chow

Michael Chow: From psychology and Python to constrained creativity

For this one, we turn the mic around. Wes McKinney takes over the interviewer’s chair to chat with his co-host, Michael Chow. Michael’s a principal software engineer at Posit, but he started out studying how people think — literally, with a PhD in cognitive psychology. Somewhere along the way, he got hooked on data science, helped build adaptive learning tools at DataCamp, and now spends his days thinking about how to make Python easier to use and more fun. The two dig into what drives Michael’s curiosity, how a “weird obsession with tables” turned into a beloved open source project, and the future of data science/scientists. We explore Michael’s path from studying the mind to shaping the Python data science ecosystem. From adaptive learning platforms to Great Tables, Michael shares how following unexpected curiosities can spark tools and communities that last. What’s Inside: • Michael’s pivot from an academic career in data science • Behind-the-scenes messiness of building data and learning platforms • Open source projects born out of zany, single-minded passions • Bringing beauty to rows and columns • Big-picture thoughts on where data science — and open source tooling — are headed

Michael Chow

Keeping LLMs in Their Lane: Focused AI for Data Science and Research

From R+AI 2025, hosted by R Consortium Keynote LLMs are powerful, flexible, easy-to-use… and often wrong. This is a dangerous combination, especially for data analysis and scientific research, where correctness and reproducibility are core requirements. Fortunately, it turns out that by carefully applying LLMs to narrower use cases, we can turn them into surprisingly reliable assistants that accelerate and enhance, rather than undermine, scientific work. This is not just theory—I’ll showcase working examples of seamlessly integrating LLMs into analytic workflows, helping data scientists build interactive, intelligent applications without needing to be web developers. You’ll see firsthand how keeping LLMs focused lets us leverage their “intelligence” in a way that’s practical, rigorous, and reproducible. Bio Joe Cheng is the CTO and first employee at Posit, PBC (formerly known as RStudio), where he helped create the RStudio IDE, Shiny web framework, and Databot agent for exploratory data analysis. R Consortium Resources Main R Consortium Site: https://www.r-consortium.org/ R+AI website: https://rconsortium.github.io/RplusAI_website R Consortium webinars: https://r-consortium.org/webinars/webinars.html Blog: https://r-consortium.org/blog/ LinkedIn: https://www.linkedin.com/company/r-consortium/

Joe Cheng

Web applications with Shiny and React and AI (Winston Chang, Posit) | posit::conf(2025)

Web applications with Shiny and React (and AI) Speaker(s): Winston Chang If you've ever wanted to have complete control over the UI for a Shiny application, this talk might be for you. In this talk I'll show how to integrate a back end written in Shiny (for R or Python) with a front end written in React.js. This lets you combine Shiny's reactivity with the flexibility of the React web development ecosystem. In the past, writing a front end in React was a large time investment, and would be reserved only for a serious project. However, with today's agentic AI coding tools, it can make sense to create a React front end even for smaller-scale applications. But even with AI involved, you will still need to know some React or be willing to learn about it. GitHub Repo - https://github.com/wch/shiny-react CLI tool - https://github.com/wch/create-shiny-react-app Anthropic Dashboard - https://github.com/wch/anthropic_dashboard posit::conf(2025) Subscribe to posit::conf updates: https://posit.co/about/subscription-management/

Winston Chang

The Curse of Documentation (Michael Chow, Posit) | posit::conf(2025)

The Curse of Documentation Speaker(s): Michael Chow Abstract: In Greek mythology, Tantalus was doomed to stand with a lake of water below him and branches of fruit close above. When he went to drink the water it receded, and when he reached to eat the fruit it was blown beyond his grasp. What he needed was forever at arms length. Software documentation often puts users in a similar bind. The information is there, but something doesn’t quite connect. Maybe you try and fail to adapt an example to your use case. Maybe it’s unclear how a bunch of functions fit together. In this talk, I'll discuss how effective user guides--like R for Data Science and the React.js guide--break the curse. I'll focus on three factors behind effective guides: strategic information, inductive learning, and task sequencing. posit::conf(2025) Subscribe to posit::conf updates: https://posit.co/about/subscription-management/

Michael Chow

Making the most of artificial and human intelligence for data science (Hadley Wickham, Joe Cheng)

Making the most of artificial and human intelligence for data science Speaker(s): Hadley Wickham; Joe Cheng Abstract: This presentation explores the complex and often contradictory nature of large language models (LLMs) in data science, acknowledging the simultaneous excitement and apprehension that we feel toward these technologies. We’ll provide a practical framework to help you understand the LLM ecosystem (from foundation models and hosting to SDKs and applications) that supports our current philosophy: augmenting, not replacing human intelligence. The talk demonstrates how Posit is addressing this space through two complementary approaches: building SDKs and tools that help you create your own LLM-powered solutions, and developing integrated LLM capabilities directly into data science workflows through tools like Positron assistant and databot. We’ll showcase practical, immediately useful applications while addressing current limitations, providing you with both the emotional preparation and technical foundation needed to effectively leverage LLMs in their data science practice today. posit::conf(2025) Subscribe to posit::conf updates: https://posit.co/about/subscription-management/

Hadley Wickham, Joe Cheng

Positron AI Session (George Stagg, Winston Chang, Tomasz Kalinowski , Carson Sievert) | posit::conf

George Stagg, Winston Chang, and Tomasz Kalinowski introduce AI capabilities in Positron, including Positron Assistant, a tool still in preview that enhances coding and data analysis. 0:00 Introduction to Posit's approach to AI 0:23 George Stagg: Positron Assistant 11:03 Winston Chang: Databot 21:30 Tomasz Kalinowski: ragnar 31:13 Carson Sievert: chatlas 41:42 Q&A posit::conf(2025) Subscribe to posit::conf updates: https://posit.co/about/subscription-management/

Carson Sievert, George Stagg, Tomasz Kalinowski, Winston Chang

Observability at scale (Barret Schloerke, Posit) | posit::conf(2025)

Observability at scale: Monitoring Shiny Applications with OpenTelemetry Speaker(s): Barret Schloerke Abstract: Understanding what happens behind the scenes in production Shiny applications has always been challenging. When users experience slow response times or unexpected behavior, developers are left guessing where bottlenecks occur. This talk introduces OpenTelemetry integration for Shiny for R, a new approach to profiling code and understanding application behavior. Through a chat-enabled weather application, we'll explore how complex user interactions trigger cascading events across multiple processes. You'll learn how OpenTelemetry's "high-quality, ubiquitous, and portable telemetry" can provide complete visibility into your Shiny application's performance with minimal setup... just a few environment variables! After walking through the chat app, you'll have a taste of how to implement comprehensive monitoring for your Shiny applications in production, enabling you to proactively identify and resolve unexpected performance issues. Materials - https://github.com/schloerke/presentation-2025-09-17-posit-conf-otel posit::conf(2025) Subscribe to posit::conf updates: https://posit.co/about/subscription-management/

Barret Schloerke

{plumber2}: Streamlining Web API Development in R - Barret Schloerke

Over the past nine years, the R package {plumber} has simplified the creation of web APIs using annotations over existing R source code with roxygen2-like comments. During this time, the community has gathered valuable insights and identified numerous areas for improvement. To invest in a way forward, a new package called {plumber2} has been created. {plumber2} is designed from the ground up to be highly extensible, enabling developers to easily integrate custom decorators to modify the behavior of their APIs. Furthermore, {plumber2} is built using a modern foundation, leveraging the latest packages associated with the {fiery} framework. This modern architecture is built upon middleware (the ability to introduce custom logic at specific points within the API's request handling process). One of the many fine-grained controls over how your API can behave. By incorporating these improvements and embracing a modern framework, {plumber2} offers a sustainable path forward for building web APIs in R. This new approach avoids the need for short-term fixes and ensures that {plumber2} can continue to evolve and adapt to the changing needs of developers

Barret Schloerke

Michael Chow - User guides: engaging new users, delighting old ones | SciPy 2025

User guides are the piece you often hit right after clicking the "Learn" or "Get Started" button in a package's documentation. They're responsible for onboarding new users, and providing a learning path through a package. Surprisingly, while pieces of documentation like the API Reference tend to be the same, the design of user guides tend to differ across packages. In this talk, I'll discuss how to design an effective user guide for open source software. I'll explain how the guides for Polars, DuckDB, and FastAPI balance working end-to-end like a course, with being browsable like a reference

Michael Chow

Visualizing Gas Prices | PydyTuesday Uncut #2

Join Michael Chow (open source developer at Posit) and Jeroen Janssens (developer relations engineer at Posit) as they dive into this week's #PydyTuesday dataset. This time, they visualize gas prices using the four P's: Positron, Python, Polars, and Plotnine. True to the "PydyTuesday Uncut" title, this video is completely unedited. Every typo, mistake, web search, and "aha!" moment is left in so you can see exactly how we approach a new dataset from scratch. Things mentioned during the session and related resources: - Weekly US Gas Prices https://github.com/rfordatascience/tidytuesday/blob/main/data/2025/2025-07-01/readme.md - Code produced during the session https://github.com/jeroenjanssens/pydytuesday-uncut/ - Plotnine https://plotnine.org - Positron https://positron.posit.co #python #polars #tidytuesday #datascience

Jeroen Janssens, Michael Chow

Adding Plots to Great Tables

Exploring three approaches to add small plots to Great Tables using plotnine, svg.py, or HTML

Jules Walzer-Goldfeld, Michael Chow

Exploring Web APIs | PydyTuesday Uncut #1

Join Michael Chow (open source developer at Posit) and Jeroen Janssens (developer relations engineer at Posit) as they dive into this week's #PydyTuesday dataset about Web APIs. Tools include uv, Positron, Polars, Plotnine, Great Tables, and the Unix command line. True to the "PydyTuesday Uncut" title, this video is completely unedited. Every typo, mistake, web search, and "aha!" moment is left in so you can see exactly how others approach a new dataset from scratch. Things mentioned during the session and related resources: - Code produced during the session: https://github.com/jeroenjanssens/pydytuesday-uncut/blob/main/2025-06-17/01-start.py - PydyTuesday https://github.com/posit-dev/pydytuesday - TidyTuesday https://github.com/rfordatascience/tidytuesday - Getting Data from the TidyTuesday Repo with Python https://www.youtube.com/watch?v=ol2FrSL5gVU - Positron IDE https://positron.posit.co - Data Science at the Command Line https://jeroenjanssens.com/dsatcl/ - Python Polars: The Definitive Guide https://polarsguide.com - Polars https://pola.rs - Plotnine https://plotnine.org - Great Tables https://posit-dev.github.io/great-tables/ - The Big Year https://www.imdb.com/title/tt1053810/ 00:00 Introduction 02:46 Getting the data with uv 13:18 Positron IDE 17:42 Importing Polars 23:17 Plotting a bar chart with Plotnine 33:55 Inspecting duplicates 46:30 Handling missing values 58:56 Crafting a great table 1:38:48 Reflection

Jeroen Janssens, Michael Chow

The Test Set: A Posit Podcast Trailer

Introducing The Test Set–a Posit podcast for data science, coming July 1, 2025. For data science junkies, anomaly hunters, and those who play outside the confidence interval. Hosted by Michael Chow, Wes McKinney & Hadley Wickham Subscribe to receive updates: https://pos.it/thetestset

Hadley Wickham, Michael Chow

Demystifying LLMs with Ellmer

From R/Medicine 2025 Joe Cheng, CTO, Posit Joe Cheng is the CTO of Posit, PBC. He’s the original creator of the Shiny web framework and co-creator of ellmer. Today’s best LLMs are incredibly powerful–but you’re only scratching the surface of their capabilities if your use is limited to ChatGPT or Copilot. Accessing LLMs programmatically opens up a whole new world of possibilities, letting you integrate LLMs into your own apps, scripts, and workflows. In this workshop, we’ll cover: A practical introduction to LLM APIs -- Configuring R to access LLMs via the ellmer package -- Customizing LLM behavior using system prompts and tool calling -- Creating Shiny apps with integrated chatbots -- Using LLMs for natural language processing Attendees will leave the workshop armed with ready-to-run examples, and the confidence and inspiration to run their own experiments with LLMs. Attendees should be familiar with the basics of R and have a working R installation. Note that to avoid any potential firewall issues, it is recommended that participants use a personal computer for this workshop. Resources Presentation: https://jcheng5.github.io/rmedicine-2025 R/Medicine: https://rconsortium.github.io/RMedicine_website/ R Consortium: https://www.r-consortium.org/

Joe Cheng

Posit Conf 2025 Keynote Previews | Kieran Healy & Jonathan McPherson | Data Science Hangout

To join future data science hangouts, add it to your calendar here: https://pos.it/dsh - All are welcome! We'd love to see you! Thursdays at 12PM US Eastern We were recently joined by upcoming Posit Conf 2025 keynote speakers Kieran Healy, Professor of Sociology at Duke University, and Jonathan McPherson, Software Architect at Posit PBC, to chat about how and why open-source IDEs like RStudio and Positron get made, how to do data visualization for discovery and explanation, what their keynotes are going to be about, and what’s next for Posit’s IDE development, including AI integration. In this Hangout, Kieran talked about the trustworthy data visualization. He highlighted that while data visualization is a powerful way to condense and present information, often creating compelling and authoritative artifacts, phrases like "visual storytelling" can be problematic if they encourage presenting a predetermined narrative not fully supported by data. He emphasized that the trustworthiness of visualizations does not come solely from the techniques used or the software, but from a "web of social processes and individual commitments" that cannot be easily automated. Jonathan talked about the future of Positron and its relationship with RStudio, addressing whether Positron is intended to replace RStudio. He clarified that the long-term goal for Positron is to make it the best Integrated Development Environment (IDE) for working with data in any language. He explained that Positron is built with an extensibility layer, allowing anyone to write plugins for new languages or capabilities, making it a robust and evolving data science workbench. It does not have all of RStudio's features and makes different design trade-offs. RStudio, having evolved over decades, is highly optimized for specific R-based workflows and remains the best at what it does for those use cases. Resources mentioned in the video and zoom chat: Posit Conference 2025 Registration → https://posit.co/conference/ Kieran Healy's Website → https://kieranhealy.org Kieran Healy's book "The Ordinal Society" → https://theordinalsociety.com/ Kieran Healy's book "Data Visualization: A Practical Introduction" → https://socviz.co/ Jonathan McPherson's LinkedIn → https://www.linkedin.com/in/jonathanmcpherson Joe Cheng’s AI Talk on Harnessing LLMs for Data Analysis → https://youtu.be/owDd1CJ17uQ?feature=shared TidyTuesday GitHub → https://github.com/rfordatascience/tidytuesday Positron IDE → https://positron.posit.co/ Will R Chase's talk on making clear plots → https://www.youtube.com/watch?v=h5cTacaWE6I If you didn’t join live, one great discussion you missed from the zoom chat was about the ongoing debate and practical tips for moving from presenting tables of numbers to visualizations. Community members shared various strategies, including using color-mapped tables as an intermediate step, providing both tables and visuals, and ensuring accessibility and interpretability for diverse audiences. Are you team tables or team graphs? ► Subscribe to Our Channel Here: https://bit.ly/2TzgcOu Follow Us Here: Website: https://www.posit.co Hangout: https://pos.it/dsh LinkedIn: https://www.linkedin.com/company/posit-software Bluesky: https://bsky.app/profile/posit.co Thanks for hanging out with us!

Joe Cheng

Harnessing LLMs for Data Analysis | Led by Joe Cheng, CTO at Posit

When we think of LLMs (large language models), usually what comes to mind are general purpose chatbots like ChatGPT or code assistants like GitHub Copilot. But as useful as ChatGPT and Copilot are, LLMs have so much more to offer—if you know how to code. In this demo Joe Cheng will explain LLM APIs from zero, and have you building and deploying custom LLM-empowered data workflows and apps in no time. Posit PBC hosts these Workflow Demos the last Wednesday of every month. To join us for future events, you can register here: https://posit.co/events/ Slides: https://jcheng5.github.io/workflow-demo/ GitHub repo: https://github.com/jcheng5/workflow-demo Resources shared during the demo: Ellmer https://ellmer.tidyverse.org/ Chatlas https://posit-dev.github.io/chatlas/ Environment variable management: For R: https://docs.posit.co/ide/user/ide/guide/environments/r/managing-r.html#renviron For Python https://pypi.org/project/python-dotenv/ Shiny chatbot UI: For R, Shinychat https://posit-dev.github.io/shinychat/ For Python, ui.Chat https://shiny.posit.co/py/docs/genai-inspiration.html Deployment Cloud hosting https://connect.posit.cloud On-premises (Enterprise) https://posit.co/products/enterprise/connect/ On-premises (Open source) https://posit.co/products/open-source/shiny-server/ Querychat Demo: https://jcheng.shinyapps.io/sidebot/ Package: https://github.com/posit-dev/querychat/ If you have specific follow-up questions about our professional products, you can schedule time to chat with our team: pos.it/llm-demo

Joe Cheng

Forecasting AI Demand at Microsoft | Sajay Suresh | Data Science Hangout

To join future data science hangouts, add it to your calendar here: https://pos.it/dsh - All are welcome! We'd love to see you! We were recently joined by Sajay Suresh, Senior Director of Data and Applied Science at Microsoft, to chat about data center supply chain planning, forecasting AI demand, and navigating data science careers. In this Hangout, we explored how the emergence of technologies like LLMs changed projections for data center demand. Sajay discussed how forecasting for something with little historical data, like AI demand, required drawing analogies from the past, such as comparing the training/inferencing model to the iPhone and its App Store. A major complexity in current supply chain planning is the lack of fungibility with modern GPUs requiring specific infrastructure like liquid cooling, meaning data centers designed for GPUs cannot easily be repurposed for traditional compute/storage workloads, increasing investment risk if demand is lower than planned. Resources mentioned in the video and zoom chat: LLM Workflow Demo with Joe Cheng → https://pages.posit.co/05-28WorkflowDemo.html Posit::conf 2025 Virtual Registration → https://posit.co/blog/posit-conf-2025-virtual-experience-registration/ Sajay Suresh on LinkedIn → https://www.linkedin.com/in/sajay-suresh-12687631/ Find mentors on ADPList → https://adplist.org/ Officeverse R packages for Office documents → https://ardata-fr.github.io/officeverse/ Microsoft team meetup video on capacity planning → https://www.youtube.com/live/07j22d4B_hA?feature=shared Seattle Data And AI Security community → https://www.linkedin.com/posts/seattle-data-and-ai-security_microsoft-fabric-tour-seattle-data-ai-security-6891902675280633856-xLw3?utm_source=share&utm_medium=member_desktop Quarto Gallery → https://quarto.org/docs/gallery/ Quarto Guide → https://quarto.org/docs/guide/ If you didn’t join live, one great discussion you missed from the zoom chat was about communities and meetups recommended for networking and learning in data science. Participants shared various groups like R-Ladies, Data Book Club, local tech meetups, and specific conference recommendations like Shiny Conf and DataConf.ai NYC. What's your favorite data community? ► Subscribe to Our Channel Here: https://bit.ly/2TzgcOu Follow Us Here: Website: https://www.posit.co Hangout: https://pos.it/dsh LinkedIn: https://www.linkedin.com/company/posit-software Bluesky: https://bsky.app/profile/posit.co Thanks for hanging out with us! Subscribe to posit::conf updates: https://posit.co/about/subscription-management/

Joe Cheng

Great Tables 3: Data Color and Polishing

This workshop is all about using Great Tables to make beautiful tables for publication and display purposes. We believe that effective tables have these things in common: structuring that aids in the reading of the table well-formatted values, fitting expectations for the field of study styling that reduces time to insight and improves aesthetics These materials are for you if: • you have some experience with data analysis in Python • you often create reporting that involves summarizations of data • you were often frustrated with making tables for display purposes outside of Python • you found beautiful-looking tables in the wild and wondered: 'How could I do that?' Other videos in this series: Great Tables 1: Structure, Format, and Style: https://youtu.be/QM7DbsY-nc4 Great Tables 2: Introducing Units Notation: https://youtu.be/SN0_vIL1Rhk About us: Michael Chow, Senior Software Engineer, Posit Michael is a data scientist and software engineer. He has programmed in Python for well over a decade, and he obtained a PhD in cognitive psychology from Princeton University. His interests include statistical methods, skill acquisition, and human memory. Richard Iannone, Senior Software Engineer, Posit Richard is a software engineer and table enthusiast. He's been vigorously working on making display tables easier to create/display in Python. And generally Rich enjoys creating open source packages so that people can great things in their own work. Workshop repo: https://github.com/rich-iannone/great-tables-mini-workshop?tab=readme-ov-file Learn more at https://posit-dev.github.io/great-tables/articles/intro.html

Michael Chow

Great Tables 2: Introducing Units Notation

This workshop is all about using Great Tables to make beautiful tables for publication and display purposes. We believe that effective tables have these things in common: structuring that aids in the reading of the table well-formatted values, fitting expectations for the field of study styling that reduces time to insight and improves aesthetics These materials are for you if: • you have some experience with data analysis in Python • you often create reporting that involves summarizations of data • you were often frustrated with making tables for display purposes outside of Python • you found beautiful-looking tables in the wild and wondered: 'How could I do that?' Other videos in this series: Great Tables 1: Structure, Format, and Style: https://youtu.be/QM7DbsY-nc4 Great Tables 3: Data Color and Polishing https://youtu.be/Huteb5OmcrA About us: Michael Chow, Senior Software Engineer, Posit Michael is a data scientist and software engineer. He has programmed in Python for well over a decade, and he obtained a PhD in cognitive psychology from Princeton University. His interests include statistical methods, skill acquisition, and human memory. Richard Iannone, Senior Software Engineer, Posit Richard is a software engineer and table enthusiast. He's been vigorously working on making display tables easier to create/display in Python. And generally Rich enjoys creating open source packages so that people can great things in their own work. Workshop repo: https://github.com/rich-iannone/great-tables-mini-workshop?tab=readme-ov-file Learn more at https://posit-dev.github.io/great-tables/articles/intro.html

Michael Chow

Great Tables 1: Structure, Format, and Style

This workshop is all about using Great Tables to make beautiful tables for publication and display purposes. We believe that effective tables have these things in common: structuring that aids in the reading of the table well-formatted values, fitting expectations for the field of study styling that reduces time to insight and improves aesthetics These materials are for you if: • you have some experience with data analysis in Python • you often create reporting that involves summarizations of data • you were often frustrated with making tables for display purposes outside of Python • you found beautiful-looking tables in the wild and wondered: 'How could I do that?' Other videos in this series: Great Tables 2: Introducing Units Notation: https://youtu.be/SN0_vIL1Rhk Great Tables 3: Data Color and Polishing https://youtu.be/Huteb5OmcrA About us: Michael Chow, Senior Software Engineer, Posit Michael is a data scientist and software engineer. He has programmed in Python for well over a decade, and he obtained a PhD in cognitive psychology from Princeton University. His interests include statistical methods, skill acquisition, and human memory. Richard Iannone, Senior Software Engineer, Posit Richard is a software engineer and table enthusiast. He's been vigorously working on making display tables easier to create/display in Python. And generally Rich enjoys creating open source packages so that people can great things in their own work. Workshop repo: https://github.com/rich-iannone/great-tables-mini-workshop?tab=readme-ov-file Learn more at https://posit-dev.github.io/great-tables/articles/intro.html

Michael Chow

Tables in Python with Great Tables

Tables in Python with Great Tables - Rich Iannone, Michael Chow Resources mentioned in the workshop: - Workshop GitHub Repository: https://github.com/rich-iannone/great-tables-mini-workshop - Great Tables https://posit-dev.github.io/great-tables/articles/intro.html - {reactable-py} https://github.com/machow/reactable-py - Save a gt table as a file https://gt.rstudio.com/reference/gtsave.html - {gto} Insert gt tables into Word documents https://gsk-biostatistics.github.io/gto/ - GT.save https://posit-dev.github.io/great-tables/reference/GT.save.html - define_units https://posit-dev.github.io/great-tables/reference/define_units.html#great_tables.define_units - Posit Tables Contest 2024 winners: https://posit.co/blog/2024-table-contest-winners/ Editor's note: During this workshop, several interruptions from an unwanted and disruptive intruder (commonly referred to as a "Zoom bomber") occurred. We removed those instances from the recording, however that causes a few of the workshop sections to appear disjointed. We apologize for the inconvenience. Workshop recorded as part of the 2024 R/Pharma Workshop Series

Michael Chow, Rich Iannone

{shinylive}: Serverless Shiny applications workshop

{shinylive}: Serverless Shiny applications workshop: An exercise in deploying your app to GitHub Pages - Barret Schloerke Resources mentioned in the workshop: - Workshop slides (best viewed in browsers using Chrome engine): http://schloerke.com/workshop-rinpharma24-shinylive/ - Workshop GitHub repository: https://github.com/schloerke/workshop-rinpharma24-shinylive Workshop recorded as part of the 2024 R/Pharma Workshop Series

Barret Schloerke

Shiny community, hackathons, and his AI mindset | Joe Cheng | Data Science Hangout

To join future data science hangouts, add it to your calendar here: https://pos.it/dsh - All are welcome! We'd love to see you! We were recently joined by Joe Cheng, CTO at Posit, to chat about the Shiny contest, the use of AI in data science, and designing hackathons for learning new technologies. We were joined by several past and present Shiny contest winners who gave great advice on how to get started if you want to participate (and we really hope you do)! In this Hangout, we explore the evolution of the Shiny contest since its inception, including what made the 2024 submissions unique and the ways the contest encourages community contribution and learning. Joe also shared about his personal journey from feeling skepticism about AI to seeing and embracing its potential. We got some amazing questions from the Hangout attendees! We hope you join us live next time to ask some of your own questions Resources mentioned in the video and zoom chat: 2024 Shiny Contest Winners → https://posit.co/blog/winners-of-the-2024-shiny-contest/ Joe's AI Hackathon Slides → https://jcheng5.github.io/llm-quickstart/quickstart.html Shiny Assistant → https://gallery.shinyapps.io/assistant/ Isabella's blog post on prototyping with Shiny Assistant → https://posit.co/blog/ai-powered-shiny-app-prototyping/ Posit Conf Workshops → https://reg.rainfocus.com/flow/posit/positconf25/attendee-portal/page/sessioncatalog?tab.day=20250916&search.sessiontype=1675316728702001wr6r Shiny Conference 2025 → https://www.shinyconf.com/ Call for Speakers Shiny Conf 2025 → https://sessionize.com/shiny-conf-2025/ Shiny Tableau → https://rstudio.github.io/shinytableau/ Echarts4r → https://echarts4r.john-coene.com Elmer package on Github → https://github.com/tidyverse/ellmer All the Shiny app links mentioned in the video and zoom chat: Eric Nantz 2021 Shiny Contest Submission → https://forum.posit.co/t/the-hotshots-racing-dashboard-shiny-contest-submission/104925 Eric Nantz's R/Pharma conference keynote on AI → https://youtu.be/AfMa1CVUdXU?si=ThLsKFyonntxzBUF Eric Nantz's Haunted Places app → https://youtu.be/vX09QGMuOfo?si=K5_uPfK5bcfZZ92l Umair Durrani's Shiny Storytelling app → https://umair.shinyapps.io/storytimegcp/ Umair's Blue Sky profile → https://bsky.app/profile/transport-talk.bsky.social Umair's Shiny meetings project on Github → https://github.com/shiny-meetings/shiny-meetings Abby Stamm's Shiny Accessibility app → https://github.com/ajstamm/shiny-a11y-app If you didn’t join live, one great discussion you missed from the zoom chat was about everyone's favorite interactive plotting tools. Someone asked whether Plotly was the best option, and lots of people said they loved ggiraph, echarts4r, ObservableJS, and others. What about you?! What's your favorite interactive plotting library? ► Subscribe to Our Channel Here: https://bit.ly/2TzgcOu Follow Us Here: Website: https://www.posit.co Hangout: https://pos.it/dsh LinkedIn: https://www.linkedin.com/company/posit-software Bluesky: https://bsky.app/profile/posit.co Thanks for hanging out with us!

Joe Cheng

We want GREAT tables! | Richard Iannone & Michael Chow | Data Science Hangout

To join future data science hangouts, add it to your calendar here: https://pos.it/dsh - All are welcome! We'd love to see you! We were recently joined by Rich Iannone and Michael Chow, software engineers at Posit, to chat about their experiences building GT and Great Tables, how they drive community engagement around their packages, and their career advice for package developers. GT and Great Tables are R and Python packages for creating static tables in R and Python. They were created to fill a need for a good, maintained solution for generating tables with different output types from data frames. They've gained loads of popularity, and have an active community of users! Resources mentioned in the video and zoom chat: Great Tables Blog → https://posit-dev.github.io/great-tables/blog/ 2024 Table Contest Winners → https://posit.co/blog/2024-table-contest-winners/ Contributing to Public Transit Data Analysis and Tooling → https://posit-dev.github.io/great-tables/blog/open-transit-tools/ Tables as Powerful Representational Tools → https://www.researchgate.net/publication/363345970_Tables_as_Powerful_Representational_Tools The MockUp - 10+ Guidelines for Better Tables in R → https://themockup.blog/posts/2021-01-13-10-guidelines-for-better-tables-in-r/ Show Me the Numbers by Stephen Few → https://analyticspress.com/smtn.php Excel spreadsheets to gt package called {forgts} → https://github.com/luisDVA/forgts What They Forgot to Teach You About R → https://rstats.wtf/ David Robinson Talk called "The unreasonable effectiveness of public work" → https://www.youtube.com/watch?v=th79W4rv67g Publication quality tables in 2024 → https://posit.co/blog/what-we-did-with-publication-quality-tables-in-2024/ Great Tables Design Philosophy → https://posit-dev.github.io/great-tables/blog/design-philosophy/ gtsummary-to-excel → https://www.pipinghotdata.com/posts/2024-07-26-gtsummary-to-excel/ happy git with R → https://happygitwithr.com/ freeCodeCamp - how to contribute to open source → https://github.com/freeCodeCamp/how-to-contribute-to-open-source/ If you didn’t join live, one great discussion you missed from the zoom chat was about how people manage their personal and work GitHub accounts, and whether to have one account for all their work or separate accounts for each employer. Let us know YOUR thoughts on this topic below! ► Subscribe to Our Channel Here: https://bit.ly/2TzgcOu Follow Us Here: Website: https://www.posit.co Hangout: https://pos.it/dsh LinkedIn: https://www.linkedin.com/company/posit-software Bluesky: https://bsky.app/profile/posit.co Thanks for hanging out with us! #pythoncontent

Michael Chow, Rich Iannone

Joe Cheng - Summer is Coming: AI for R, Shiny, and Pharma

Summer is Coming: AI for R, Shiny, and Pharma - Joe Cheng Abstract: R users tend to be skeptical of modern AI models, given our weird insistence on answers being accurate, or at least supported by the data. But I believe the time has come—or maybe it’s a little late—for even the most AI-cynical among us to push past their discomfort and get informed about what these tools are truly capable of. And key to that is moving beyond using AI-enabled apps, and towards building our own scripts, packages, and apps that make judicious use of AI. In this talk, I’ll tell you why I believe AI has more to offer the R community than just wrong answers from chat windows or mediocre code suggestions in our IDEs. I’ll also introduce brand-new tools we’re developing at Posit that put powerful AI tools within reach of every R user. And finally, I’ll show how adding some AI could make your next Shiny app dramatically more useful for your users. Resources mentioned in the talk: - Slides: https://jcheng5.github.io/pharma-ai-2024 - {elmer} Call LLM APIs from R: https://elmer.tidyverse.org/ - {shinychat} Chat UI component for Shiny for R https://github.com/jcheng5/shinychat - R/Pharma GenAI Day Recordings: https://www.youtube.com/playlist?list=PLMtxz1fUYA5AYryl4t2mtqBngqWDrnMXJ Presented at the 2024 R/Pharma Conference

Joe Cheng

Winston Chang - Building ML and AI apps with Shiny for Python

In the last few months, the best LLMs have taken a big step forward in their ability to help write code. We’ve been building a tool that uses an LLM to help you learn Shiny and build Shiny applications much faster than ever before. If you feel like you don’t have the time to invest in learning Shiny, this might change your mind. You’ll get up and running with Shiny in no time, and you’ll be able to learn from the AI as you go. If you already know Shiny, you’ll be able to dramatically accelerate your development process, and you’ll find yourself trying out new things that wouldn’t have been worth the effort before. Talk by Winston Chang

Winston Chang

Carson Sievert - Supercharge Your Shiny (for Python) App: Unleashing Interactive Jupyter Widgets

Most Python packages that provide interactive web-based visualizations (e.g., altair, plotly, bokeh, ipyleaflet, etc.) can render in Jupyter notebooks via the ipywidgets standard. The shinywidgets package brings that ipywidgets standard to Shiny, enabling the use of 100s of Jupyter Widgets as Shiny outputs. In this talk, you'll not only learn how to render Jupyter Widgets in Shiny to get interactive output, but also how to leverage user interaction with widgets to create delightful and bespoke experiences. Talk by Carson Sievert Slides: https://talks.cpsievert.me/20240814/ GitHub Repo: https://github.com/cpsievert/talks/tree/gh-pages/20240814

Carson Sievert

Barret Schloerke - Editable data frames in Py-Shiny: Updating original data in real-time

Integrating editable data frames into Py-Shiny and Shinylive applications streamlines data scientists' workflows by allowing real-time data manipulation directly within interactive web applications. This new feature enables users to edit cells within the data frame output. Using the empowered data frame renderer, we can facilitate immediate analysis and visualization feedback. It simplifies the process of data exploration and hypothesis testing, as changes to the data set can be instantly reflected in the application's outputs without the requirement to update the original data, keeping data scientists “scientists”, not data janitors. Talk by Barret Schloerke Slides: http://schloerke.com/presentation-2024-08-13-posit-shiny-data-frame/ Slides GitHub Repo: https://github.com/schloerke/presentation-2024-08-13-posit-shiny-data-frame Shiny: https://shiny.posit.co/ Shiny for Python: https://shiny.posit.co/py/ Component gallery: https://shiny.posit.co/py/components/ Edit `Data Grid` table cells: https://shiny.posit.co/py/components/outputs/data-grid/

Barret Schloerke

Joe Cheng - Shiny x AI

These days, you can’t turn around without encountering a large language model—they’re embedded in everything from Google search results to the lower-right corner of every Windows desktop. But… in your Shiny app? In this talk, we’ll discuss some ways the Shiny team is combining the magical chaos of LLMs with the structure and control of Shiny. You’ll learn how to use modern chat models to add features to your Shiny apps that will feel like science fiction to your users while minimizing the risks of hallucination, irreproducibility, and data exposure. Talk by Joe Cheng GitHub Repo: https://github.com/jcheng5/py-sidebot

Joe Cheng, Shiny Team

Greg Swinehart - We CAN have nice Shiny apps: What's new in Shiny's UI & UX

The Shiny team has made big steps to help apps' UI and UX scale more thoughtfully and elegantly. We've built a cohesive theme that refreshes all of our colors and components. Our layouts will better serve your apps as they grow. And we've created Shiny Templates, which are opinionated boilerplate code to help users create small, simple apps or large, complicated, multi-page dashboards that just look right. Talk by Greg Swinehart

Greg Swinehart, Shiny Team

Shiny 1.2 Release: Wrap your data frame with Narwhals! 🎉 | Barret Schloerke | Posit

In this video, Barret Schloerke from the Shiny team walks us through the exciting features of Shiny 1.2. One of the major updates includes the integration of Narwhals, allowing effortless computation on data frames without needing detailed knowledge of the data structure. Barret also demonstrates a simple Shiny app displaying S&P 500 data using PyArrow, Polars, and Narwhals. Learn how these updates simplify your data workflows, with minimal code needed to run complex data frame operations. Useful Links: • Shiny Component Gallery: [https://shiny.posit.co/py/components/] • Learn more about Narwhals: [https://narwhals-dev.github.io/narwhals/] Timestamps: 0:00 - Introduction and Shiny 1.2 Release Overview 0:12 - Narwhals Integration and Data Computation 0:31 - PyArrow Application Code Breakdown 1:20 - Using S&P 500 Data with Pandas, Polars, PyArrow, and Narwhals #Shiny #DataScience #narwhals #ShinyApp #Polars #Python

Barret Schloerke, Shiny Team

Shiny Assistant: Prototype and build Shiny applications with the help of AI | Winston Chang | Posit

Have you ever had an idea for a great web application with Shiny but felt something holding you back from getting started? Maybe it’s that you don’t know where to start, or that you don’t know which packages use to build the app, or maybe it’s just that you can’t muster the energy to get started. Sometimes you just need a little help to get unstuck. We’re excited to announce a new addition to the Shiny ecosystem that can help: Shiny Assistant. Try it out here, free: https://gallery.shinyapps.io/assistant/ Get started with Shiny for R and Python: https://shiny.posit.co

Winston Chang

So You Think You Can ANALYZE? (Data Content Creator Hackathon)

Watch your favorite data science content creators compete for a piece of history. They will either prove their skills in front of the world or fail in the pursuit of eternal glory. This is so you think you can analyze. Special thanks to Posit for sponsoring this competition and make this all possible! Competitors: Team Jack @averysmith Jack Blandin @KeithGalli Team MMA @AlexTheAnalyst @nerdnourishment @Miki_ML Team Null Nick Singh Mark Freeman @SeattleDataGuy Team Shashank @ShashankData Team Posit-ively Skewed Greg Coquillo @datascienceharp Richad Nieves-Becker Ian Greengross Interviewer: Elijah Butler - https://www.tiktok.com/@imelijahbutler Posit Team - Michael Chow - Joe Cheng - Carolos Scheidegger - Julia Silge Sponsors, Affiliates, and Partners: - Pathrise - http://pathrise.com/KenJee | Career mentorship for job applicants (Free till you land a job) - Taro - http://jointaro.com/r/kenj308 (20% discount) | Career mentorship if you already have a job - 365 Data Science (57% discount) - https://365datascience.pxf.io/P0jbBY | Learn data science today - Interview Query (10% discount) - https://www.interviewquery.com/?ref=kenjee | Interview prep questions MORE DATA SCIENCE CONTENT HERE: My Twitter - https://twitter.com/KenJee_DS LinkedIn - https://www.linkedin.com/in/kenjee/ Kaggle - https://www.kaggle.com/kenjee Medium Articles - https://medium.com/@kenneth.b.jee Github - https://github.com/PlayingNumbers My Sports Blog -https://www.playingnumbers.com Check These Videos Out Next! My Leaderboard Project: https://www.youtube.com/watch?v=myhoWUrSP7o&ab_channel=KenJee 66 Days of Data: https://www.youtube.com/watch?v=qV_AlRwhI3I&ab_channel=KenJee How I Would Learn Data Science in 2021: https://www.youtube.com/watch?v=41Clrh6nv1s&ab_channel=KenJee My Playlists Data Science Beginners: https://www.youtube.com/playlist?list=PL2zq7klxX5ATMsmyRazei7ZXkP1GHt-vs Project From Scratch: https://www.youtube.com/watch?v=MpF9HENQjDo&list=PL2zq7klxX5ASFejJj80ob9ZAnBHdz5O1t&ab_channel=KenJee Kaggle Projects: https://www.youtube.com/playlist?list=PL2zq7klxX5AQXzNSLtc_LEKFPh2mAvHIO

Joe Cheng, Julia Silge, Michael Chow

Talks - Michael Chow, Richard Iannone: Making Beautiful, Publication Quality Tables in Python...

Full title: Making Beautiful, Publication Quality Tables in Python is Possible in 2024 Tables are undeniably useful for data work. We have many excellent DataFrame libraries in Python and they give us the flexibility to manipulate data to our hearts content. But what happens when comes to presenting tables to others? The display of tables can be beautiful. Tables can convey information effectively, just as plots do and, sometimes, it’s the better way to present data. Truly, the time has come to bridge the divide between raw DataFrame output and wondrously-structured tables suitable for publication. Let's review the state of ‘display tables’ in 2024. We’ll go over which table components make for effective displays of information. It’s surprising but there are many considerations that go into making a well-crafted table. We’ll take a look at the combinations of Python packages that fit together to make this important task possible, and marvel together at the tabular results they can provide

Michael Chow

Great Tables: Make beautiful, publication quality tables in Python | Rich Iannone & Michael Chow

Tables are undeniably useful for data work. We have many great DataFrame libraries available in Python, and they give us flexibility in terms of manipulating data at will, but what happens when presenting tables to others? It's nice to display tables. Tables can efficiently carry information, just like plots do, and at times it is the better way of presenting data. Indeed, it is time to bridge the divide between raw DataFrame output and wondrously structured tables suitable for publication. Now, let us turn our attention to the state of 'display tables' in 2024. Let us go over what comprises key components for building effective information displays in tables. It may surprise one how new a well-crafted table can be hewn. We'll take a look at the combinations of Python packages that fit together to make this important task possible, and marvel together at the tabular results they can provide! Learn more at https://posit-dev.github.io/great-tables/ Timestamps: 0:00 Intro: Meet Rich and Michael 0:41 What we mean by "publication ready tables" 1:29 Overview of what we'll talk about in this video 1:44 Table Goals: Ways to make a table beautiful 4:41 Tables made from reproducible code! 5:11 The history of table generation to influence our API 6:15 Our modern take on a table display framework 6:35 The problem with Excel 7:38 Introducing Great Tables! 8:00 Key Ingredients of making a Great Table 8:24 Structure: Title, column spanners and nice column labels 8:52 Format: Compact dollar values and percentages 9:23 Styling: Fill color and bold text 10:09 Imports and Polars Selectors 11:08 Coding the structure 12:27 Coding the format 13:07 Coding the styling 15:03 Putting images and plots in your table cells 15:49 Advanced Design 16:07 .fmt_nanoplot(): Small plots within table cells 19:08 .data_color(): Heat maps in tales 20:51 Powerful and plentiful methods to format cell values 22:48 To sum up: TABLES RULE

Michael Chow, Rich Iannone

Build Captivating Display Tables in Python With Great Tables | Real Python Podcast #214

Do you need help making data tables in Python look interesting and attractive? How can you create beautiful display-ready tables as easily as charts and graphs in Python? This week on the show, we speak with Richard Iannone and Michael Chow from Posit about the Great Tables Python library. Links from the show: https://realpython.com/podcasts/rpp/214/ Michael and Richard discuss the design philosophy and history behind creating display tables. We dig into the grammar of tables, the background of the project, and an ingenious way to build a collection of examples for a library. We briefly cover how Richard and Michael started contributing to open source. We also discuss practicing data skills with challenges and resources like Tidy Tuesday. This episode is sponsored by Mailtrap. Topics: - 00:00:00 -- Introduction - 00:02:00 -- Michael's background in open source - 00:04:07 -- Rich's background in open source - 00:05:27 -- Advice for someone starting out - 00:08:55 -- What do you mean by the term "display" table - 00:11:32 -- What components were missing from other tables? - 00:13:31 -- Using examples to explain features - 00:16:09 -- Why was there an absence of this functionality in Python? - 00:19:35 -- A progressive approach and the grammar of tables - 00:21:26 -- Sponsor: Mailtrap - 00:22:01 -- The design philosophy of great tables - 00:25:31 -- Nanoplots, spark lines, and column spanners - 00:27:06 -- Building a gallery of examples - 00:28:56 -- Heat mapping cells and automatically adjusting text color - 00:32:54 -- Output formats for the tables - 00:34:46 -- Building in accessibility - 00:36:55 -- Dependencies - 00:37:42 -- What is the common workflow? - 00:41:39 -- Video Course Spotlight - 00:43:15 -- Adding graphics - 00:46:41 -- Using a table contest to get examples - 00:49:47 -- quartodoc and documenting the project - 00:55:00 -- Tidy Tuesday and data science community - 01:00:29 -- What are you excited about in the world of Python? - 01:03:46 -- What do you want to learn next? - 01:08:05 -- How can people follow the work you do online? - 01:09:57 -- Thanks and goodbye Links from the show: https://realpython.com/podcasts/rpp/214/

Michael Chow

Announcing Shiny for Python 1.0

Shiny for Python's level of quality, runtime stability, API and feature set make it ready for a big announcement

Shiny Team

How to make Interactive Python Dashboards! (Reactivity in Shiny)

This is a quick-start guide to Shiny for Python, part 2 of a multi-part series. Data scientists need to quickly build web applications to create and share interactive visualizations, giving others a way to interact with data and analytics. Shiny helps you do this. In this video, we'll build off of the last tutorial where we learned the basics of building, sharing, and deploying a Shiny app in Python. This video specifically focuses on reactivity in Shiny. You can watch this video as a standalone, but it may be helpful to watch the previous video (https://youtu.be/I2W7i7QyJPI). We'll cover: ⬡ Creating toggle options for dynamic visualizations ⬡ Understanding Shiny's reactivity model ⬡ Implementing various input selectors ⬡ Building reactive components and visualizations ⬡ Using reactive calculations and effects ⬡ Adding and formatting plots with Plotly ⬡ Documentation walkthrough to learn more about reactivity (reactivity.effect, reactivity.event, reactivity.isolate, reactivity.invalidate_later, etc…) Video Resources: Video #1: https://youtu.be/I2W7i7QyJPI?si=nx1dk5ovPc91pvlB Starter Code (from end of video #1): https://github.com/KeithGalli/shiny-python-projects/tree/video1 Final App: https://keithgalli.shinyapps.io/final-app/ Shiny Resources: Shiny for Python Homepage: https://shiny.posit.co/py/ Component Gallery: https://shiny.posit.co/py/components/ Express Documentation: https://shiny.posit.co/py/api/express/ Gordon Shotwell’s “How does Shiny Render Things?”: https://youtu.be/jvV4y2xogf8?si=8uGP8ZfboUj1QM4p Joe Cheng’s “Shiny Programming Practices”: https://youtu.be/B2JzHv4FOTU?si=t4Atii-RSc5ojgom Stay tuned for part 3, where we'll explore how to make your dashboard look more professional (layouts in Shiny). Video by @KeithGalli --- Video Timeline! 0:00 - Intro & Overview 1:01 - Getting Started with Code 2:08 - Adding Shiny Components (Inputs, Outputs, & Display Messages) 3:21 - Creating an Additional Visualization (Sales Over Time by City) 7:55 - What are Reactive.Calcs and How Do We Use Them Properly? (DataFrame Best Practices) 10:27 - Creating an Additional Visualization (Sales Over Time by City) — Continued 14:30 - Filtering City Data with Select Inputs (UI.Input_Selectize) 21:15 - Rendering Shiny Inputs Within Text 22:15 - Quick Formatting Adjustments 22:54 - Understanding the Shiny Reactivity Model (How Does Shiny Render Things?) 24:23 - Adding a Checkbox Input to Change Out Bar Chart Marker Colors 28:00 - Deploying Our Updated App! 29:19 - Advanced Concepts in Shiny Reactivity (Reactive.Effect, Reactive.Event, Reactive.Isolate, Reactive.Invalidate_Later) & Other Resources All videos in the series: Part 1 - How to Build, Deploy, & Share a Python Application in 20 minutes! (Using Shiny): https://www.youtube.com/watch?v=I2W7i7QyJPI&t=0s Part 2 - How to make Interactive Python Dashboards! (Reactivity in Shiny): https://www.youtube.com/watch?v=SLkA-Z8HTAE&t=0s Part 3 - How to make your Python Dashboard look Professional! (Layouts in Shiny): https://www.youtube.com/watch?v=jemk7DoN4qk&t=0s Part 4 - How to combine Matplotlib, Plotly, Seaborn, & more in a single Python Dashboard! (Shiny for Python): https://youtu.be/xDgO5hB4-VU?si=kk20yhdpsBqkMYcC Part 5 - How to Perfect Your Python Dashboard with Advanced Styling! (HTML/CSS - Shiny for Python): https://youtu.be/uYZUS-eFbqw

Joe Cheng

{shinylive}: Serverless Shiny Apps | Barret Schloerke | Posit

In the rapidly evolving landscape of web technologies, the integration of R (and Python) with modern web frameworks has become increasingly important for data scientists and developers. This presentation introduces {shinylive}, a new R package that exports Shiny applications to be run within statically hosted websites. We will explore the capabilities of {shinylive} through its use of the innovative R package {webR}, which allows for the execution of R code in the browser (via WebAssembly and service workers) without the need for a centralized server. The presentation will cover the technical foundation of {shinylive}, including its architecture and the integration process with Quarto documents. We will also discuss the practical aspects and drawbacks of exporting Shiny apps with {shinylive}, highlighting the ease of exporting apps to a folder for local use or hosting them on GitHub pages. {shinylive} bridges the gap between Shiny and static websites, making it a valuable resource for interactive data analysis and presentation. Link to app: https://schloerke.com/presentation-2024-04-18-appsilon-shinylive/ Link to script: https://github.com/posit-dev/r-shinylive/blob/main/examples/deploy-app.yaml Link to use_github_action(): https://github.com/posit-dev/r-shinylive#github-pages Shinylive website: https://posit-dev.github.io/r-shinylive/ {webr} docs: https://docs.r-wasm.org/webr/latest/

Barret Schloerke

Joe Cheng | Managing long-running operations in Shiny | Posit

It’s been years since Shiny evolved to allow asynchronous operations within applications, improving scalability. The introduction of the {promises} package enabled concurrent processing between multiple Shiny sessions, a significant step forward in handling background tasks. However, this did not address the need for intra-session concurrency, where users expect to interact with the application while long-running calculations are executed in the background. Recently, we added a new ExtendedTask feature to Shiny to allow for such intra-session concurrency. This new feature provides a different approach for developers to incorporate asynchronous tasks, enabling smoother user interactions during intensive computations. Alongside ExtendedTask, this talk will also discuss newer methods for launching asynchronous tasks, besides the usual {future} package. The focus will be on the practical application and integration of these features into Shiny applications. Links mentioned in the video: ⬡ Shiny in Production: Principles, practices, and tools, https://youtu.be/Wy3TY0gOmJw?feature=shared Timestamps: 0:20 Make your slow code fast 1:43 Long-running operations are a problem 3:28 Inter-session concurrency and intra-session concurrency 4:24 Introducing ExtendedTask 5:17 Demo of a slow API using ExtendedTask 6:13 Slow code example (R) 7:16 Fix slow code with ExtendedTask (R) 8:55 Slow code example (Python) 7:16 Fix slow code with ExtendedTask (Python) 10:46 Links to get started 11:06 ExtendedTask backstory intro 11:28 ExtendedTask vs. Shiny Async 15:50 How reactive programming works in Shiny 21:31 How ExtendedTask works in the reactive process 25:38 What we’re still working on 26:35 {future} alternatives 31:47 Wrapping up

Joe Cheng

Using your dataset in Shiny Templates | Carson Sievert | Posit

Watch the Shiny team’s Carson Sievert change the dataset in a Shiny Template. Find the right template for you at https://shiny.posit.co/py/templates/ 0:00 Intro with Carson Sievert 0:19 How to load the template code 1:14 Running your Shiny app in VS Code with a live reloading preview 1:29 How this template works 2:23 See the contents of your data in a data_frame 2:53 How this template imports data 3:33 A more optimized way to import a large amount of data 5:10 Changing the dataset 5:44 Troubleshooting the inevitable errors when changing the dataset

Carson Sievert, Shiny Team

Introducing Shiny for Python Templates | Carson Sievert | Posit

Last month we introduced the Shiny for Python Components and Layouts galleries, which are a simple, visual overview of what Shiny can do, mixed with cheatsheet-like information. They are for new and seasoned users alike. We’re excited to announce a third section which brings those two things together into opinionated boilerplate code: Shiny Templates. This is just a start… We expect this gallery to grow as time goes on. These will allow you to hit the ground running, whether you need a quick simple app or a quick complicated one . Get started at https://shiny.posit.co/py/templates/ 0:00 Introduction to Shiny for Python Templates 0:38 How to work with a template locally in VS Code 2:24 Preview your app with the Shiny for Python VS Code Extension 2:45 A data_frame is a quick and easy way to see the contents of your data 4:39 See everything in your window with the “fillable=True” page_opts 5:16 Modifying inputs 7:40 Fix the logic in your @render.plot to show your modified inputs 9:00 Add a component to the sidebar 9:05 How to add input_dark_mode to your app 9:54 How to make your plot change to dark mode as well

Carson Sievert

How to write and deploy a Python web app with Shiny Express and Posit Team

Winston Chang at Posit joined us to share a quicker and simpler way of writing Shiny applications in Python, called Shiny Express With Shiny Express you can create interactive data dashboards and data-driven applications faster than ever. Helpful resources: ️ Introducing Shiny Express: https://shiny.posit.co/blog/posts/shiny-express/ ️ Shinylive: https://shinylive.io/py/examples/ ️ Component Gallery: https://shiny.posit.co/py/components/ ️ VS Code Shiny extension: https://marketplace.visualstudio.com/items?itemName=Posit.shiny-python ️ Q&A recording: https://youtube.com/live/zg4LP4lkihM?feature=share rsconnect-python package: https://pypi.org/project/rsconnect-python/ ️ Follow-up links: Event Survey: https://forms.gle/8AcMAnjfPFSTQZJK6 Posit Team: https://posit.co/products/enterprise/team/ Request evaluation: pos.it/chat-with-us Posit Team demo resources: pos.it/demo-resources What will you learn? If you’re new to Shiny → you’ll get started writing and deploying your first Shiny Express application in Python. If you already know Shiny → you’ll see how Shiny Express can make your development experience quicker and more efficient. Happy with the way things are? No need to change what you’re doing! We think of Shiny Express and Shiny Core as complementary, and intend to support both syntaxes indefinitely. Last month’s Workflow with Posit Team Demo featured Shiny in R and used bslib for custom theming, which you can check out here in the recording: https://youtu.be/O6WLERr5bKU?feature=shared LIVE Q&A ROOM for ~11:30 am on Feb 28th: https://youtube.com/live/zg4LP4lkihM?feature=share There is no need to register; join us here on YouTube at the time above or you can add to your calendar using the link below: pos.it/team-demo We host these Workflow Demos on the last Wednesday of every month, so you can use the link above to add the recurring event as well. #python

Winston Chang

AI and Shiny for Python: Unlocking New Possibilities - posit::conf

Presented by Winston Chang In the past year, people have come to realize that AI can revolutionize the way we work. This talk focuses on using AI tools with Shiny for Python, demonstrating how AI can accelerate Shiny application development and enhance its capabilities. We'll also explore Shiny's unique ability to interface with AI models, offering possibilities beyond Python web frameworks like Streamlit and Dash. Learn how Shiny and AI together can empower you to do more, and do it faster. Presented at Posit Conference, between Sept 19-20 2023, Learn more at posit.co/conference. -------------------------- Talk Track: I can't believe it's not magic: new tools for data science. Session Code: TALK-1153

Winston Chang

20 questions and AI chat bots - posit::conf(2023)

Presented by Winston Chang Presented at Posit Conference, between Sept 19-20 2023, Learn more at posit.co/conference. -------------------------- Talk Track: I can't believe it's not magic: new tools for data science. Session Code: TALK-1153

Winston Chang

ShinyUiEditor: From Alpha to Powerful Shiny App Development Tool - posit::conf(2023)

Presented by Nick Strayer Since its alpha debut at last year's conference, the ShinyUiEditor has experienced continuous development, evolving into a powerful tool for crafting Shiny app UIs. Some key enhancements include the integration of new bslib components and the editor's ability to create or navigate to existing server bindings for inputs and outputs. In addition to new features, the editor is now available as a VSCode extension enabling it to integrate smoothly into more developers' workflows. This talk will showcase how these new capabilities empower users to efficiently create visually appealing and production-ready applications with ease. Presented at Posit Conference, between Sept 19-20 2023, Learn more at posit.co/conference. -------------------------- Talk Track: Shiny user interfaces. Session Code: TALK-1126

Nick Strayer

Siuba and duckdb: Analyzing Everything Everywhere All at Once - posit::conf(2023)

Presented by Michael Chow Every data analysis in Python starts with a big fork in the road: which DataFrame library should I use? The DataFrame Decision locks you into different methods, with subtly different behavior:: - different table methods (e.g. polars `.with_columns()` vs pandas `.assign()`) - different column methods (e.g. polars `.map_dict()` vs pandas `.map()`) In this talk, I'll discuss how siuba (a dplyr port to python) combines with duckdb (a crazy powerful sql engine) to provide a unified, dplyr-like interface for analyzing a wide range of data sources‚ whether pandas and polars DataFrames, parquet files in a cloud bucket, or pins on Posit Connect. Finally, I'll discuss recent experiments to more tightly integrate siuba and duckdb. Presented at Posit Conference, between Sept 19-20 2023, Learn more at posit.co/conference. -------------------------- Talk Track: Databases for data science with duckdb and dbt. Session Code: TALK-1101

Michael Chow

Running R-Shiny without a Server - posit::conf(2023)

Presented by Joe Cheng A year ago, Posit announced ShinyLive, a deployment mode of Shiny that lets you run interactive applications written in Python, without actually running a Python server at runtime. Instead, ShinyLive turns Shiny for Python apps into pure client-side apps, running on a pure client-side Python installation. Now, that same capability has come to Shiny for R, thanks to the webR project. In this talk, I'll show you how you can get started with ShinyLive for R, and why this is more interesting than just cheaper app hosting. I'll talk about some of the different use cases we had in mind for ShinyLive, and help you decide if ShinyLive makes sense for your app. Presented at Posit Conference, between Sept 19-20 2023, Learn more at posit.co/conference. -------------------------- Talk Track: I can't believe it's not magic: new tools for data science. Session Code: TALK-1151

Joe Cheng

Quickly get your Quarto HTML theme in order - posit::conf(2023)

Presented by Greg Swinehart A 5-minute talk to discuss how I've used Quarto and Bootstrap variables to quickly make Shiny's new website look as it should. The Quarto user I have in mind works at an organization with specific brand guidelines to follow. I‚ will discuss how to set up your theme, show some key Quarto settings, and how Bootstrap‚ Sass variables are your best friend. Presented at Posit Conference, between Sept 19-20 2023, Learn more at posit.co/conference. -------------------------- Talk Track: Lightning talks. Session Code: TALK-1170

Greg Swinehart

Towards the Next Generation of Shiny UI

Presented by Carson Sievert Create awesome looking and feature rich Shiny dashboards using the bslib R package. Shiny recently celebrated its 10th birthday, and since its birth, has grown tremendously in many areas; however, a hello world Shiny app still looks roughly like it did 10 years ago. The bslib R package helps solve this problem making very easy to apply modern and customizable styling your Shiny apps, R Markdown / Quarto documents, and more. In addition, bslib also provides dashboard-focused UI components like expandable cards, value boxes, sidebar layouts, and more to help you create delightful Shiny dashboards. Materials: - https://rstudio.github.io/bslib/ - https://bslib.shinyapps.io/flights/ Presented at Posit Conference, between Sept 19-20 2023, Learn more at posit.co/conference. -------------------------- Talk Track: Shiny user interfaces. Session Code: TALK-1124

Carson Sievert

"Shiny: Data-centric web applications in Python" - Joe Cheng (PyBay 2023)

Joe Cheng https://pybay.com/speakers/#sz-speaker-7e5324de-3afa-4614-a498-562bd5eb9986 Shiny is a web framework that is designed to let you create data dashboards, interactive visualizations, and workflow apps in pure Python or R. Shiny doesn't require knowledge of HTML, CSS, and JavaScript, and lets you create data-centric applications in a fraction of the time and effort of traditional web stacks. Of course, Python already has several popular and high-quality options for creating data-centric web applications. So it's fair to ask what Shiny can offer the Python community. In this talk, I will introduce Shiny for Python and answer that question. I'll start with some basic demos that show how Shiny apps are constructed. Next, I'll explain Transparent Reactive Programming (TRP), which is the animating concept behind Shiny, and the reason it occupies such an interesting place on the ease-vs-power tradeoff frontier. Finally, I'll wrap up with additional demos that feature interesting functionality that is made trivial with TRP. This talk should be interesting to anyone who uses Python to analyze or visualize data, and does not require experience with Shiny or any other web frameworks. PyBay features the most influential speakers presenting the most crucial technologies to help beginners and seasoned developers alike get up-to-date quickly, in a single-track format. Whether you’re interested in web technologies, data, devops, Python internals, or performance, PyBay will help you stay on top of your game AND network with engineers at companies that are hiring! Working remotely and want to meet your teammates to boost team cohesiveness? Leverage the platform we’ve built. There are great talks, yummy food, fresh air, vitamin D... all the elements developers crave for these days. If there are talks that don’t interest your team, take the opportunity to talk to speakers, create your own team activities or book a tee-time at the adjacent miniature golf course! PyBay is the regional Python conference for the San Francisco Bay Area, bringing together Pythonistas from around the Bay Area and beyond. It is a volunteer-run organization dedicated to building a stronger Python community. PyBay offers deep-dive talks and networking opportunities that aim to enrich and empower the Python community. PyBay is part of BAPyA (Bay Area Python Association). BAPyA member organizations are the SF Python, Pyninsula, and BayPIGgies meetups. Produced by NDV: https://youtube.com/channel/UCQ7dFBzZGlBvtU2hCecsBBg?sub_confirmation=1 Sun Oct 8 18:30:00 2023 at Bungalo East

Joe Cheng

Joe Cheng @ Posit | You have to be able to reason about it | Data Science Hangout

We were recently joined by Joe Cheng, CTO at Posit PBC to chat about all things Shiny - a web framework for data scientists, career journeys, being vulnerable, and so much more. At 39:53 - Joe shared what it means when he says, "you have to be able to reason about it" When you write software or do an analysis or whatever, there's a level of “I got it to work” and then there's the level of “it works, and I can reason about it.” Complex pieces of software are among the most complicated things that humankind has ever devised. What other human-made constructs can have hundreds of millions of pieces and yet they're expected to all fit and work together so precisely that, if one token is off, rockets explode. I don't know what the limit is, but even the smartest humans can only hold some small number of variables and operations in their head at any one time. When we work on software that's non-trivial, we work on software that in its totality is more than any one human mind can hold at any one given time. The main challenge in software engineering is about, how do you take all this complexity and break it down into smaller pieces, each of which you can reason about, each of which you can hold in your head, each of which you can look at and say, “Yeah, I can fully ingest this entire function definition. I can read it, line by line, and prove to myself, this is definitely correct if the functions that it's calling don't have bugs and if it's called in the right way.” So with those caveats, if the things that this is calling are correct and are called correctly, then the result will be correct because the logic here is correct. Software engineering, at all but the most beginner level, is a lot about this. How do you break up inherently complicated things that we're trying to do into small pieces that are individually easy to reason about? That's half the battle right there. The other half of the battle is - how do we combine them in ways that can be reliable and also easy to reason about? So it's these two pieces– small pieces reliably composed– if you can achieve that, that's what I'm talking about. That's software that you can reason about. This has implications for data science as well. With data science, you're doing some kind of analysis on some data, and it starts out as, oh, I'm just doing these simple things. I'm doing this manipulation and then I'm doing this visualization. But then as you get deeper and deeper into it, it grows and grows and grows. You're at the point where you're at the end and you don't remember where these variables came from. You don't remember what's the difference between this data frame and this data frame. And you go back and hopefully start breaking it into functions or somehow dividing it into smaller pieces that each focus on a thing. Then you join those pieces together in your overall script. That's this principle of small pieces individually able to be reasoned about. When you think about other rules that you might have heard about software engineering – we know when you're writing functions, using global variables is bad. That's another one of these things where that hurts your ability to hold the entire function in your head and to prove that it'll work correctly. Because who knows who is setting that global variable to what value? You can't prove to yourself this function is definitely correct. I think if there's anything that you're working on that needs to be correct and you do care that the answer is right, I try never to stop when I have an answer but I can't reason about the code. I always try to go back and do the refactoring that's necessary just so I can prove to myself that the answer is right. The other big benefit to this is that those individual pieces– if it does turn out that there's a mistake somewhere, you can individually debug, test, unit test those individual pieces. When there are problems, you'll much more easily be able to find them. ______ ► Subscribe to Our Channel Here: https://bit.ly/2TzgcOu Follow Us Here: Website: https://www.posit.co LinkedIn: https://www.linkedin.com/company/posit-software Twitter: https://twitter.com/posit_pbc To join future data science hangouts, add to your calendar here: pos.it/dsh (All are welcome! We'd love to see you!) Come hangout with us! The Data Science Hangout is a gathering place for the whole data science community - including current and future data science leaders - to chat about data science leadership and questions you're all facing that happens every Thursday at 12 ET

Joe Cheng

Joe Cheng - Shiny: Data-centric web applications in Python | PyData Seattle 2023

www.pydata.org Shiny is a web framework that is designed to let you create data dashboards, interactive visualizations, and workflow apps in pure Python or R. Shiny doesn't require knowledge of HTML, CSS, and JavaScript, and lets you create data-centric applications in a fraction of the time and effort of traditional web stacks. Of course, Python already has several popular and high-quality options for creating data-centric web applications. So it's fair to ask what Shiny can offer the Python community. In this talk, I will introduce Shiny for Python and answer that question. I'll start with some basic demos that show how Shiny apps are constructed. Next, I'll explain Transparent Reactive Programming (TRP), which is the animating concept behind Shiny, and the reason it occupies such an interesting place on the ease-vs-power tradeoff frontier. Finally, I'll wrap up with additional demos that feature interesting functionality that is made trivial with TRP. This talk should be interesting to anyone who uses Python to analyze or visualize data, and does not require experience with Shiny or any other web frameworks. PyData is an educational program of NumFOCUS, a 501(c)3 non-profit organization in the United States. PyData provides a forum for the international community of users and developers of data analysis tools to share ideas and learn from each other. The global PyData network promotes discussion of best practices, new approaches, and emerging technologies for data management, processing, analytics, and visualization. PyData communities approach data science using many languages, including (but not limited to) Python, Julia, and R. PyData conferences aim to be accessible and community-driven, with novice to advanced level presentations. PyData tutorials and talks bring attendees the latest project features along with cutting-edge use cases. 00:00 Welcome! 00:10 Help us add time stamps or captions to this video! See the description for details. Want to help add timestamps to our YouTube videos to help with discoverability? Find out more here: https://github.com/numfocus/YouTubeVideoTimestamps

Joe Cheng

Keynote, Winston Chang: Lessons and opportunities with Shiny for Python

About the keynote: For the past 10 years, the R community has been able to use Shiny to bring interactive data analyses to the web. Last summer, we announced that Shiny would also be available to for Python. In this talk, I’ll discuss what we’ve learned along the way, as well as the opportunities that Shiny for Python opens up. We are at the beginning of an exciting new era for Shiny, and I hope that community of old and new Shiny users make the most of it! Speaker's bio: Winston Chang is a software engineer at Posit, PBC, who has served in various roles on the Shiny team, including team lead. He has contributed to many widely-used packages in the R ecosystem, including Shiny, devtools, and ggplot2, and is the creator of several packages, including shinydashboard, R6, and profvis. Recently he has been busy working on Shiny and Shinylive for Python. Winston has a Ph.D. in psychology from Northwestern University and is the author of the R Graphics Cookbook, published by O’Reilly Media

Shiny Team, Winston Chang

Carson Sievert: Towards the next generation of Shiny UI

About the talk: Shiny, the R package for creating interactive web graphics, recently celebrated its 10th birthday. Since then, Shiny has grown tremendously in many areas (e.g., performance, functionality, extensions, etc); however, a "hello world" Shiny app still looks like it did 10 years ago. This is mostly because Shiny goes to great lengths to ensure backwards compatibility; and as a result, default Shiny UI will likely continue to be based on Bootstrap 3 (a CSS styling framework released in 2010). However, thanks to the new bslib R package, it is now easy to opt-into a modern Bootstrap 5 foundation that "just works" with Shiny, R Markdown, flexdashboard, pkgdown, bookdown, and more. In addition to upgrading Shiny's Bootstrap dependency, bslib also makes it much easier to do custom theming, leverage modern layout techniques, and create custom components (all from R without any CSS/HTML/JS required). At this point, bslib is still maturing, and does not yet provide what we'd consider a "complete UI toolkit", but it should eventually replace and/or improve upon all of Shiny UI. In this talk, I'll highlight bslib features that we're most excited about (e.g., expandable cards, accordions, (sidebar) layouts, input controls, etc.), discuss some best design practices for improving user experience with these tools, and present some real world examples of these tools in action. Speakers' bio: Carson is a software engineer on the Shiny team at Posit. He joined Posit in 2018, and in recent years, has focused primarily on Shiny for Python and improving Shiny UI. The Shiny UI work has manifested in the creation and development of many R packages such as bslib, thematic, htmltools, htmlwidgets, sass, shiny, rmarkdown, flexdashboard, and more. Carson also has a PhD in statistics, is a recipient of the ASA's Chambers Statistical Software Award, has maintained the R package plotly since 2015, authored the book "Interactive data visualization with R, plotly, and shiny", and ran a successful freelance consulting service for numerous years

Carson Sievert, Shiny Team

Why Shiny for Python? - Posit PBC

Learn how Shiny for Python's design philosophy sets it apart from Streamlit, Dash, and traditional web development frameworks. With Shiny for Python out of alpha as of April, many have wondered how it stacks up against other popular alternatives. In this video, Gordon Shotwell -- developer advocate on the Shiny team at Posit -- explores the design philosophy behind Shiny for Python and how it compares to other frameworks for developing data science web applications. If you are a data scientist working mostly in Python, we hope this motivates you to take a serious look at Shiny for Python. Learn more on Posit blog, https://posit.co/blog/why-shiny-for-python/ 00:00 What is Shiny for Python? 03:05 What is Reactivity? 04:19 How does Shiny compare to Streamlit? 05:14 What are the main differences between Streamlit and Shiny for Python? 07:05 Why should I prefer Shiny over Streamlit? 09:09 How does Shiny compare to Dash? 10:22 What is the difference between a stateless and a stateful application? 12:19 Why consider Shiny for Python over Dash? 13:37 Shiny for Python's Design Philosophy

Shiny Team

The Evolution of Shiny with Posit's CTO, Joe Cheng

Posit’s Joe Cheng talks about the evolution of Shiny and the future of Shiny for Python. Joe is one of the original architects of Shiny and leads Posit’s Open Source software development. Learn more about Shiny for Python at shiny.posit.co/py

Joe Cheng

Barret Schloerke: Lessons Learned Testing 2500+ Shiny Apps Every Day

About the Talk: The Shiny team tests 2500+ different combinations of Shiny Applications, R versions, and operating systems to verify no feature regressions occur within the bleeding edge of the Shiny-verse. Over the past few years, we have learned a few lessons to keep our tests robust and honest. There is a non-zero chance that a test failure is not your fault. When working with CI systems, external influences such as installation failures or slower computing power will prevent tests from executing properly. A picture is worth a thousand tests but visual testing is known to have a non-zero false-positive rate. To address this, we have utilized threshold based image comparisons for flaky tests. We have found that it is best to test the minimal amount of content where possible. Changes in App package dependencies can produce unintended changes in expected outputs. These hard learned lessons have reduced unreliable test results allowing the Shiny team to quickly respond to feature regressions. Speaker's bio: Dr. Barret Schloerke is a Software Engineer at Posit. He currently develops and maintains many R packages in the Shiny ecosystem at RStudio including shiny, reactlog, plumber, learnr, leaflet, and shinyloadtest. Dr. Schloerke received his PhD in Statistics from Purdue University under the direction of Dr. Ryan Hafen and Dr. William Cleveland, specializing in Large Data Visualization

Barret Schloerke, Shiny Team

The accidental analytics engineer

There’s a good chance you’re an analytics engineer who just sort of landed in an analytics engineering career. Or made a murky transition from data science/data engineering/software engineering to full-time analytics person. When did you realize you fell into the wild world of analytics engineering? In this session, Michael Chow (RStudio) draws upon his experience building open source data science tools and working with the data science community to discuss the early signs of a budding analytics engineer, and the small steps these folks can take to keep the best parts of Python and R, all while moving towards engineering best practices. Check the slides here: https://docs.google.com/presentation/d/1H2fVa-I4D8ibanlqLutIrwPOVypIlXVzEITDUNzzPpU/edit?usp=sharing Coalesce 2023 is coming! Register for free at https://coalesce.getdbt.com/

Michael Chow

Winston Chang | Running Shiny without a server | RStudio (2022)

Shiny for Python has the ability to be deployed without a server that runs Python. These applications can be served by any web hosting service. They are easily deployed and can scale to handle large amounts of traffic. This mode of deployment is called Shinylive. It works by running Python in the user’s web browser, using Pyodide, which is a version of Python that is compiled to WebAssembly. Shinylive opens up new possibilities for how Shiny applications can be used. In this talk I discuss the advantages and the limitations of Shinylive applications. Session: Some of my best friends use Python

Winston Chang

Nick Strayer | A new way to build your Shiny app's UI | RStudio (2022)

Shiny helps data scientists create web applications without requiring web development experience. However, there's still a steep learning curve for writing the Ui portion of an app. Unlike an app's server code, which typically only uses a few different Shiny-specific functions, the app's UI code is almost entirely made up of functions with strange syntaxes and often surprising interactions with each other. This paradigm requires a very different mindset than your typical R Script. This talk introduces a new tool to help both new and experienced Shiny developers spend less time writing their app's UI and more time doing data science. Session: Pour some glitter on it: Polishing the design of your shiny apps

Nick Strayer

Joe Cheng | The Past and Future of Shiny | RStudio (2022)

Shiny is a package that makes it easy to create interactive web apps using R. It's hard to believe, but it's been ten whole years since the launch of Shiny! I'll mark the occasion by sharing some stories about the creation of Shiny, the conditions that have made it a success over the years, and our plans for the near future. https://shiny.rstudio.com/ Session: Keynote

Joe Cheng

Greg Swinehart | Designing for people is hard | RStudio (2022)

Shiny users can prototype an app in minutes, but... What if it also looked better almost immediately? In this talk, we'll walk through a new look for Shiny's UI, as well as some new functionality. Session: Pour some glitter on it: Polishing the design of your shiny apps

Greg Swinehart

Barret Schloerke | {shinytest2}: Unit testing for Shiny applications | RStudio (2022)

Manually testing Shiny applications is often laborious, inconsistent, and doesn’t scale well. Whether you are developing new features, fixing bug(s), or simply upgrading dependencies, it is critical to know when regressions are introduced. The new {shinytest2} R package provides a toolkit for unit testing Shiny apps and seamlessly integrates with {testthat}. Under the hood, it uses the new {chromote} R package to render apps in a headless Chrome browser with features such as live preview and built in debugging tools. In this talk, you’ll learn how to test Shiny apps by simply recording your actions as code and extending it to test more particular aspects of your app, resulting in fewer bugs and more confidence in future development. Talk materials are available at https://bit.ly/shinytest2-conf22 Session: I like big apps: Shiny apps that scale

Barret Schloerke

Plot Outputs in Shiny for Python || Winston Chang || RStudio

Shiny makes it easy to build interactive web applications with the power of Python’s data and scientific stack. You can try out Shiny for Python without installing a single thing… All in the browser. Learn more about Shiny for Python: https://shiny.rstudio.com/py/ Check out our interactive Shiny for Python examples: https://shinylive.io/py/examples/ Content: Winston Chang (@winston_chang)

Winston Chang

Multiple Inputs in Shiny for Python || Winston Chang || RStudio

Shiny makes it easy to build interactive web applications with the power of Python’s data and scientific stack. You can try out Shiny for Python without installing a single thing… All in the browser. Learn more about Shiny for Python: https://shiny.rstudio.com/py/ Check out our interactive Shiny for Python examples: https://shinylive.io/py/examples/ Content: Winston Chang (@winston_chang)

Winston Chang

Getting Started with Shiny for Python - in the browser! || Winston Chang || Posit

Shiny makes it easy to build interactive web applications with the power of Python’s data and scientific stack. You can try out Shiny for Python without installing a single thing… All in the browser. Learn more about Shiny for Python: https://shiny.rstudio.com/py/ Check out our interactive Shiny for Python examples: https://shinylive.io/py/examples/ Content: Winston Chang (@winston_chang)

Winston Chang

An Interview with Winston Chang: Building a Wordle App with Shiny for Python || RStudio

Shiny makes it easy to build interactive web applications with the power of Python’s data and scientific stack. Learn more about Shiny for Python: https://shiny.rstudio.com/py/ Check out our interactive Shiny for Python examples: https://shinylive.io/py/examples/ Content: Winston Chang (@winston_chang) + Jesse Mostipak (@kierisi) Producer: Jesse Mostipak (@kierisi) Editing and Motion Design: Tony Pelleriti (@TonyPelleriti)

Winston Chang

A Beginner's Guide to Shiny for Python || Winston Chang || Posit

Shiny makes it easy to build interactive web applications with the power of Python’s data and scientific stack. Learn more about Shiny for Python: https://shiny.rstudio.com/py/ Check out our interactive Shiny for Python examples: https://shinylive.io/py/examples/ Content: Winston Chang (@winston_chang) Producer: Jesse Mostipak (@kierisi) Editing and Motion Design: Tony Pelleriti (@TonyPelleriti)

Winston Chang

Shiny UI Editor Project Walkthrough || Nick Strayer || RStudio

The Shiny UI Editor is a dynamic drag-and drop interface to help you design beautiful Shiny apps. The Shiny UI Editor is a visual tool for building the UI portion of a Shiny application that generates clean and human-readable code. The goal of the Shiny UI Editor is to allow people to build the broad-level UI for their Shiny app without writing code. The editor is intended for those who may not be comfortable with the HTML-style code of Shiny’s UI functions or who simply don’t want to fiddle with sizes to get things laid out correctly. Learn more about the Shiny UI Editor here: https://rstudio.github.io/shinyuieditor/ And read up on GridLayout here: https://rstudio.github.io/gridlayout Content: Nick Strayer (@NicholasStrayer) Producer: Jesse Mostipak (@kierisi) Editing and Motion Design: Tony Pelleriti (@TonyPelleriti)

Nick Strayer

Shiny UI Editor Feature Tour || Nick Strayer || Posit (RStudio)

The Shiny UI Editor is a dynamic drag-and drop interface to help you design beautiful Shiny apps. The Shiny UI Editor is a visual tool for building the UI portion of a Shiny application that generates clean and human-readable code. The goal of the Shiny UI Editor is to allow people to build the broad-level UI for their Shiny app without writing code. The editor is intended for those who may not be comfortable with the HTML-style code of Shiny’s UI functions or who simply don’t want to fiddle with sizes to get things laid out correctly. Learn more about the Shiny UI Editor here: https://rstudio.github.io/shinyuieditor/ And read up on GridLayout here: https://rstudio.github.io/gridlayout Content: Nick Strayer (@NicholasStrayer) Producer: Jesse Mostipak (@kierisi) Editing and Motion Design: Tony Pelleriti (@TonyPelleriti)

Nick Strayer

Wrangling data for a Shiny app in Python || Michael Chow || Posit

Shiny makes it easy to build interactive web applications with the power of Python’s data and scientific stack. Learn more about Shiny for Python: https://shiny.rstudio.com/py/ Check out our interactive Shiny for Python examples: https://shinylive.io/py/examples/ Content: Michael Chow (@chowthedog) Producer: Jesse Mostipak (@kierisi) Editing and Motion Design: Tony Pelleriti (@TonyPelleriti)

Michael Chow

Shiny Programming Practices || Joe Cheng || Posit

Have you ever wanted to sit down and talk with Joe Cheng, the creator of Shiny and CTO of Posit (RStudio) and ask him how he approaches programming? Look no further - we've got that conversation for you right here! Shiny makes it easy to build interactive web apps straight from R or Python. You can host standalone apps on a webpage or embed them in Markdown-style documents or build dashboards. You can also extend your Shiny apps with CSS themes, htmlwidgets, and JavaScript actions. Learn more about Shiny: https://shiny.rstudio.com/ Check out Shiny for Python: https://shiny.rstudio.com/py/ Explore our interactive Shiny for Python examples: https://shinylive.io/py/examples/ Content: Joe Cheng (@jcheng) Producer: Jesse Mostipak (@kierisi) Editing and Motion Design: Tony Pelleriti (@TonyPelleriti)

Joe Cheng

Shinywidgets - An Overview || Carson Sievert || RStudio

Shiny makes it easy to build interactive web applications with the power of Python’s data and scientific stack. Shinywidgets lets you use ipywidgets in Shiny for Python applications. We called it ipyShiny during development, but we're launching as Shinywidgets! Learn more about how to integrate them into your Shiny for Python apps. . Learn more about Shiny for Python: https://shiny.rstudio.com/py/ Check out our interactive Shiny for Python examples: https://shinylive.io/py/examples/ Content: Carson Sievert (@cpsievert) Producer: Jesse Mostipak (@kierisi) Editing and Motion Design: Tony Pelleriti (@TonyPelleriti)

Carson Sievert

Hello, World! A Quick Tour of Shiny for Python || Carson Sievert || Posit

Shiny makes it easy to build interactive web applications with the power of Python’s data and scientific stack. Learn more about Shiny for Python: https://shiny.rstudio.com/py/ Check out our interactive Shiny for Python examples: https://shinylive.io/py/examples/ Content: Carson Sievert (@cpsievert) Producer: Jesse Mostipak (@kierisi) Editing and Motion Design: Tony Pelleriti (@TonyPelleriti)

Carson Sievert

Data visualization and plotting with Shiny for Python || Carson Sievert || RStudio

Shiny makes it easy to build interactive web applications with the power of Python’s data and scientific stack. Learn more about Shiny for Python: https://shiny.rstudio.com/py/ Check out our interactive Shiny for Python examples: https://shinylive.io/py/examples/ Content: Carson Sievert (@cpsievert) Producer: Jesse Mostipak (@kierisi) Editing and Motion Design: Tony Pelleriti (@TonyPelleriti)

Carson Sievert

Getting Started with {shinytest2} Part I || Example + basics || RStudio

00:00 Introduction 00:48 Overview of the demo Shiny app 03:00 Running record_test() 04:44 Results from record_test() 07:18 A note on .png files created during testing 08:52 Debugging with shinytest2 09:32 Using app$view() to open a visual representation of a headless browser Part 2 - Exporting values: https://youtu.be/7KLv6HdIxvU Part 3 - Using shiny.testmode: https://youtu.be/xDxa_mDwN04 Manually testing Shiny applications is often laborious, inconsistent, and doesn’t scale well. Whether you are developing new features, fixing bug(s), or simply upgrading dependencies on a serious app where mistakes have real consequences, it is critical to know when regressions are introduced. shinytest2 provides a streamlined toolkit for unit testing Shiny applications and seamlessly integrates with the popular testthat framework for unit testing R code. shinytest2 uses chromote to render applications in a headless Chrome browser. chromote allows for a live preview, better debugging tools, and/or simply using modern JavaScript/CSS. By simply recording your actions as code and extending them to test the more particular aspects of your application, it will result in fewer bugs and more confidence in future Shiny application development. Read up on shinytest2 here: https://rstudio.github.io/shinytest2/ Learn more about Shiny here: https://shiny.rstudio.com/ Got questions? The RStudio Community site is a great place to get assistance: https://community.rstudio.com/ Content: Barret Schloerke (@schloerke) Motion design and editing: Jesse Mostipak (@kierisi) Theme song: Brad PKL by Blue Dot Sessions (https://app.sessions.blue/browse/track/113507)

Barret Schloerke

Getting Started with {shinytest2} Part 3 || Using shiny.testmode in {shinytest2} || RStudio

00:00 Introduction 00:15 Testing production apps Part 1 - Getting started: https://youtu.be/SS1Na3c8lhk Part 2 - Exporting values: https://youtu.be/7KLv6HdIxvU Manually testing Shiny applications is often laborious, inconsistent, and doesn’t scale well. Whether you are developing new features, fixing bug(s), or simply upgrading dependencies on a serious app where mistakes have real consequences, it is critical to know when regressions are introduced. shinytest2 provides a streamlined toolkit for unit testing Shiny applications and seamlessly integrates with the popular testthat framework for unit testing R code. shinytest2 uses chromote to render applications in a headless Chrome browser. chromote allows for a live preview, better debugging tools, and/or simply using modern JavaScript/CSS. By simply recording your actions as code and extending them to test the more particular aspects of your application, it will result in fewer bugs and more confidence in future Shiny application development. Read up on shinytest2 here: https://rstudio.github.io/shinytest2/ Learn more about Shiny here: https://shiny.rstudio.com/ Got questions? The RStudio Community site is a great place to get assistance: https://community.rstudio.com/ Content: Barret Schloerke (@schloerke) Motion design and editing: Jesse Mostipak (@kierisi) Theme song: Brad PKL by Blue Dot Sessions (https://app.sessions.blue/browse/track/113507)

Barret Schloerke

Getting Started with {shinytest2} Part 2 || Exporting values || RStudio

00:00 Introduction 00:29 Exporting reactives 03:28 Using exportTestValues() Part 1 - Getting started: https://youtu.be/SS1Na3c8lhk Part 3 - Using shiny.testmode: https://youtu.be/xDxa_mDwN04 Manually testing Shiny applications is often laborious, inconsistent, and doesn’t scale well. Whether you are developing new features, fixing bug(s), or simply upgrading dependencies on a serious app where mistakes have real consequences, it is critical to know when regressions are introduced. shinytest2 provides a streamlined toolkit for unit testing Shiny applications and seamlessly integrates with the popular testthat framework for unit testing R code. shinytest2 uses chromote to render applications in a headless Chrome browser. chromote allows for a live preview, better debugging tools, and/or simply using modern JavaScript/CSS. By simply recording your actions as code and extending them to test the more particular aspects of your application, it will result in fewer bugs and more confidence in future Shiny application development. Read up on shinytest2 here: https://rstudio.github.io/shinytest2/ Learn more about Shiny here: https://shiny.rstudio.com/ Got questions? The RStudio Community site is a great place to get assistance: https://community.rstudio.com/ Content: Barret Schloerke (@schloerke) Motion design and editing: Jesse Mostipak (@kierisi) Theme song: Brad PKL by Blue Dot Sessions (https://app.sessions.blue/browse/track/113507)

Barret Schloerke

Hey Shiny Team, what are some of your biggest learnings from 2022? || Shiny Developers || RStudio

BIG THINGS happened on the Shiny team in 2022! Our team built out a new Shiny UI Editor, Shiny for Python, and Shiny for Python in the browser using WebAssembly. So we asked some of our Developers what their biggest learnings have been from building these products! Learn more about Shiny for Python: https://shiny.rstudio.com/py/ Content: Winston Chang (@winston_chang), Carson Sievert (@cpsievert), Nick Strayer (), Michael Chow (@chowthedog) Producer: Jesse Mostipak (@kierisi) Video editing + motion design: Tony Pelleriti (@TonyPelleriti)

Carson Sievert, Michael Chow, Nick Strayer, Shiny Team, Winston Chang

Programming Games with Shiny || Roll the Dice: with Quosures! || RStudio

00:00 Introduction 03:44 The pain of copy + paste 07:28 Going on a helper function adventure! 18:09 Ready for rlang 28:17 !! + enquo() 37:57 Benefits of the rlang approach 38:46 Embracing the embrace operator 41:33 Visualizing what's happening using reactlog You've most likely used Shiny to build a web app that displays data, but you can also use Shiny to build games! In this video series, Jesse and Barret pair program simply games in Shiny as a way to uncover and explore new features. Read up on the embrace operator here: https://rlang.r-lib.org/reference/embrace-operator.html Learn more about Shiny here: https://shiny.rstudio.com/ Got questions? The RStudio Community site is a great place to get assistance: https://community.rstudio.com/ Content: Barret Schloerke (@schloerke) and Jesse Mostipak (@kierisi) Animation, motion design, and editing: Jesse Mostipak (@kierisi) Theme song: Hakodate Line by Blue Dot Sessions (https://app.sessions.blue/browse/track/111291")

Barret Schloerke

Programming Games with Shiny || Roll the Dice || RStudio

00:00 Introduction 01:40 Rolling with eventReactive( ) 06:26 Reducing eventReactive( ) to reactive( ) + isolate( ) 16:23 Combining reactive( ) and bindEvent( ) 20:11 Reviewing our reactives 21:23 Writing a function to de-duplicate dice rolls You've most likely used Shiny to build a web app that displays data, but you can also use Shiny to build games! In this video series, Jesse and Barret pair program simply games in Shiny as a way to uncover and explore new features. Read up on tabset panels here: https://shiny.rstudio.com/reference/shiny/0.14/tabsetPanel.html Learn more about Shiny here: https://shiny.rstudio.com/ Got questions? The RStudio Community site is a great place to get assistance: https://community.rstudio.com/ Content: Barret Schloerke (@schloerke) and Jesse Mostipak (@kierisi) Animation, motion design, and editing: Jesse Mostipak (@kierisi) Theme song: Hakodate Line by Blue Dot Sessions (https://app.sessions.blue/browse/track/111291")

Barret Schloerke

Data Science Hangout | Michael Chow, Posit | Exploring Team Structure w/ Data Scientists & Engineers

We were joined by Michael Chow, Data Scientist and Software Engineer at RStudio. Michael also previously led a team at the California Integrated Travel Project. On this week’s hangout there were a lot of thoughts shared on structuring a data science team from both Michael and the broader group: ⬢ Jacqueline Nolis also shared thoughts on this on a data science hangout that there were virtues to different ones, but ended up sold on the decentralized model where data scientists are embedded in teams: https://youtu.be/CcPE29bYGVo?t=325 ⬢ Michael agreed that data scientists and analysts should be sitting with the teams that they’re pushing out reports for. Otherwise, I would be trying to send people into those teams to figure out their priorities. ⬢ A data scientist should work with a Project Manager or whoever’s leading the team to push up metrics but also help change the roadmap. ⬢ It leaves a tricky question of where data engineers should be and how they should interact with the team. Today data engineers are often doing more tooling empowerment, so it can be okay to have them a bit more centralized and connect to the data scientists to enforce best practices or enable new pieces for them. ⬢ I think a nice model is for data scientists/analysts to live in the teams and data engineers to be like spokes of a wheel where then the data scientists connect with them and work closely to enforce better best practice and enable new important things. ⬢ Tatsu shared that in thinking of the structure, it’s also important to find your translators and to use the power of feedback. Reach out to those people to start to put that feedback into action. ⬢ George shared that insurance companies have come from a really traditional landscape where they have lots of actuaries working on lots of excel spreadsheets and there can be a lack of knowledge sharing and tool sharing. This is where the data science element comes in. To me, within the organization, you need to have this team which is a mini-spoke if you will, because they are central to the actuarial team. If they are too far removed and they’re back with the IT team, you end up with the old problems because they may not get the business concept communicated back. It's all about getting enough skills, so they can get stuff done, especially proof of concepts. Maybe after that you can take a step back and then start to look at the centralized model again. ⬢ A central team can help converge to what they see as best practice, but if you’re pushing out something new, exploring a new line of work or area it can be important to set the data engineer there to actually do whatever they need to. Make sure that the converging doesn’t stifle creativity or prevent a team from doing the right thing. ⬢ Manny jumped in to share the perspective from data science being with IT as well, data science is a new field for their company (in real estate) and there’s an identity of where does data science fall. The IT team is fantastic and they’re very structured. Data science is so fluid and creative and non structured at the moment, so you kind of have to look at where it actually should fall. * please note that some of the points above are summarized and not 100% actual quotes. Resources shared: ⬢ Tatsu shared in the chat, a few projects that Michael is working on: vetiver: https://vetiver.tidymodels.org/articles/vetiver.html, siuba: https://github.com/machow/siuba ⬢ Libby shared a helpful tip on creating a 2 minutes YouTube video with a cover letter, to get the attention of a hiring manager ⬢ Javier shared an example Shiny app used in an interview: https://javierorraca.shinyapps.io/Bloomreach_Shiny_App/ ⬢ Michael mentioned David Robinson’s screencasts: https://www.youtube.com/channel/UCeiiqmVK07qhY-wvg3IZiZQ ⬢ Michael mentioned an article on “What data scientists really do according to 35 data scientists”: https://hbr.org/2018/08/what-data-scientists-really-do-according-to-35-data-scientists ⬢ Rachael shared a blog post link where Jacqueline Nolis talked about team structure as well: https://www.rstudio.com/blog/building-effective-data-science-team-answering-your-questions/#Structure ► Subscribe to Our Channel Here: https://bit.ly/2TzgcOu ► Add the Data Science Hangout to your calendar: rstd.io/datasciencehangout ► View the Data Science Hangout site here: rstudio.com/data-science-hangout Follow Us Here: Website: https://www.rstudio.com LinkedIn:https://www.linkedin.com/company/rstudio-pbc Twitter: https://twitter.com/rstudio

Michael Chow

Programming Games with Shiny || Guess the Number || RStudio

00:00 Introduction 00:35 Setting up our app UI 06:19 Using observeEvent() 10:02 Writing an if else statement as part of our feedback mechanism 13:40 Testing our app and deciding which bugs to fix first 14:20 Check yourself before you req() yourself 17:10 Using tabset panels to control what the user sees You've most likely used Shiny to build a web app that displays data, but you can also use Shiny to build games! In this video series, Jesse and Barret pair program simply games in Shiny as a way to uncover and explore new features. Read up on tabset panels here: https://shiny.rstudio.com/reference/shiny/1.5.0/tabsetPanel.html Learn more about Shiny here: https://shiny.rstudio.com/ Got questions? The RStudio Community site is a great place to get assistance: https://community.rstudio.com/ Content: Barret Schloerke (@schloerke) and Jesse Mostipak (@kierisi) Animation, motion design, and editing: Jesse Mostipak (@kierisi) Theme song: Hakodate Line by Blue Dot Sessions (https://app.sessions.blue/browse/track/91291)

Barret Schloerke

Programming Games with Shiny || Dragon Realm || RStudio

00:00 Introduction 00:05 Fun dragon facts 00:35 Describing the Dragon Realm game 01:20 Outlining our approach 04:38 Coding the basics of our app 10:15 Programming our action buttons 14:10 A note on coding objects "outside" of Shiny 15:27 Programming cave choice logic 20:29 Connecting action buttons to our consequences function 29:40 Creating separate pages using tabsetPanel() 39:35 Conclusion You've most likely used Shiny to build a web app that displays data, but you can also use Shiny to build games! In this video series, Jesse and Barret pair program simply games in Shiny as a way to uncover and explore new features. And because we know you'll ask, Jesse is using the Woodland theme from the base16 palette. You can get it - and other themes - from the {rsthemes} package: https://github.com/gadenbuie/rsthemes Read up on tabset panels here: https://shiny.rstudio.com/reference/shiny/1.5.0/tabsetPanel.html Learn more about Shiny here: https://shiny.rstudio.com/ Got questions? The RStudio Community site is a great place to get assistance: https://community.rstudio.com/ Content: Barret Schloerke (@schloerke) and Jesse Mostipak (@kierisi) Animation, motion design, and editing: Jesse Mostipak (@kierisi) Intro music: RGift by Blue Dot Sessions (https://app.sessions.blue/browse/track/91282) Theme song: Hakodate Line by Blue Dot Sessions (https://app.sessions.blue/browse/track/91291)

Barret Schloerke

Carson Sievert || Using tagQuery() from {htmltools} to modify HTML snippets in R || RStudio

00:00 Introduction 00:45 Motivating example - enabling front-facing camera as an input for fileInput() 01:55 Breaking down the return value of fileInput() 04:16 Design philosophy of fileInput() 07:27 tagAppendAttributes() overview 11:05 tagQuery() basics 12:00 Quick overview of the htmltools package 13:18 How tagQuery() is used to append attributes 20:54 How tagQuery() is used to append children 23:45 Using tagQuery() on an actionButton() Learn more about tagQuery here: https://rstudio.github.io/htmltools/articles/tagQuery.html Read up on tagAppendAttributes() here: https://shiny.rstudio.com/reference/shiny/latest/tagAppendAttributes.html And learn more about the htmltools package here: https://rstudio.github.io/htmltools/index.html Got questions? The RStudio Community site is a great place to get assistance: https://community.rstudio.com/ Content: Developer (@winston_chang) Animation, design, and editing: Jesse Mostipak (@kierisi)

Carson Sievert

Carson Sievert || Customizing Navigation Items in Shiny using {bslib} || RStudio

00:00 Introduction 00:15 Linking inside navbarPage 01:19 Replacing tabPanel with navbarPage, and navbarMenu 02:32 nav_spacer() 03:41 Adding header and//or footer content 04:07 Replacing tabsetPanel with navs_tab and navs_pill 04:32 navs_tab_card() and navs_pill_card() variants 04:40 Demo of all of the nav_*() functions The bslib R package provides tools for customizing Bootstrap themes directly from R, making it much easier to customize the appearance of Shiny apps & R Markdown documents. bslib’s primary goals are: - To make custom theming as easy as possible. - Custom themes may even be created interactively in real-time. - Also provide easy access to pre-packaged Bootswatch themes. - Make upgrading from Bootstrap 3 to 4 (and beyond) as seamless as possible. (Shiny and R Markdown default to Bootstrap 3 and will continue to do so to avoid breaking legacy code.) - Serve as a general foundation for Shiny and R Markdown extension packages. (Extensions such as flexdashboard, pkgdown, and bookdown already fully support bslib’s custom theming capabilities.) You can read more about bslib here: https://rstudio.github.io/bslib/articles/bslib.html And you can learn more about Shiny here: https://shiny.rstudio.com/ Got questions? The RStudio Community site is a great place to get assistance: https://community.rstudio.com/ Content: Carson Sievert (@cpsievert) Design & editing: Jesse Mostipak (@kierisi)

Carson Sievert

Carson Sievert || Developing Shiny Custom Themes in Real Time Using {bslib}| RStudio

00:00 Introduction 00:09 The magic of bs_theme_preview() 01:43 The interactive widget provided by bs_theme_preview() 02:12 Using Bootswatch themes 02:57 Using the interactive widget to adjust your theme in real time 03:38 Integration with Google Fonts 04:22 Thematic is enabled in bs_theme_preview() 04:45 DT tables is enabled in bs_theme_preview() 05:30 Going from the interactive widget to your R code 07:03 Using interactive theming on your own Shiny app 09:01 Interactive theming with R Markdown documents The bs_theme_preview() function launches an example shiny app via run_with_themer() and bs_theme_dependencies(). This is useful for getting a quick preview of the current theme setting as well as an interactive GUI for tweaking some of the main theme settings. Link to docs: https://rstudio.github.io/bslib/reference/bs_theme_preview.html You can read more about the bslib package here: https://rstudio.github.io/bslib/ And you can learn more about Shiny here: https://shiny.rstudio.com/ Got questions? The RStudio Community site is a great place to get assistance: https://community.rstudio.com/ Content: Carson Sievert (@cpsievert) Design and editing: Jesse Mostipak (@kierisi)

Carson Sievert

Carson Sievert || Custom Theming with {bslib} in Shiny and R Markdown using bs_theme() || RStudio

00:00 Introduction 01:15 Jumping right in with the theme argument in Shiny 01:31 Shiny's classic navbarPage using bs_theme() 01:46 Specifying your Bootstrap version 02:31 Using the theme argument in R Markdown 03:17 Custom theming in R Markdown using bs_theme() 04:10 bslib templates provided by RStudio 05:33 Review of common arguments for the theme parameter 08:47 Tips for working with dark themes 10:34 Introduction to the thematic package, which styles plots 12:04 How thematic handles fonts 13:09 Using fonts with bslib in R Markdown 14:36 Moving a theme from an R Markdown document into a Shiny app 16:51 Setting warnings for contrast ratios 18:42 A quick tour of Bootstrap 4 and Bootstrap 5 Sass variables 20:35 A quick overview of writing custom HTML in Shiny 22:15 How bslib automatically handles color contrast ratios bs_theme() allows you to creates a Bootstrap theme object, where you can choose a (major) Bootstrap version, choose a Bootswatch theme (optional), customize main colors and fonts via explicitly named arguments (e.g., bg, fg, primary, etc), and customize other, lower-level, Bootstrap Sass variable defaults via .... You can read more about the bslib package here: https://rstudio.github.io/bslib/ And you can learn more about Shiny here: https://shiny.rstudio.com/ Got questions? The RStudio Community site is a great place to get assistance: https://community.rstudio.com/ Content: Carson Sievert (@cpsievert) Design and editing: Jesse Mostipak (@kierisi)

Carson Sievert

Barret Schloerke || Maximize computing resources using future_promise() || RStudio

00:00 Introduction 01:45 Setting up a multisession using the future package 02:05 Simulation using two workers 04:14 Simulation using 10 workers 05:20 What happens when we run out of workers? 05:35 How Shiny handles future processes like promises 07:16 Introduction to future_promise() 07:45 Demo of the promises package 09:21 Setting the number of workers 10:40 Demo of processing without future_promise() 14:11 Wrapping a slow calculation in a future() 14:53 Demo of processing using Plumber 16:25 Considerations on the number of cores to use 17:21 What happens if we run out of workers? 19:44 Decrease in execution times using future_promise() In an ideal situation, the number of available future workers (future::nbrOfFreeWorkers()) is always more than the number of future::future() jobs. However, if a future job is attempted when the number of free workers is 0, then future will block the current R session until one becomes available. The advantage of using future_promise() over future::future() is that even if there aren’t future workers available, the future is scheduled to be done when workers become available via promises. In other words, future_promise() ensures the main R thread isn’t blocked when a future job is requested and can’t immediately perform the work (i.e., the number of jobs exceeds the number of workers). You can read more about the promises package here: https://rstudio.github.io/promises/articles/shiny.html And you can learn more about Shiny here: https://shiny.rstudio.com/ Got questions? The RStudio Community site is a great place to get assistance: https://community.rstudio.com/ Content: Barret Schloerke (@schloerke) Design and editing: Jesse Mostipak (@kierisi)

Barret Schloerke

Nick Strayer || Part IV: Styling a Shiny Wordle App with CSS || RStudio

00:00 Introduction 00:44 Switching from verbatimTextOutput to uiOutput 01:42 Switching from renderText to HTML DOM elements 03:17 In-line styling with divs 07:30 Converting individual letters from block elements to adjacent grids with CSS grid 08:56 Adding CSS at the head of the UI variable in Shiny with tags$head (and wrapping with HTML!) 10:36 CSS targeting of the background color 12:24 Link: Complete Guide to CSS Grid 14:05 Moving text position within each individual div using CSS classes 16:48 Creating a gap between grid elements 17:13 Rounding border edges for letter grids 19:00 Formatting letter grid background color to indicate result "correctness" 21:30 Increasing font size 23:37 Updating the legend to use color, not text indicators 26:40 Adjusting padding to improve app aesthetic 28:08 Formatting the app UI with justified centering 31:56 Adjusting the text input and Go button 34:07 Why Flexbox is the right tool for this task 35:09 Exploring Flexbox Dev Tools in Chrome 39:14 Adjusting the colors of letter grids using Inspect Element 40:40 Making text bold with font-weight 41:04 Hint on how to approach formatting the keyboard In final installment of this four-part series, RStudio's Nick Strayer walks through using CSS to stylize our Shiny Wordle app. Code + word list: https://github.com/wch/shiny-wordle Check out the full Shiny app here: https://winston.shinyapps.io/wordle/ You can learn more about Shiny here: https://shiny.rstudio.com/ Got questions? The RStudio Community site is a great place to get assistance: https://community.rstudio.com/ Content: Nick Strayer (@NicholasStrayer) Animation, design, and editing: Jesse Mostipak (@kierisi) Music: Lakal by Blue Dot Sessions Wordle: https://www.powerlanguage.co.uk/wordle/

Nick Strayer

Barret Schloerke || {reactlog} Rundown || RStudio

00:00 Introduction to Reactlog 00:44 Viewing Reactlog using an Old Faithful Shiny app 02:07 The Reactlog interface 04:31 Walking through a reactive graph with Reactlog 05:14 Downstream dependency invalidation in Shiny 06:43 How Shiny "grabs" data 09:41 How the Reactlog timeline works 10:46 Switching between idle states in Reactlog 11:58 Reactlog interactivity - clicking a single item 13:21 Reactlog with the Pythagoras Theorem app 15:45 Adding a UI and server value to add Reactlog to your Shiny app 18:05 Walking through the reactive graph using the Pythagorean Theorem app 21:07 Append-only behavior of Reactlog 21:18 Marking a time point in Reactlog 23:17 Using Reactlog to debug reactivity 26:55 Resetting our app and testing logic changes 28:01 Reactlog with a large Shiny app, CRANwhales 34:10 Freezing reactive values 36:19 Calculating click count in a Shiny app 37:10 Click the button, render the plot is bad - see why Shiny is an R package from RStudio that makes it incredibly easy to build interactive web applications with R. Behind the scenes, Shiny builds a reactive graph that can quickly become intertwined and difficult to debug. reactlog provides a visual insight into that black box of Shiny reactivity. After logging the reactive interactions of a Shiny application, reactlog constructs a directed dependency graph of the Shiny’s reactive state at any time point in the record. The reactlog dependency graph provides users with the ability to visually see if reactive elements are: - Not utilized (never retrieved) - Over utilized (called independently many times) - Interacting with unexpected elements - Invalidating all expected dependencies - Freezing (and thawing), preventing triggering of future reactivity There are many subtle features hidden throughout reactlog. Here is a short list quickly describing what is possible within reactlog: - Display the reactivity dependency graph of your Shiny applications - Navigate throughout your reactive history to replay element interactions - Highlight reactive family trees - Filter on reactive family trees - Search for reactive elements You can read more about reactlog here: https://rstudio.github.io/reactlog/articles/reactlog.html And you can learn more about Shiny here: https://shiny.rstudio.com/ Got questions? The RStudio Community site is a great place to get assistance: https://community.rstudio.com/ Content: Barret Schloerke (@schloerke) Design & editing: Jesse Mostipak (@kierisi)

Barret Schloerke

Winston Chang || Part III: Adding a Keyboard to a Wordle Shiny App || RStudio

00:00 Introduction 00:25 Setting up a keyboard 00:54 Using an HTML p tag to print out letter indicators 01:56 Back to our keyboard! 03:44 Setting up a search and replace 06:32 Removing letters using regular expressions 08:43 Making guesses a reactiveVal() 11:00 Avoiding an infinite loop with reactiveVal() In Part III of this four-part series, Winston walks through how to build a keyboard in a Shiny Wordle app. Code + word list: https://github.com/wch/shiny-wordle Check out the full Shiny app here: https://winston.shinyapps.io/wordle/ You can learn more about Shiny here: https://shiny.rstudio.com/ Got questions? The RStudio Community site is a great place to get assistance: https://community.rstudio.com/ Content: Developer (@winston_chang) Animation, design, and editing: Jesse Mostipak (@kierisi) Wordle: https://www.powerlanguage.co.uk/wordle/

Winston Chang