Shiny

Charlie Gao: Advances in the Shiny Ecosystem

Charlie Gao, Senior Software Engineer on Posit’s open source team will review some of the latest high-performance async tooling developed by Posit to support R Shiny in terms of performance, scalability and user experience

Charlie Gao

Shiny for Python

Quick reference guide for shiny for python

Shiny for R

Quick reference guide for shiny for r

Strategic Budget Optimization through Marketing Mix Modeling (MMM)

Stop guessing which channels drive growth. Join Isabella Velásquez and Daniel Chen for this end-to-end workflow demo on modeling marketing spend, building 'what-if' scenario planners in Shiny, and deploying automated Quarto reports that give non-technical stakeholders a clear, data-backed view of ROI. We will explore: 1. The Workflow Architecture: A look at the “plumbing” required to move from data to insights. 2. The Interface: Wrapping an existing model in a Shiny dashboard for real-time “what-if” scenario planning. 3. The Delivery: Automating communication via Quarto reports to keep stakeholders aligned. 4. The Deployment: Using Posit Connect to turn your code into an accessible business asset for leaders. This workflow demo grew out of the incredible energy at our recent Data Science Hangout with Ryan Timpe at LEGO. We were so inspired by the community’s interest in MMM that we decided to build this session to address your specific questions. Thank you for the great discussion. We’re excited to show you what we’ve put together! Demo References MMM Demo GitHub Repo (https://github.com/chendaniely/dashboard-mmm) MMM Demo Dashboard (https://danielchen-dashboard-mmm.share.connect.posit.cloud/) Ryan Timpe’s posit::conf(2023) talk, tidymodels: Adventures in Rewriting a Modeling Pipeline - posit::conf(2023) (https://www.youtube.com/watch?v=R7XNqcCZnLg) MMM Resources Bayesian Media Mix Modeling for Marketing Optimization, PyMC Labs (https://www.pymc-labs.com/blog-posts/bayesian-media-mix-modeling-for-marketing-optimization) Modernizing MMM: Best Practices for Marketers, IAB (https://www.iab.com/wp-content/uploads/2025/12/IAB_Modernizing_MMM_Best_Practices_for_Marketers_December_2025.pdf) The Future of Media Mix Modeling, Measured (https://info.measured.com/hubfs/Guides/Measured_Guide%20The%20Future%20of%20Media%20Mix%20Modeling.pdf?hsCtaAttrib=184767817336) Media Mix Modeling: How to Measure the Effectiveness of Advertising, Hajime Takeda, PyData (https://www.youtube.com/watch?v=u4U_PUTasPQ) An Analyst's Guide to MMM, Meta (https://facebookexperimental.github.io/Robyn/docs/analysts-guide-to-MMM/) Full Python Tutorial: Bayesian Marketing Mix Modeling (MMM) SPECIAL GUEST: PyMC Labs, Matt Dancho (https://www.youtube.com/watch?v=lJ_qq_IVUgg) Reading MMM Outputs: Dashboards and Decisions for Small Teams, SmartSMSSolutions (https://smartsmssolutions.com/resources/blog/business/reading-mmm-dashboards-article)

Driving Shiny adoption by removing friction | Jonathan Lin | Data Science Hangout

ADD THE DATA SCIENCE HANGOUT TO YOUR CALENDAR HERE: https://pos.it/dsh - All are welcome! We'd love to see you! We were recently joined by Jonathan Lin, Adviser of Data Science and AI at Ovintiv, to chat about scaling data science infrastructure with Kubernetes, the "show, don't tell" method for leadership buy-in, creating internal handbooks to support users, and even a little chat around navigating a sparse job market. In this Hangout, we explore Jon's approach to driving adoption and scaling impact without becoming a bottleneck. He discusses moving from simple virtual machines to using Kubernetes to manage memory for over 900 users and 60 publishers (wow!!). John also details how he built a comprehensive internal "handbook" to answer repeated questions, allowing him to support a growing community of R and Python users while encouraging self-service learning. Resources mentioned in the video and zoom chat: Posit Conf 2026 Call for Talks → https://posit.co/blog/posit-conf-2026-call-for-talks/ Data Science Lab → https://pos.it/dslab R Screencasts (David Robinson) → https://www.rscreencasts.com/ Python for Data Analysis (Wes McKinney) → https://wesmckinney.com/book/ Cool 3D printing ggplots and maps using Rayshader! (shared in chat) → https://www.tylermw.com/posts/data_visualization/3d-printing-rayshader.html If you didn’t join live, one great discussion you missed from the zoom chat was about Dragon Boating! Jon coaches a team, and the chat lit up with curiosity, explanations, and excitement about the sport (and its potential crossover with 3D printing paddles? We are the best community). Have you ever watched a dragon boat event?! ► Subscribe to Our Channel Here: https://bit.ly/2TzgcOu Follow Us Here: Website: https://www.posit.co Hangout: https://pos.it/dsh The Lab: https://pos.it/dslab LinkedIn: https://www.linkedin.com/company/posit-software Bluesky: https://bsky.app/profile/posit.co Thanks for hanging out with us! Timestamps: 00:00 Introduction 10:38 "What are tips for navigating a sparse job market?" 14:33 "How do you support all of your users with different skills?" 17:49 "What types of fraud were you working with?" 21:12 "How do you get people to actually read it?" 24:55 "How did you learn R?" 29:18 "What are some techniques you use to get people to trust the tech?" 33:35 "Do you block time each week for documentation?" 36:50 "How would you recommend getting a company to buy in?" 42:15 "How do you pick the topics to learn more about?" 45:34 "Advice on how to overcome fear and feel confident enough to ask questions?" 49:09 "Do you program much in your current position?" 51:34 "Is it truly necessary to have deployment experience to get a data science job?"

Turbocharge your Shiny Apps with remote submission to HPC

Turbocharge your Shiny Apps with remote submission to HPC - Michael Mayer Resources mentioned in the workshop: * Workshop site: https://pub.current.posit.team/public/shiny-remote-hpc/ * Workshop GitHub repository: https://github.com/sol-eng/shiny-hpc-offload

querychat in Python: Query Your Data with Natural Language | Shiny + LLMs | Veerle van Leemput

Learn how to use QueryChat to add natural language querying to your Python data applications. This tutorial shows you how to let users ask questions about data without building complex filters or dashboards. In this video, data scientist Veerle Eeftink demonstrates how to integrate QueryChat with Shiny for Python to create interactive data exploration tools powered by LLMs (Claude, GPT-4, Gemini). What You'll Learn: - Set up QueryChat in minutes with any data source - Understand how QueryChat translates natural language to SQL - Build custom dashboards with reactive data frames - Configure LLM behavior with greetings, data descriptions, and instructions - Ensure safety and read-only access for production environments Key Features: Works with Claude, GPT-4, Gemini, and other LLMs Transparent SQL generation (no black box) Integrates with Shiny, Streamlit, and other frameworks Uses DuckDB or bring your own SQL database Read-only operations for data safety Enterprise-ready with private LLM support Resources: - QueryChat Documentation: [https://posit-dev.github.io/querychat/py/index.html] - Blog Post: "Where Questions Become Queries" [https://shiny.posit.co/blog/posts/querychat-python-r/] - SheScores Demo App [https://github.com/hypebright/shescores-dashboard/tree/main/Python] #Python #DataScience #LLM #AI #Shiny #QueryChat #NaturalLanguage #SQL #DataVisualization Timestamps 00:00 - Introduction: The dashboard problem 01:28 - What is QueryChat? 02:36 - Demo: Three things you'll learn today 03:00 - Setup: LLM API keys and installation 04:04 - Quick start: First QueryChat app in 5 lines 04:27 - Live demo: Natural language queries 06:10 - How QueryChat works under the hood 07:19 - Four benefits: Reliability, transparency, reproducibility, safety 08:17 - Tool calling explained 08:54 - Schema information and DuckDB integration 09:29 - Building custom interfaces 09:45 - Customizing behavior: Greetings and data descriptions 11:16 - Adding custom instructions to the LLM 11:35 - Building a Shiny dashboard with QueryChat 13:09 - Code walkthrough: Sidebar chat and reactive data frames 14:14 - Complete dashboard demo 14:52 - Safety and security deep dive 16:22 - Resources and links

querychat in R: Query Your Data with Natural Language | Shiny + LLMs | Veerle van Leemput

Learn how to use querychat, an R package that lets users query data using natural language instead of predefined filters. Perfect for data scientists who want to build flexible, interactive Shiny dashboards without anticipating every possible user question. In this tutorial, you'll discover: - How querychat translates natural language to SQL using LLMs - Setting up querychat in seconds with your data - Building custom Shiny interfaces with reactive data frames - Why it's reliable, transparent, and safe for production use - Enterprise deployment with Azure, AWS Bedrock, or Google Vertex AI Key Features: Drop-in Shiny component Works with any DBI-compatible database Read-only by design for data safety Full SQL transparency for reproducibility Supports Claude, GPT, Gemini via ellmer Resources: - querychat Documentation: [https://posit-dev.github.io/querychat/py/index.html] - Blog Post: "Where Questions Become Queries" [https://shiny.posit.co/blog/posts/querychat-python-r/ - Github repo: [https://github.com/posit-dev/querychat/tree/main/pkg-r] Perfect for R users working with Shiny, data exploration, and interactive analytics. Timestamps 00:00 - Introduction: The Dashboard Problem 00:50 - Why Dashboards Can't Answer Every Question 01:47 - What is querychat? 02:46 - Getting Started (Installation & Setup) 03:08 - API Key Setup (Claude, GPT, Gemini) 03:20 - First querychat App in 5 Lines of Code 04:04 - Live Demo: Querying Data with Natural Language 05:01 - How querychat Works Under the Hood 06:44 - Four Key Benefits (Reliability, Transparency, Reproducibility, Safety) 07:37 - Tool Calling & DuckDB Integration 08:46 - Building Custom Shiny Interfaces 09:01 - Customizing querychat Behavior (Greetings, Data Descriptions, Instructions) 11:00 - Creating Custom Dashboards with Reactive Data Frames 12:00 - Complete App Structure Walkthrough 13:10 - Safety & Security Deep Dive 14:00 - Enterprise Deployment (Azure, AWS, Google Vertex AI) 15:12 - Resources & Documentation

How to deploy Shiny apps in 2026 | Alex Chisholm | 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 Posit product manager Alex Chisholm as he walks through the evolution of shiny app deployment over the years, how to deploy shiny apps in the modern era, and peeks into Posit's roadmap for future development. Do you call it "deployment" or "publishing" when it comes to Shiny apps? 🤔 This is a super friendly and conversational space, and being there live in the Discord chat can't be beat!! We hope you get to join us sometime soon. Hosting crew from Posit: Libby Heeren, Isabella Velasquez, Daniel Chen, Alex Chisholm Alex Chisholm's LinkedIn: http://www.linkedin.com/in/chisholm1 Resources from the hosts and chat: Posit Connect Cloud for deploying Shiny apps in the modern era: https://connect.posit.cloud/ Install Positron: https://positron.posit.co/ Simon Couch's blog post on local LLMs not being good enough yet: https://www.simonpcouch.com/blog/2025-12-04-local-agents/ Blue-Green Shiny App Deployments using Posit Connect posit::conf(2025) talk by Ryszard Szymański: https://youtu.be/QEEGLWj0nas Digital Ocean: https://www.digitalocean.com/ Ollama local LLM: https://ollama.com/ py-sidebot app template: https://shiny.posit.co/py/templates/sidebot/ querychat app template: https://shiny.posit.co/py/templates/querychat/ Dan Chen mentioned Render in the chat as an alternative to Digital Ocean: https://render.com/ Alex Chisholm's AB testing GitHub repo example: https://github.com/alex-chisholm/shiny-r-abtesting Edward in the chat shared a GitHub repo for using GitHub actions to execute remote SSH commands: https://github.com/appleboy/ssh-action Abu in the chat shared blue-green vs. canary deployments: https://octopus.com/devops/software-deployments/blue-green-vs-canary-deployments/ Frank in the chat mentioned Simon's blog on using local LLMs with the chores package: https://www.simonpcouch.com/blog/2025-12-10-chores-0-3-0/ ► 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 03:03 Meaningful applications and value creation 05:31 The evolution of Shinyapps.io and Posit Connect 08:12 DigitalOcean and Droplets 09:36 DigitalOcean vs. commercial cloud providers, 11:48 Comparisons: DigitalOcean, Azure, and AWS 14:47 Replicating local environments with Docker 16:51 The open-source Shiny Server 18:20 Use case: University of Illinois CITL 20:02 Key considerations for deployment decisions 21:53 GitHub Actions and version control 23:31 Addressing single points of failure and maintainability 24:38 Posit Connect Cloud features and portfolio 26:01 Beyond Shiny: Quarto, Streamlit, and Dash 27:07 Handling secrets and database credentials 28:56 Custom vanity links vs. UUIDs 30:04 Blue-Green deployment strategies 31:55 "Is it easy to set up a developer workflow?" 34:46 Guardrails for AI powered apps and token usage 37:32 Small language models and Ollama 38:29 Sidebot AI demo and LLM integration 39:41 Understanding manifest.json and dependencies 45:00 Automatic publish on GitHub push 46:51 The future of Shinyapps.io and migration 48:33 "Did you just build a custom agent for that specific dashboard?" 51:43 Publishing from RStudio IDE to Connect Cloud 54:16 Preview: Inspecting website APIs for data harvesting

Simon Couch

Integrating Shiny with Epic EHR | Matt Maloney | Data Science Hangout

ADD THE DATA SCIENCE HANGOUT TO YOUR CALENDAR HERE: https://pos.it/dsh - All are welcome! We'd love to see you! We were recently joined by Matt Maloney, Director of Applied AI and Data Science at City of Hope, to chat about applying data science to cancer care operations, integrating open source data science tools like Shiny with Electronic Health Records (like Epic), and the evolving governance of generative AI in healthcare. In this Hangout, we explore the technical and operational strategies behind integrating custom data science applications directly into clinical workflows. Matt discusses how his team moves beyond standalone tools by embedding Shiny apps and other solutions into Epic, allowing medical coders and providers to access predictions and summaries without leaving their primary software environment-of-choice. He also mentions the "build vs. buy" decision-making process as vendors release their own AI solutions, emphasizing the importance of validating external models against their specific patient population. Resources mentioned in the video and zoom chat: City of Hope → https://www.cityofhope.org Unity Health Toronto Customer Story → https://posit.co/about/customer-stories/unity-health-toronto/ pointblank (Data Validation package) → https://rstudio.github.io/pointblank/ If you didn’t join live, one great discussion you missed from the zoom chat was about *where* data science teams sit within community members' organizations and whether they like it or not, specifically the pros and cons of being housed within IT versus embedded inside business units. Participants debated access to infrastructure versus proximity to business stakeholders, with several sharing their own experiences of shifting between these departments (or between companies with different structures). Let us know below if you’d like to hear more about this topic! ► Subscribe to Our Channel Here: https://bit.ly/2TzgcOu Follow Us Here: Website: https://www.posit.co Hangout: https://pos.it/dsh The Lab: https://pos.it/dslab LinkedIn: https://www.linkedin.com/company/posit-software Bluesky: https://bsky.app/profile/posit.co Thanks for hanging out with us! Timestamps: 00:00 Introduction 03:37 "What does the data science function at City of Hope help with?" 08:52 "Tell us a little bit more about how you're integrating Posit with Epic" 16:08 "How do you handle the needs of privacy with the push to adopt AI?" 18:40 "How do you manage to stay abreast of technical advancements?" 22:45 "At what point do you hand off your data work to the software engineering team?" 27:23 "How much has development that involves LLMs and generative AI taken hold?" 30:38 "Does your team evaluate a lot of the things that Epic might be throwing your way?" 34:41 "How does Epic pass an encounter number or a patient ID to Posit Connect?" 35:57 "How does your team handle these nuanced pieces of clinical information?" 40:29 "Do the administrators appreciate the time that it takes to do things?" 44:22 "What happens in the academic division?" 46:10 "Do you have a piece of career advice for us?"

Daniel Chen - LLMs, Chatbots, and Dashboards_ Visualize Your Data with Natural Language - PyData

LLMs have a lot of hype around them these days. Let's demystify how they work and see how we can put them in context for data science use. As data scientists, we want to make sure our results are inspectable, reliable, reproducible, and replicable. We already have many tools to help us in this front. However, LLMs provide a new challenge; we may not always be given the same results back from a query. This means trying to work out areas where LLMs excel in, and use those behaviors in our data science artifacts. This talk will introduce you to LLms, the Chatlas package, and how they can be integrated into a Shiny to create an AI-powered dashboard. We'll see how we can leverage the tasks LLMs are good at to better our data science products

End-to-End Data Science Workflow with the Posit Team Snowflake Native App

Posit Product Manager, Chetan Thapar, demonstrates how the Posit Team Native App for Snowflake delivers an end-to-end workflow—exploration, iteration, and deployment—in minutes, not weeks. Built directly inside the Snowflake security perimeter, the app gives data teams instant access to governed data, managed infrastructure, and familiar tools like Posit Workbench, Connect, and Shiny for Python. Watch how AI assistants like DataBot and Positron accelerate EDA, streamline coding, and help developers build an interactive, LLM-powered dashboard with ease. With one-click deployment and automatic Snowflake governance applied to every user, this demo shows what modern data science looks like when speed, security, and productivity work together. Learn more about the Posit partnership with Snowflake: https://posit.co/use-cases/snowflake/ Get the Posit Team Native App: https://pos.it/Team-Native-App-Snowflake

Hadley Wickham: Spreadsheets, bikes, and the accidental empire of R packages

Before Hadley Wickham became a pillar of modern data science, he was a spreadsheet-loving teenager making databases for his dad’s job. In this episode, he reflects on the early days of his involvement with R, the birth of tidyverse, and how real-world unpredictability — like a bear in a field — shapes data science. Data scientists around the world owe a lot to Hadley Wickham — but how did he go from wrangling databases as a teen to shaping the future of statistical computing? In this episode of The Test Set, Hadley takes us through the winding path of his early days with R, the birth of the tidyverse, and the quirks of open source development. We dig into the philosophies behind his tools, why team dynamics matter, and how large language models are sparking his curiosity all over again. What’s Inside: • Hadley’s first brush with R code … inside a Word doc • Consulting as a grad student — and learning what people really want from stats • How messy Excel sheets inspired the tidy data revolution • Writing R packages as a form of self-defense (and productivity) • The secret sauce of building the tidyverse team • On focus, burnout, and saying “no” to GitHub pull requests • Current obsession: using LLMs to make data science faster, easier, and more fun • How writing books is a form of tidying ideas, and how a Shiny textbook led to a custom bike

Hadley Wickham

James Blair: Part 1 — Portfolios, practice, and staying curious

In Part 1 of our conversation with James Blair, we trace his delightfully non-linear path from childhood robotics dreams to journalism to R, with a few stops in between. We hear about the Shiny app that changed his career, plus a candid roundtable with Michael, Hadley, and Wes about whether a data-science master’s still pays off in the age of AI. This is a story about staying hands-on and fiercely inquisitive — whether analyzing bike telemetry or teaching data science. James shares how early experimentation with Shiny helped shape his career, and how curiosity (not credentials) still powers meaningful work in data science. What’s inside • A winding path from robotics to journalism to psychology to data science • Discovering the power of applied stats • The value (and limits) of a data-science master’s in a shifting AI landscape • Fighting confirmation bias: good analysis resists the answer you want

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

Create and Deploy a Python Shiny Express Application to Connect Cloud

In this video, Daniel Chen demonstrates how to build a Shiny dashboard in Python using Positron. Dan starts by setting up the Python environment and adding necessary packages, then proceeds to create a histogram from the Palmer penguins dataset. Then, he explains how to implement input components, such as radio buttons, and connect them to the visual output. After finalizing the dashboard, Dan shows how to deploy the application to Connect Cloud and publish it for public access. 0:00 Introduction 0:15 Start a new folder in Positron 0:45 Install packages using uv 1:27 Finished app preview 1:50 Shiny app development 13:46 Deploy to Connect Cloud

AskRADS: An AI Recommendation Agent for Maximizing ROI of Data Science Collaborations (Regis James)

AskRADS: An AI Recommendation Agent for Maximizing the ROI of Data Science Collaborations Speaker(s): Regis A. James Abstract: Blockers to crucial data-driven decisions can often be a challenge. To address this, we established RADS, the Regeneron Analysts and Data Scientists, as a Community of Practice for exchanging strategies on eliminating these obstacles. RADS has grown to nearly 500 members, creating a new challenge: avoiding redundancy and helping non-RADS colleagues find the right experts. To solve this, we developed AskRADS, an AI agent on Posit Connect that provides recommendations based on discussions, experts, and relevant resources. It uses R, Shiny for Python, FastAPI, LangGraph, Neo4j GraphRAG, and MySQL. This talk will cover its architecture, AI search solutions, and optimization techniques. posit::conf(2025) Subscribe to posit::conf updates: https://posit.co/about/subscription-management/

Building a Real-Time COVID-19 Surveillance System with R (Hugo Fitipaldi, Lund University)

Building a Real-Time COVID-19 Surveillance System with R: Lessons from the COVID Symptom Study Sweden Speaker(s): Hugo Fitipaldi Abstract: During the COVID-19 pandemic, the COVID Symptom Study Sweden collected over 20 million daily health reports from more than 200K participants. This talk demonstrates how R served as the backbone for transforming this massive dataset into actionable public health insights. I'll showcase our analytics pipeline built entirely in R, from processing raw data to developing an interactive Shiny dashboard for real-time COVID-19 surveillance. The presentation covers predictive modeling for prevalence and hospital admissions estimates and the creation of our 'covidsymptom' R package. Through practical examples, I'll share key learnings about handling large-scale health data and creating data products with R during a public health emergency. posit::conf(2025) Subscribe to posit::conf updates: https://posit.co/about/subscription-management/

Data 911: how Posit can support decision-makers in times of environmental crisis (Marcus Beck)

Data 911: how Posit can support decision-makers in times of environmental crisis Speaker(s): Marcus Beck Abstract: Over 200 million gallons of mining wastewater was released into Tampa Bay in March of 2021. Concerns about the environmental impacts prompted a multi-agency response to monitor water quality changes in the bay, producing thousands of sample points in need of synthesis and communication to a concerned public. This talk will describe how the Tampa Bay Estuary Program leveraged Posit products to create a data synthesis workflow and Shiny dashboard to inform decision-makers on how, where, and when water quality was affected by this pollution. Our experience navigating this event in real time will be shared with the broader community as a successful example of how Posit products can address environmental crises. posit::conf(2025) Subscribe to posit::conf updates: https://posit.co/about/subscription-management/

Design of Everyday Shiny Apps (Casey Aguilar-Gervase & Maya Gans, Atorus) | posit::conf(2025)

Design of Everyday Shiny Apps Speaker(s): Casey Aguilar-Gervase; Maya Gans Abstract: Donald Norman’s Design of Everyday Things shows how even smart people struggle with bad design—flipping the wrong switch, pushing a door instead of pulling. The same issues exist in Shiny apps, where function often outweighs experience. But as a Shiny developer, you are the door designer, and it’s your responsibility to create user-friendly tools. Not to worry—good design isn’t just for designers. You don’t need an art degree to build intuitive, visually appealing apps. This talk covers composition, color theory, scale, and proportion—practical rules to improve usability. We’ll show real-world examples and code-based strategies to bring these principles to life. Because good design isn’t a luxury—it’s a necessity. Materials - https://github.com/caseyag/Posit-Conf-25 posit::conf(2025) Subscribe to posit::conf updates: https://posit.co/about/subscription-management/

Disposable Shiny Apps (James Wade, Dow) | posit::conf(2025)

Disposable Shiny Apps Speaker(s): James Wade Abstract: Many data scientists find themselves building Shiny apps for one-off presentations, client meetings, or teaching demonstrations. These "disposable" apps can suffer from overengineering, leading to unnecessary development time and complexity. Or, the apps never get built because the development hill is too high to climb. This talk covers disposable Shiny apps - intentionally minimal applications designed for specific, short-term needs. We'll explore strategies for rapid development, including reusable templates, coding assistants, efficient styling, and design principles that prioritize speed and clarity. This talk will show how this approach can transform a typical week-long development process into a few hours while maintaining polish. Materials - https://github.com/JamesHWade/posit-conf-2025 posit::conf(2025) Subscribe to posit::conf updates: https://posit.co/about/subscription-management/

Engineer Insightful Shiny Apps with Behavioral Science (Jeremy Winget, CrossStack) | posit::conf

Death by Dropdown? Engineer Insightful Shiny Apps with Behavioral Science Speaker(s): Jeremy Winget, PhD Abstract: Opening a Shiny app to endless dropdowns and scattered filters leads to immediate disengagement and feeling like "death by dropdown". This talk introduces the Behavioral Insights Design (BID) Framework, a behavioral science roadmap that transforms overwhelming dashboards into guided user journeys. Using the "Interfaces Need A Smart Vision" mnemonic, we'll explore five stages: Interpret user needs through data storytelling, Notice cognitive friction points, Anticipate user behavior, Structure the application, and Validate & empower users. Drawing from established theories and real-world production examples, attendees will see how applying behavioral science can dramatically reduce the time between "Where do I even start?" and "Aha, now I get it!". You'll leave with practical techniques using the new {bidux} package to help transform user confusion into confident exploration and build dashboards that guide users toward better decisions (and fewer ghosted users). BID Framework - https://github.com/jrwinget/bid-framework bidux docs - https://github.com/jrwinget/bidux posit::conf(2025) Subscribe to posit::conf updates: https://posit.co/about/subscription-management/

Get Your Ducks in a Row with Databases (Melissa Albino Hegeman, NYS OGS) | posit::conf(2025)

Get your ducks in a row... faster Shiny apps with DuckDB Speaker(s): Melissa Albino Hegeman Abstract: Our small team tackled sluggish Shiny applications by implementing DuckDB as a cache layer, transforming slow, resource-intensive operations into responsive user experiences. Initially, our application pulled data directly from SQL Server, performing real-time aggregations that resulted in poor response times. By restructuring our pipeline to pre-compute results in DuckDB, we significantly improved performance. This presentation demonstrates how we identified bottlenecks, implemented DuckDB integration, and measured improvements. We'll share practical examples of DuckDB integration with R, discuss trade-offs, and show how this accessible solution can benefit other small teams with limited resources. posit::conf(2025) Subscribe to posit::conf updates: https://posit.co/about/subscription-management/

Keeping Data Alive: Persistent Storage Options for Dynamic Cloud Applications (Alex Chisholm, Posit)

Keeping Data Alive: Persistent Storage Options for Dynamic Cloud Applications Speaker(s): Alex Chisholm Abstract: Building cloud-based data applications that evolve over time requires persistent storage solutions. Without a way to record new information or modify datasets, applications like Shiny or Streamlit would reset after each session, losing potentially valuable information. This talk explores persistent storage options ranging from lightweight solutions like Google Sheets to scalable services like Amazon S3 and MotherDuck. We’ll also cover securing connections to these services using Posit Connect Cloud’s secret variable management. By the end, you’ll understand common persistent storage solutions, their trade-offs, and how to choose the best approach for your specific project. Aquarium Search App - https://github.com/alex-chisholm/aquarium-search posit::conf(2025) Subscribe to posit::conf updates: https://posit.co/about/subscription-management/

Lift Off! Building REST APIs that Fly (Joe Kirincic, RESTORE-Skills) | posit::conf(2025)

Lift Off! Building REST APIs that Fly Speaker(s): Joe Kirincic Abstract: Picture the scene: you've successfully deployed your ML model as a plumber API into production. Your company loves it! One team uses the API's predictions as an input to their own ML model. Another team displays the predictions in an internal Shiny app. But once adoption reaches a certain point, your API's performance starts to degrade. What can you do to help your service maintain high performance in the face of high demand? In this talk, we'll show some strategies for taking your API performance to the next level. Using two R packages, {yyjsonr} and {mirai}, we can augment our API with faster JSON processing and better responsiveness through asynchronous computing, allowing our services to do great things at scale at no additional cost. posit::conf(2025) Subscribe to posit::conf updates: https://posit.co/about/subscription-management/

maidr: Empowering Accessible, Multimodal Data Visualizations (JooYoung Seo) | posit::conf(2025)

maidr: Empowering Accessible, Multimodal Data Visualizations Speaker(s): JooYoung Seo Abstract: maidr is a Python package that transforms visualizations into accessible multimodal representations. Designed for both blind/low-vision and sighted users, it integrates with libraries like matplotlib and seaborn and supports interactive environments such as Quarto, Jupyter Notebooks, Google Colab, Streamlit, and Shiny. With a simple function call, maidr synchronizes visual, tactile (Braille), textual, audible (sonification), and conversational outputs, enabling reproducible, inclusive workflows. By creating, modifying and sharing accessible visualizations, maidr fosters collaborative insights by bridging the gap between blind/low-vision and sighted users, empowering inclusive, data-driven decision-making that leverages diverse perspectives. GitHub Repo - https://github.com/xability/py-maidr posit::conf(2025) Subscribe to posit::conf updates: https://posit.co/about/subscription-management/

Modular, layout-as-code approach for customizable Shiny dashboards (Kim Schouten, De NZa)

Modular, layout-as-code approach for customizable Shiny dashboards Speaker(s): Kim Schouten Abstract: To improve government supervision in the healthcare space, we have designed a Shiny dashboard that enables us to adhere to GDPR and other regulations and share different bits of information with different types of stakeholders. For that, we have implemented a ‘layout-as-code’ system where each user can have its own layout of pages and modules, stored as json in the database. Users have the option to drag and drop modules to different locations or change the layout altogether, adding and removing modules as needed! For developers, this system of loosely coupled modules helps to quickly contribute to the project as a new module needs only a couple of lines of code to integrate it within the framework. Materials - https://github.com/KSchouten/elemental posit::conf(2025) Subscribe to posit::conf updates: https://posit.co/about/subscription-management/

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

Old Apps, New Tricks: How AI can write Automated Tests for your Shiny Apps (Karan Gathani, Posit)

Old Apps, New Tricks: How AI can write Automated Tests for your Shiny Apps Speaker(s): Karan Gathani Abstract: As Shiny applications grow in complexity, comprehensive testing becomes crucial yet often overlooked. Many developers struggle to implement proper testing due to time constraints and technical barriers. To address this challenge, we're introducing an innovative solution that automatically generates regression tests for existing Shiny apps. By leveraging AI models trained on testing best practices, the Shiny package will streamline the testing process, making it more accessible and efficient for developers of all skill levels. Materials - https://docs.google.com/presentation/d/130bJNGp3XIlKPaouA8K0Lv0O3P7OFesW/edit?usp=sharing&ouid=105060716153365836674&rtpof=true&sd=true posit::conf(2025) Subscribe to posit::conf updates: https://posit.co/about/subscription-management/

Karan Gathani

Semantic Search for the Rest of Us with DuckDB (Marcos Huerta, Carmax) | posit::conf(2025)

Semantic Search for the Rest of Us with DuckDB Speaker(s): Marcos Huerta Abstract: Semantic search matches a search query against documents not just by directly matching words, but by ranking results using semantic meaning - for example searching for “cat” could also turn up documents that have “tiger.” While many enterprise level solutions exist for semantic search, I will show a low memory technique in Python that enables live semantic search for small to medium document collections that need to be deployed in constrained memory/ CPU environments - such as Posit Connect Cloud or a small cloud server. I will show how a web app (such as Shiny for Python) using just a few hundred megabytes of memory can enable live search using the fixed array support in DuckDB, and the open source library LlamaCPP. posit::conf(2025) Subscribe to posit::conf updates: https://posit.co/about/subscription-management/

shinyGovStyle- accessible gov design in RShiny (Cameron Race & Sarah Wong-Brown) | posit::conf(2025)

shinyGovStyle - accessible government design in RShiny Speakers: Cameron Race; Sarah Wong-Brown Abstract: In the UK, public sector websites are required to be accessible to all users. Government analysts are increasingly turning to R Shiny to enhance data dissemination. Enter **shinyGovstyle**, a package crafted by UK government analysts that seamlessly incorporates **GOV.UK's frontend design components into shiny functions**, allowing R users to effortlessly emulate the design of other GOV.UK services

Shinystate (Eric Nantz, Eli Lilly) | posit::conf(2025)

shinystate: Launching collaboration and session management to new heights in Shiny applications Speaker(s): Eric Nantz Abstract: Shiny is being used more regularly as a front end to sophisticated workflows in data science, often with a large number of inputs and intricate reactivity. End users desire a way to save their progress through the application workflow and share their state of the application with others for review. For small applications, the existing Shiny bookmarkable state feature is a valid approach. However, many of the production Shiny applications I've created require more granular control. Enter {shinystate}, my new R package that offers an intuitive class system and integration with {pins} to let developers choose where to save application state, ability to save multiple sessions at once, and bring collaboration to new heights for end users. Materials - https://rpodcast.github.io/shinystate-positconf2025/ posit::conf(2025) Subscribe to posit::conf updates: https://posit.co/about/subscription-management/

surveydown (John Paul Helveston, GWU) | posit::conf(2025)

surveydown: A Markdown-Based Platform for Interactive and Reproducible Surveys Using Quarto and Shiny Speaker(s): John Paul Helveston Abstract: This talk introduces the surveydown R package and survey platform, which leverages the Quarto publication system and R shiny web framework to create reproducible and interactive surveys. While most survey platforms rely on graphical interfaces or spreadsheets to define survey content, surveydown uses plain text (markdown and R code chunks), enabling version control and collaboration via tools like GitHub. It supports complex features like conditional skip logic, dynamic questions, and complex randomization as well as a diverse set of question types and formatting options. The open-source package gives researchers full control over survey implementation and data storage, with reproducible workflows that integrate with R data analysis. GitHub Repo - https://github.com/surveydown-dev/surveydown Materials - https://github.com/jhelvy/2025-posit-conf-surveydown posit::conf(2025) Subscribe to posit::conf updates: https://posit.co/about/subscription-management/

Talk data to me: How to present youR data to any audience (Freda Warner, CIHR) | posit::conf(2025)

Talk data to me: How to present youR data to any audience Speaker(s): Freda Warner Abstract: Translating data and analytics to diverse audiences is a vital part of any data scientists’ job, no matter what level. Strong data communication skills are valuable for every shiny app or quarto-generated presentation you give, and involve more than just avoiding pie charts! This presentation will cover creating a narrative with your data, identifying key messages, creating effective slides and visuals, and delivering an oral presentation that is not only articulate, but will help your audience understand and remember your message. posit::conf(2025) Subscribe to posit::conf updates: https://posit.co/about/subscription-management/

Theming Made Easy: Introducing brand.yml (Garrick Aden-Buie, Posit) | posit::conf(2025)

Theming Made Easy: Introducing brand.yml Speaker(s): Garrick Aden-Buie Abstract: brand.yml is an exciting new project from Posit that radically simplifies theming. Every data science tool supports some form of theme and appearance customization, but each app framework, output format, or visualization tool requires its own special syntax for theming. The goal of brand.yml is to create a portable and unified interface for brand-related theming that can be used anywhere that data science artifacts are produced. As a collaboration between the Shiny and Quarto teams, brand.yml provides a single interface to setting baseline themes in reports and apps across the R and Python ecosystems. In this talk, I’ll introduce brand.yml and showcase the many ways that brand.yml can bring consistent styles to your data science outputs. Materials - https://github.com/gadenbuie/brand-yml-posit-conf-2025 Slides - https://pkg.garrickadenbuie.com/brand-yml-posit-conf-2025 posit::conf(2025) Subscribe to posit::conf updates: https://posit.co/about/subscription-management/

Garrick Aden-Buie

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

Scaling a shiny app to 100K monthly users | Tan Ho | Data Science Hangout

ADD THE DATA SCIENCE HANGOUT TO YOUR CALENDAR HERE: https://pos.it/dsh - All are welcome! We'd love to see you! We were recently joined by Tan Ho, Engineering manager at Teamworks Intelligence Soccer, to chat about scaling Shiny applications, working out loud and building a personal brand, defining "code in production," and best practices for R package development. In this Hangout, we explore how Tan built a successful Shiny application that scaled to serve thousands of users, challenging the misconception that R does not scale. Tan shared his firsthand experience running the Dynasty Process Shiny app which peaked at 200,000 monthly users. He explained that the app was able to handle this load because user sessions were kept very short (around 30 seconds to a minute). Key advice for performance optimization includes focusing on small round-trip times for users, moving as much logic out of the app as possible (such as pre-computing or caching common requests), reducing the interface, and optimizing the actual queries (for instance, by rewriting them in data.table). Resources mentioned in the video and zoom chat: DynastyProcess GitHub → https://github.com/DynastyProcess Tan Ho's Github → https://github.com/tanho63 Tan Ho talk: A minimum viable Shiny infrastructure for serving 95,000 monthly users → https://www.youtube.com/watch?v=zb3umo3Ka2g&t=3s Tan Ho talk: Shiny in Production 2023: Tan Ho - Effective logging for Shiny → https://www.youtube.com/watch?v=wbUXrK_YWfI Show Your Work by Austin Kleon → https://austinkleon.com/show-your-work/ If you didn’t join live, one great discussion you missed from the zoom chat was about display setups, with participants debating whether one screen is better for focus or if multiple screens (up to four!) are essential for data science work. How many monitors do you roll with? Libby can't live without at least two external monitors, but admits that sometimes just one laptop monitor is better for focusing. ► 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! Timestamps: 00:00 Introduction 04:15 "Tell us just, like, a snippet of your journey into R/Shiny" 07:36 "How many users did you have on your shiny app?" 09:44 "How did the techniques and skills you learned in NFLverse help translate to your professional role?" 13:03 "Do you feel like working out loud played a big part in building a personal brand?" 15:29 "What is your top advice for thinking about code in production?" 21:30 "Do you have resources for people starting their Shiny journey?" 25:01 "What's the trigger point when you decide to bundle products into one package?" 27:25 "What were the biggest hurdles faced in scaling the Shiny app with high user load?" 31:23 "How can I do a better job of evaluating fantasy football players than ESPN projections?" 32:59 "What packages are most helpful for benchmarking and writing fast code?" 35:29 "Do you start with use case first or generic code and then refine?" 37:48 "What soft skills or personality traits help manage bugs efficiently?" 41:49 "Did you have instances when you felt you were going overboard with curiosity?" 45:25 "What are the best practices for reproducible production workflows for non-technical teams?" 49:00 "What piece of career advice would you give?"

Accelerating Study Insights with Shiny and Posit | Regeneron x Atorus

In this session, Atorus and Regeneron, and Posit showcase their innovative partnership. Topics covered: -Building a Unified Analytical Environment: Learn how to reduce friction by integrating fragmented SAS and R workflows. -Case Study: A Config-Driven App: See a live demo of how a simple configuration file can build a fully functional application for data review and safety monitoring. -Operational Shifts: Understand how internal teams are empowered to independently manage and extend their own applications in a regulated environment. This isn’t just about technology—it’s about the strategic shift required to simplify development and accelerate insights within a regulated environment. Learn more about Posit's work in the pharma space: https://posit.co/use-cases/pharma/?utm_source=youtube&utm_medium=social&utm_term=pharma&utm_content=atorus-regeneron

Lessons from a Broad & Varied Data Science Career | Arcenis Rojas | Data Science Hangout

ADD THE DATA SCIENCE HANGOUT TO YOUR CALENDAR HERE: https://pos.it/dsh - All are welcome! We'd love to see you! We were recently joined by Arcenis Rojas, Data Scientist at Indeed, to chat about econometrics, public vs private sector data science, navigating a varied career trajectory, AI integration in the hiring sphere, and making friends at conferences. In this Hangout, Arcenis talked about how his career journey has been wide as opposed to vertically narrow. He shared that this breadth of experience has given him confidence that he can quickly figure out any dataset. He feels it also taught him how to communicate effectively about data to people at different levels and across various domains. He also shared his tech stack at Indeed, including RStudio, Positron, AWS, Snowflake, Quarto for reporting, Shiny for apps, and Posit Connect for deploying them. An attendee asked about the impacts of AI on the job search space, and Arcenis shared the AI at Work Report (linked below) from the Indeed Hiring Lab. He says, based on research, generative AI is expected to assist many people but only replace small segments of the workforce in the coming 5-10 years, and that entry-level knowledge work is predicted to be the most highly impacted area. Resources mentioned in the video and zoom chat: Indeed Hiring Lab: AI at Work Report 2025 → https://www.hiringlab.org/2025/09/23/ai-at-work-report-2025-how-genai-is-rewiring-the-dna-of-jobs/ To Explain or to Predict? (Galit Shmueli, 2010) → https://arxiv.org/abs/1101.0891 Announcing the 2025 table and plotnine contests → https://posit.co/blog/announcing-the-2025-table-and-plotnine-contests/ If you didn’t join live, one great discussion you missed from the zoom chat was about the wide variety of data types data scientists work with. Attendees shared that their data included genomics, finance/trading, environmental/natural resources, e-commerce products, and medical/clinical data. What kind of data types do you work with? ► 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! Timestamps 00:00 Introduction 06:16 "What do you like to do for fun?" 08:51 "What are the unique aspects of financial and economic data science?" 15:07 "What are econometrics?" 16:02 "Is the difference that hard sciences stats is trying to explain what happened where econometrics might be what might happen in the future?" 19:39 "Suggestions for making data friends and going to a conference alone." 23:26 "Do you see any misconceptions about the job market online, specifically the ATS thing?" 29:52 "How has your varied career trajectory been an advantage or a challenge in data science?" 34:08 "How is the recent hype wave of AI integration manifesting in the hiring sphere?" 40:08 "What are the tools that you use in your job for reporting?" 41:42 "How do you know when it is time to pivot and leave your role because your skills are stagnating?" 45:56 "How would you persuade leadership to use R or Python?" 49:32 "Did you find yourself always trying to use more complex models when simpler ones would serve the audience better?"

Pair Programming for Sustainable Deployment | Kris Fabick | Data Science Hangout

ADD THE DATA SCIENCE HANGOUT TO YOUR CALENDAR HERE: https://pos.it/dsh - All are welcome! We'd love to see you! We were recently joined by Kris Fabick, data scientist at Nissan North America, to chat about pair programming as a mechanism for sustainable deployment, data science in supply chain operations, the challenges of integrating pair programming into a team, and even a little about Kris's hobby, reffing soccer! In this Hangout, we explore how pair programming can serve as a mechanism for sustainable deployment. Kris explained that using pair programming is the team's solution to successfully deploying projects in a sustainable way, especially since they have a small data science team without extensive enterprise-level tools or IT support. Pair programming creates human redundancy in a project, meaning two (or more) people are familiar with it, allowing the team to react quickly to changes in development and deployment, and ensuring that someone can cover maintenance even if the original programmer is on vacation. When pitching the investment of time to leadership, a crucial metric was cited: pair programming requires only 15% more time to implement but results in 15% fewer defects. The value proposition is that saving defects saves far more time and downstream costs than the initial investment, offering stability that was a great comfort to leadership. Resources mentioned in the video and zoom chat: Shiny State Blog Post (by Eric Nantz) → https://shinydevseries.com/blog/2025-09-24-shinystate-cran/ Guest's posit::conf() GitHub Repo → https://github.com/kfabick03/positconf2025 We don't have the link just yet, but Kris's conf talk will be on YouTube soon! You can search for the title, "Self-sufficient deployment- using pair programming to have fun and sell your solutions" and the speakers are Kris Fabick & Kristin Carr If you didn’t join live, one great discussion you missed from the zoom chat was about the difference between using AI for coding versus using human pair programming. The group discussed how "Pair programming == everyone learns MORE about the codebase" while "AI coding == everyone understands LESS about the codebase". Chris noted that when he uses AI to help with code, he actually knows less about it and would not be able to explain the functionality to stakeholders if changes were requested. Attendees also noted that chatbots don't show their logic or mistakes and how they back out of them, which is a valuable source of learning. Let us know below if you’d like to hear more about this topic! ► 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! Time Stamps 00:00 Introduction 01:47 "What is the best and worst thing about being a referee?" 04:58 "Kris, could you give us a little recap of your posit::conf(2025) talk about pair programming?" 08:52 "What was the most persuasive thing or metric that you feel like you were able to use to persuade leadership to let you adopt pair programming?" 13:52 "Are there any challenges or additional benefits of pair programming to the individual, that you've noticed?" 17:58 "Do you have any tips for being self-conscious while coding in front of someone?" 19:53 "Could you give a high level overview of supply chain?" 21:56 "Is it better to have both devs be at the same level of experience or expertise when pair coding?" 27:32 "I was just wondering if you could tell us a little bit about the container fill ratio problem you mentioned in your talk." 31:41 "How as a pair of programmer do you set realistic expectation from the stakeholder? How do you manage the communication gap?" 36:50 "Do you think that AI and specifically things like Copilot might be able to replace some aspects of pair programming?" 40:59 "Do you have a piece of career advice that has really stuck with you or that you like to give people that you find impactful?" 43:36 "Have you ever done any fun data stuff related to your refereeing?" 48:36 "How do you balance the time that gets added on with pair programming with tasks that need to be done quickly?" Subscribe to posit::conf updates: https://posit.co/about/subscription-management/

Building the Future of Data Apps: LLMs Meet Shiny

GenAI in Pharma 2025 kicks off with Posit's Phil Bowsher and Garrick Aiden-Buie sharing a technical overview of how LLMs can integrate with Shiny applications and much more! Abstract: 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 Garrick will explain LLM APIs from zero, and have you building and deploying custom LLM-empowered data workflows and apps in no time. Resources mentioned in the session: * GitHub Repository for session: https://github.com/gadenbuie/genAI-2025-llms-meet-shiny * {mcptools} - Model Context Protocols servers and clients https://posit-dev.github.io/mcptools/ * {vitals} - Large language model evaluation for R https://vitals.tidyverse.org/

Positron Assistant for Developing Shiny Apps - Tom Mock

Positron Assistant for Developing Shiny Apps - Tom Mock (Posit) Abstract: This talk will explore building AI Apps with a focus on Positron Assistant for Shiny developer experience and in-IDE tooling for accelerating app creation. This talk will discuss tools like ellmer / chatlas / querychat / shinychat and compare it to Positron Assistant. Resources mentioned in the presentation: * Positron - https://positron.posit.co/ * Positron Assistant - https://positron.posit.co/assistant.html

Daniel Chen - LLMs, Chatbots, and Dashboards: Visualize Your Data with Natural Language

For information on upcoming conferences, visit https://www.dataconf.ai. LLMs, Chatbots, and Dashboards: Visualize Your Data with Natural Language by Daniel Chen Abstract: LLMs have a lot of hype around them these days. Let's demystify how they work and see how we can put them in context for data science use. As data scientists, we want to make sure our results are inspectable, reliable, reproducible, and replicable. We already have many tools to help us in this front. However, LLMs provide a new challenge; we may not always be given the same results back from a query. This means trying to work out areas where LLMs excel in, and use those behaviors in our data science artifacts. This talk will introduce you to LLms, the Ellmer, and Chatlas packages for R and Python, and how they can be integrated into a Shiny to create an AI-powered dashboard. We'll see how we can leverage the tasks LLMs are good at to better our data science products. Presented at The New York Data Science & AI Conference Presented by Lander Analytics (August 26, 2025) Hosted by Lander Analytics (https://www.landeranalytics.com)

Laboratory science to data science & the art of the growth gig | Lisa Elkin | Data Science Hangout

ADD THE DATA SCIENCE HANGOUT TO YOUR CALENDAR HERE: https://pos.it/dsh - All are welcome! We'd love to see you! We were recently joined by Lisa Elkin, Senior Principal Computational Toxicologist at Pfizer, to chat about her career transition from a lab scientist to a data scientist, building Shiny apps for scientific audiences, and the value of internal programs for up-skilling and data literacy. In this Hangout, we explore how to foster data science skills and build communities within a large organization. Lisa shares her experience with programs like an "Analytics Exchange," where employees could dedicate 20% of their time to working on data science projects from across the company, allowing them to learn by doing. She provides tips on how to propose similar "growth gig" opportunities to leadership, highlighting the value of up-skilling the entire department to increase efficiency and innovation without necessarily hiring more specialists. Lisa also gives advice for starting a new internal community from the ground up, emphasizing the need for a few passionate individuals and the importance of repeating introductory sessions to support newcomers. Lisa runs a Data Science Hangout internally at Pfizer!! Resources mentioned in the video and zoom chat: Mastering Shiny Book → https://mastering-shiny.org/ Jenny Bryan - Code Smells and Feels Talk → https://github.com/jennybc/code-smells-and-feels Posit Academy → https://posit.co/products/enterprise/academy/ If you didn’t join live, one great discussion you missed from the zoom chat was about what a "mainframe" computer is. The conversation sparked memories of punch cards, floppy disks, and how the cloud is in some ways a return to the mainframe paradigm. Let us know below if you’d like to hear more about it! Better yet, join us live on Thursdays :) pos.it/dsh ► 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! Timestamps 00:00 Introduction 04:50 "What is toxicology?" 06:19 "What are the data types that your tool users are interfacing with?" 07:19 "What is an assay?" 08:15 "How does your science background benefit or disadvantage you as a data scientist?" 14:55 "What kind of audience do you build Shiny apps for and what is your workflow?" 18:05 "What made you decide to switch to industry and what were the bottlenecks between academia and industry?" 24:39 "Do you have any tips on proposing an 'analytics exchange' program to leadership?" 28:38 "What tools or systems do you use for sharing apps and what tools do you use daily?" 32:33 "How much oversight do you have on your analysis and do you ever get stuck in skeptic paralysis?" 35:18 "Do you have any podcast recommendations?" 38:01 "How can organizations resolve the tension between allowing employees space to learn and being productive?" 41:12 "What advice would you give to somebody starting a brand new community within their company?" 46:05 "Any resources for learning modular Shiny apps or tool building in general?" 47:40 "What is the career progression like for a data scientist and is it possible to grow as an individual contributor?"

Jenny Bryan

SAS to R, data harmonization, & a career in pharma | Dony Unardi | Data Science Hangout

ADD THE DATA SCIENCE HANGOUT TO YOUR CALENDAR HERE: https://pos.it/dsh - All are welcome! We'd love to see you! We were recently joined by Dony Unardi, Principal Data Scientist at Genentech, to chat about the Teal framework for Shiny, data cleaning and harmonization in the pharmaceutical industry, and career transitions from SAS (and web development!) to R. In this Hangout, we explore Teal, an open-source framework built around Shiny to accelerate the creation of clinical trial analysis apps. Donnie explains that Teal provides out-of-the-box features like advanced filtering and, most importantly, code reproducibility. This allows users to generate the exact R code needed to reproduce a visualization or analysis from the app in their local environment, a critical feature for validation and submission in the pharma industry. Resources mentioned in the video and zoom chat: Teal Gallery → https://insightsengineering.github.io/teal.gallery/ Pharmaverse → https://pharmaverse.org/ SAS to R: A Data Snack from the Fred Hutch Data Science Lab → https://hutchdatascience.org/data_snacks/r_snacks/sas2r.html A SAS to R Success Story (Posit Video) → https://posit.co/resources/videos/a-sas-to-r-success-story/ R Consortium Submissions Working Group → https://rconsortium.github.io/submissions-wg/ If you didn’t join live, one great discussion you missed from the zoom chat was about making the transition from SAS to R. Many community members shared personal experiences, valuable resources, and advice, emphasizing the importance of learning R's idioms rather than attempting a direct, one-to-one translation of SAS code. Let us know below if you’d like to hear more about this topic! ► 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! Timestamps 00:00 Introduction 06:34 "What is the teal shiny app framework?" 12:10 "Does being in the Bay Area make a difference for data careers?" 16:44 "What kind of sass are you talking about? (SAS!)" 18:07 "How do you approach technical interviews?" 20:22 "Do you have any tips for a SAS programmer being told to use R?" 26:10 "What are some of the data quality challenges that you find in pharma data?" 29:43 "How is reproducibility defined in the pharma industry?" 32:37 "What does Teal offer for reproducibility that a Git repo does not?" 36:48 "What are the pharma job titles for roles focused on data cleaning and QAQC?" 39:11 "What do you mean by harmonizing data?" 42:09 "How do you prioritize projects and collaborate with your teammates?" 44:36 "Should personal data science projects be for learning or for a resume?" 47:58 "How did you get leadership support to contribute to the open-source community?"

Data viz, Shiny app design, & technical career paths | Kiegan Rice | Data Science Hangout

ADD THE DATA SCIENCE HANGOUT TO YOUR CALENDAR HERE: https://pos.it/dsh - All are welcome! We'd love to see you! We were recently joined by Keegan Rice, Senior Statistician at NORC at the University of Chicago, to chat about data visualization design, bridging the gap between technical and non-technical teams, and building large-scale, public-facing Shiny apps. In this Hangout, we explore how to effectively communicate statistical results and design intuitive data visualizations for non-technical audiences. Keegan shares her top tips, emphasizing the importance of knowing your audience and not assuming they have the same level of data literacy as a practitioner. She suggests testing your charts on friends or colleagues outside the data space to ensure they are understandable. The conversation also covers the challenges of explaining concepts like statistical significance and the value of forcing stakeholders to articulate their core business questions rather than just asking for a specific table or chart. Resources mentioned in the video and zoom chat: Kiegan's posit::conf talk, "Wait, that's shiny" → https://www.youtube.com/watch?v=SAbV6d7Pn0U Kiegan's reproducible GitHub repo from the talk → https://github.com/kiegan/wait-thats-shiny Deepsha Menghani's talk on crosstalk → https://youtu.be/AbuK2F57NEs The NCVS dashboard, an example of a tool built for a federal client → https://ncvs.bjs.ojp.gov/Home The Medicare Current Beneficiary Survey Chartbook → https://chartbook.mcbs.org/ If you didn’t join live, one great discussion you missed from the zoom chat was about favorite board games and sci-fi/fantasy books. Recommendations ranged from board games like Ark Nova, Dominion, and Terraforming Mars to book series like The Expanse, The Stormlight Archive, and Gideon the Ninth. Come hang out with us live to chat about this stuff!! ► 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! Timestamps: 00:00 Introduction 07:40 "What are your top tips for data visualization design?" 11:15 "What are the challenges you’ve faced when communicating statistical results to non-statisticians?" 18:30 "Do you experience any imposter syndrome because you’re not really doing stats anymore?" 22:04 "How do you see data visualization evolving and what are your book recommendations?" 26:56 "How do you get federal clients to modernize beyond using tables for everything?" 29:37 "How do you decide what aspects to drop when a data visualization is too busy?" 35:57 "Is there a middle ground for Shiny between Quarto and JavaScript?" 39:51 "Which sci-fi or fantasy books are you loving?" 42:19 "What advice do you have for someone just getting started with interactive data visualization?" 47:40 "What advice do you have for attending or giving a talk at posit::conf for the first time?" 50:35 "How important is it to show the lineage of data so people can trust your visualizations?"

Sports analytics, baseball metrics, and Shiny apps | Brian Chase | Data Science Hangout

ADD THE DATA SCIENCE HANGOUT TO YOUR CALENDAR HERE: https://pos.it/dsh - All are welcome! We'd love to see you! We were recently joined by Brian Chase, Vice President of Baseball Systems at the Miami Marlins, to chat about the role of baseball systems and data analytics in professional sports, leveraging technology and hardware for player performance and team strategy, the evolution of sports analytics since the "Moneyball" era, and career insights for breaking into niche industries (like baseball!). In this Hangout, we explore how the Miami Marlins leverage advanced technology and data analytics to enhance player performance and team strategy. Brian details the use of innovative hardware like the Trajekt robotic pitching machine that allows batters to practice against simulated versions of opposing pitchers with exact spin rates and velocities. He also discusses the Hawkeye cameras and other systems, which capture real-time player and ball tracking data, including bio-mechanical information, using 12 cameras at LoanDepot Park. This extensive data is then platformed in tools like Snowflake and Google Cloud for analysis. The team also utilizes wearables to track bat speed and other metrics. Insights are delivered to coaches and players through pre-game and post-game reports and dashboards, often built using Posit Connect and Shiny apps, which helps translate complex data into easily digestible stories. Resources mentioned in the video and zoom chat: Miami Marlins Job Opportunities → https://www.teamworkonline.com/baseball-jobs/miamibaseball/miami-marlins Technology & AI Magazine Feature on Miami Marlins → https://technologymagazine.com/brochure/miami-marlins-using-ai-to-accelerate-competitive-sport Trajekt Sports (Trajekt pitching machine) → https://www.trajektsports.com/ MIT Sloan Sports Analytics Conference → https://www.sloansportsconference.com/ Astroball by Ben Reiter → https://www.porchlightbooks.com/products/astroball-ben-reiter-9780525576648 The MVP Machine by Ben Lindbergh and Travis Sawchik → https://www.sandmanbooks.com/book/9781541698925?srsltid=AfmBOorVPNYGMdhNFsiaUfJ2N88em1qiGfEf6Kok5Z3LmaREs-Iv25ac If you didn’t join live, one great discussion you missed from the zoom chat was about mascots! Libby shared her love for mascots, especially the San Antonio Missions "puffy taco". Attendees chimed in, sharing their favorite team mascot pics - you really have to be there live to appreciate all the fun in the chat!! ► 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! Timestamps: 00:00 Introduction 00:55 "Tell us a little bit about what you do and how you got here?" 09:15 "How did you get your foot in the door for an MLB job?" 14:02 "What coding languages, tools, and systems do your teams work with the most?" 19:35 "What does data analytics have to do with baseball hardware?" 23:51 "What do pre-game and post-game reports look like, and how do you use Shiny?" 26:39 "How do you measure ROI for technologies, and how do you get buy-in?" 30:41 "How has stats analytics evolved since the Moneyball era?" 34:25 "Is qualitative analysis still used alongside quantitative data from scouts?" 35:27 "Who will play you in the future of Moneyball 2?" 36:27 "Will AI benefits plateau if all teams have similar access to tools and data?" 40:22 "Are you measuring off-field factors like sleep, nutrition, and injuries in your models?" 42:57 "What's the thought process behind developing new features and actionable metrics in sports analytics?" 47:53 "What might someone be surprised by when turning a hobby into a job?" 50:40 "Did you ever feel discouraged during your 4-year job search?" 50:50 "Was getting your MBA worth it for your career in sports?"

Daniel Chen - Shiny for Python: Building Production-Ready Dashboards in Python | SciPy 2025

Shiny is a framework for building web applications and data dashboards in Python. In this workshop, you will see how the basic building blocks of shiny can be extended to create your own scalable production-ready python applications. In particular, this workshop covers: - Overview of the basic building blocks of a Shiny for Python application - How to refactor applications into shiny modules - How to write tests for your shiny application - Deploy and share your application At the end of this course you will be able to: - Build a Shiny app in Python - Refactor your reactive logic into Shiny Modules - Identify when to write Shiny modules - Write unit tests and end-to-end tests for your shiny application - Deploy and share your application (for free!)

Deploying Scikit-learn models for in-database scoring with Snowflake and Posit Team

Modern data science workflows often face a critical challenge: how to efficiently deploy machine learning models where the data lives. Traditional approaches require moving large datasets out of the database for scoring, creating bottlenecks, security concerns, and unnecessary data movement costs. In this demo, Nick Pelikan at Posit highlights how orbital bridges the gap between Python’s rich ML ecosystem and database-native execution by converting scikit-learn pipelines to optimized SQL. This enables data scientists to: 1. Use familiar Python tools for model development 2. Automatically translate complex feature engineering to SQL 3. Deploy models without rewriting code in different languages 4. Maintain model accuracy through faithful SQL translations While this example focuses on Python, Nick also gave this demo using Orbital for R users: https://youtu.be/pnEjYNgOG9c?feature=shared Helpful resources: 1. Follow-along blog post: https://posit.co/blog/snowflake-orbital-scikit-learn-models/ 2. Supported models for Orbital: https://orbital.tidymodels.org/articles/supported-models.html 3. Orbital (Python) GitHub Repo: https://github.com/posit-dev/orbital 4. Orbital (R) GitHub Repo: https://github.com/tidymodels/orbital 5. Databricks and Orbital for R and Python model deployment: https://posit.co/blog/databricks-orbital-r-python-model-deployment/ 6. Emily Riederer's XGBoost example with Orbital: https://www.emilyriederer.com/post/orbital-xgb/ 7. Sara Altman's blog post on Shiny + Databases: https://posit.co/blog/shiny-with-databases/ 8. Emil's introduction of orbital: https://emilhvitfeldt.com/talk/2024-08-13-orbital-positconf/ 9. Nick's Blog on Running Tidymodel Prediction Workflows with Orbital: https://posit.co/blog/running-tidymodel-prediction-workflows-inside-databases/ If you'd like to learn more about using Posit Team, you can always schedule time to chat with Posit here: https://posit.co/schedule-a-call/

AI and Shiny | Keynote ShinyConf 2025

ShinyConf #ShinyConf2025 This is a talk from ShinyConf 2025: https://www.shinyconf.com Abstract: As LLMs continue to get more and more capable, you might find yourself wanting to build web applications that make use of LLMs. Shiny is a great tool for doing this. I will talk about some of the tools we've developed at Posit to help you build applications that use LLMs, and I'll show you how simple it is to get started building your first AI chat application with Shiny. ‍On the flip side, LLMs are great tools for helping to build Shiny applications, and I will show the AI-driven tools we've been working on at Posit that can help you build Shiny applications more quickly and with more fun. ____________________ Want to explore more sessions? Sign up for replay access:

Building Tailored Dashboards: Drill Down Visualizations and LLM-Powered Summaries with Shiny

Led by Isabella Velásquez, Sr Product Marketing Manager at Posit PBC Scenario: Imagine the weekly scramble at DemoCo. Isabella, a lonely Marketing analyst, spends hours every Friday manually compiling marketing lead performance data from Salesforce, website logs, and event records into a sprawling Excel report. The tedious, redundant process is both a time sink and a bottleneck.  Marketing Leadership, who need to identify top-performing platforms, find the mass amount of information in the report confusing. They constantly return to Isabella for clarification or, even worse, don’t reach back out and make misinformed decisions on critical budget allocation. Determined, Isabella decides it’s finally time to automate and tailor this critical dashboard, and save headaches for both Leadership and herself. In this demo, you will learn how to: 1. Transform redundant, manual, error-prone data compilation into an automated lead performance dashboard with Shiny 2. Integrate diverse marketing data sources for a holistic view 3. Build tailored marketing KPI dashboards that address Leadership’s specific questions 4. Use drill-downs, data visualizations, and LLM-powered summaries to reduce data overload and clarify complex takeaways instantly 5.Provide flexibility in dashboard functionality to meet diverse preferences and needs, from pre-selected insights derived directly from the data to implementing an LLM-powered analytics option Helpful resources: 1. Demo Slides: https://github.com/ivelasq/2025-06-25_marketing-demo/blob/main/README.md 2. Demo Marketing Dashboard: https://pub.current.posit.team/public/marketing-demo/ 3. GitHub Repo (including links to packages used: pointblank, querychat, etc.): https://github.com/ivelasq/2025-06-25_marketing-demo?tab=readme-ov-file If you have specific follow-up questions about using Posit in your organization, we'd love to chat with you: https://posit.co/schedule-a-call/

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

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

Create a PydyTuesday Shiny app with Shiny Assistant

Watch Sara Altman quickly prototype a Shiny app for PydyTuesday with Shiny Assistant, an AI-powered tool designed to help you with Shiny. Shiny Assistant can create Shiny apps from scratch, debug or assist with existing apps, and answer general questions about Shiny. Shiny Assistant: https://gallery.shinyapps.io/assistant/ Learn more: * Shiny for Python: https://shiny.posit.co/py/ * The potential for AI-powered Shiny app prototyping with Shiny Assistant: https://posit.co/blog/ai-powered-shiny-app-prototyping/ * TidyTuesday project: https://github.com/rfordatascience/tidytuesday * Posit PydyTuesday GitHub repo: https://github.com/posit-dev/python-tidytuesday * Other videos in this PydyTuesday playlist: https://youtube.com/playlist?list=PL9HYL-VRX0oSDQjicFMLIIdcLv5NuvDp9&si=i09_CuKmjiV86D-9 #pythoncontent

Standardizing a safety model with tidymodels, Posit Team & Databricks at Suffolk Construction

If you’ve ever struggled with standardizing machine learning workflows, ensuring secure data access, or scaling insights across your organization, this month’s Posit Team Workflow demo is for you. Maxwell Patterson, Data Scientist at Suffolk walked us through how their team is: Standardizing model workflows using tidymodels, vetiver, Shiny, and Quarto Leveraging row-level permissions in Shiny apps to improve data governance Using Databricks and Posit to gain insights faster and more securely A few helpful links for this demo: Suffolk Customer Spotlight: https://posit.co/about/customer-stories/suffolk/ Quarto email customization: https://docs.posit.co/connect/user/quarto/#email-customization Vetiver package: https://rstudio.github.io/vetiver-r/reference/vetiver_deploy_rsconnect.html Pins package: https://pins.rstudio.com/ Tidymodels "meta-package" https://tidymodels.tidymodels.org/ More information on how Posit and Databricks work together: https://posit.co/use-cases/databricks/ Do you use both Databricks and Posit, but not together yet. You can use this link to chat more with our team as well: https://pos.it/chat-databricks Q&A Recording: https://youtube.com/live/zU-bBUJMyQ4?feature=share To add future workflow demos on your calendar: https://pos.it/team-demo ^ These demos happen the last Wednesday of every month

Shiny Assistant - Prototype Shiny for Python Apps with AI

Ryan Johnson walks through how to use Shiny Assistant, an AI-powered tool for Shiny for Python app development. Learn how to quickly create and interact with a Shiny app based on your own description. Shiny Assistant is a powerful tool for rapid prototyping and iteration. You can also ask it questions about how to use Shiny. Shiny Assistant: https://gallery.shinyapps.io/assistant/ Learn more: * Shiny for Python: https://shiny.posit.co/py/ * The potential for AI-powered Shiny app prototyping with Shiny Assistant: https://posit.co/blog/ai-powered-shiny-app-prototyping/ * TidyTuesday project: https://github.com/rfordatascience/tidytuesday * Posit PydyTuesday GitHub repo: https://github.com/posit-dev/python-tidytuesday * Other videos in this PydyTuesday playlist: https://www.youtube.com/playlist?list=PL9HYL-VRX0oSDQjicFMLIIdcLv5NuvDp9 #pythoncontent

{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

R-Ladies Rome (English) - Interactive R, Python, and Shiny in the Browser with Quarto and Shinylive

In this session, Isabella Velásquez walks us through Quarto Live and Shinylive, powerful tools that allow us to create interactive R, Python, and Shiny applications without a server. These technologies make it easier than ever to share dynamic, engaging data science projects directly in the browser. What You’ll Learn ️ How Quarto Live brings interactive code to static documents ️ How Shinylive allows Shiny apps to run entirely in the browser ️ Practical use cases for data science, education, and collaboration This talk is ideal for data scientists, educators, and open-source enthusiasts who want to make their work more interactive and accessible. To further explore the subject, we recommend visiting the presentation of the talk : https://ivelasq.github.io/2025-02-21_r-python-shiny-in-the-browser More about the Speaker: - https://www.linkedin.com/in/ivelasq/ 0:00 R-Ladies Rome Chapter Intro 5:00 Isabella's Talk Please visit: https://rladiesrome.org

Deploy your work to Posit Connect Cloud

*Deploy your data science content with Posit Connect Cloud!* Daniel Chen walks you through deploying a Shiny for Python app to Connect Cloud, sharing your content, and updating it via GitHub. While this video focuses on Shiny for Python, Posit Connect Cloud also supports Quarto, Streamlit, Jupyter, and more! Use Posit Connect Cloud to share your PydyTuesday work with the world. Learn more here: https://github.com/posit-dev/python-tidytuesday. Resources: * Shiny app code: https://github.com/posit-dev/py-shiny-templates/tree/main/dashboard * Posit Connect Cloud: https://connect.posit.cloud/ * Shiny for Python: https://shiny.posit.co/py/ * Other videos in this PydyTuesday playlist: https://www.youtube.com/playlist?list=PL9HYL-VRX0oSDQjicFMLIIdcLv5NuvDp9 #pythoncontent

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

The changing landscape of data science | Kanchana Padmanabhan | 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 Kanchana Padmanabhan, Director of Data and AI at Homebase, to chat about data science team structures, the role of math in understanding LLMs, building effective hackathons, and communicating model insights to stakeholders. In this Hangout, we explore the importance of understanding the probabilistic nature of LLMs and how that understanding should influence how data scientists approach their work. We also discussed how to structure a hackathon to encourage learning, centering on the customer problem, and collaboration between technical teams and business stakeholders. Resources mentioned in the video and zoom chat: List of R Conferences for 2025 → https://rworks.dev/posts/r-conferences-2025/ Posit Conference Call for Talks → https://posit.co/blog/speak-at-posit-conf-2025/ Julia Silge's workflow demo on model cards → https://www.linkedin.com/posts/posit-software_join-us-for-a-live-workflow-demo-on-creating-activity-7287998741557522432-jseQ?utm_source=share&utm_medium=member_desktop Shiny Assistant Gallery → https://gallery.shinyapps.io/assistant Data Science Hangout Playlist → https://www.youtube.com/playlist?list=PL9HYL-VRX0oTu3bUoyYknD-vpR7Uq6bsR Add Posit Team End-to-End Workflows to calendar → https://evt.to/aoimiohuw Making of a Manager Book → https://www.amazon.com/Making-Manager-What-Everyone-Looks/dp/0735219567 If you didn’t join live, one great discussion you missed from the zoom chat was about how to gain domain knowledge for a new industry, where attendees shared their experiences and advice. Let us know below if you’d like to hear more about this topic! ► 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!

Julia Silge

Shiny Forms with Accordions 🎉

Learn how to elevate your Shiny forms from basic to professional with dynamic accordions. This tutorial demonstrates how to implement intelligent form organization and visual feedback using Shiny's accordion components

Stop Your Shiny Apps from Breaking on Mobile! Master Responsive Design in Minutes 📱💻

A comprehensive guide to implementing responsive design in Shiny applications using UI layout columns. This tutorial covers how to create adaptive layouts that automatically adjust based on screen size, from desktop to mobile devices. Learn how to leverage Shiny's bootstrap-based grid system to create professional, responsive applications that look great on any device. Key concepts covered: • Default Shiny responsive behavior • UI layout column implementation • Screen size breakpoints • Bootstrap grid system • Responsive card layouts • Mobile-first design principles Reference Documentation: UI Layout Columns: https://shiny.posit.co/r/reference/shiny/latest/layout_column Layout Guide: https://shiny.posit.co/r/articles/build/layout-guide/ Bootstrap Integration: https://shiny.posit.co/r/articles/build/bootstrap/ Responsive Design: https://shiny.posit.co/r/articles/build/responsive/ Timestamps: 0:00 - Introduction 0:23 - Default Shiny layout behavior 0:38 - Understanding screen responsiveness 1:05 - Introduction to UI layout columns 1:38 - Screen size breakpoints explained 2:02 - Desktop layout demonstration 2:30 - Mobile layout adaptation 2:44 - Bootstrap grid system overview 3:21 - Documentation resources 3:45 - Conclusion

Transform Boring Forms into Eye-Catching UI: Shiny Party Tricks That Will Make You Look Like a Pro 🎉

Learn how to elevate your Shiny forms from basic to professional with dynamic accordions. This tutorial demonstrates how to implement intelligent form organization and visual feedback using Shiny's accordion components. We cover both basic accordion implementation and advanced dynamic features including status indicators, automatic title updates, and section validation. Perfect for developers looking to enhance their Shiny applications with modern, user-friendly form interfaces. Key features covered: Basic form to accordion conversion Dynamic panel updates Status indicator implementation Visual feedback systems Section validation techniques Reference Documentation: For accordion implementation, see: https://shiny.posit.co/r/reference/shiny/latest/accordion For dynamic updates, see: https://shiny.posit.co/r/reference/shiny/latest/updateAccordion For input validation, see: https://shiny.posit.co/r/reference/shiny/latest/validate For modular development, see: https://shiny.posit.co/r/articles/build/modules/ Timestamps: 0:00 - Introduction 0:23 - Basic form structure overview 0:50 - Introduction to accordion components 1:11 - Basic accordion implementation 1:35 - Dynamic accordion enhancement 2:00 - Status indicators and visual feedback 2:29 - Updating accordion panels 2:55 - Documentation resources 3:18 - Conclusion

Wes McKinney & Hadley Wickham (on cross-language collaboration, Positron, career beginnings, & more)

We hosted a special event hosted by Posit PBC with Wes McKinney (Pandas & Apache Arrow) and Hadley Wickham (rstats & tidyverse) to ask questions, share your thoughts, and exchange insights about cross-language collaboration with fellow data community members. Here's a preview into what came up in conversation: 1. Cross-language collaboration between R and Python 2. Positron, a new polyglot data science IDE 3. Open source development, how Wes and Hadley got involved in open source and their experiences in building and maintaining open-source projects such as Pandas and the tidyverse. 4. Documentation for R and Python, especially in the context of teams that use both languages (shoutout to Quarto!) 5. The use of LLMs in data science 6. The emergence of libraries like Polars and DuckDB 7. Challenges of switching between the two languages 8. Package development and maintenance for polyglot teams that have internal packages in both languages 9. The future of data science The chat was on fire for this conversation and we've gathered most of the links shared among the community below: Documentation mentioned: Positron, next-generation data science IDE built by Posit: https://positron.posit.co/ Quarto tabset documentation: https://quarto.org/docs/output-formats/html-basics.html#tabset-groups Packages / Extensions mentioned: Pins: https://pins.rstudio.com/ Vetiver: https://vetiver.posit.co Orbital: https://orbital.tidymodels.org Elmer: https://elmer.tidyverse.org Tabby Extension: https://quarto.thecoatlessprofessor.com/tabby/ Blog posts: AI chat apps with Shiny for Python: https://shiny.posit.co/blog/posts/shiny-python-chatstream/ Using an LLM to enhance a data dashboard written in Shiny: R Sidebot & Python Sidebot Marco Gorelli Data Science Hangout (polars): https://youtu.be/lhAc51QtTHk?feature=shared Emily Riederer's blog post on Polars: https://www.emilyriederer.com/post/py-rgo-polars/ Jeffrey Sumner’s tabset example: https://rpy.ai/posts/visualizations%20with%20r%20and%20python/r_python_visualizations Emily Riederer's blog post on Python and R ergonomics: https://www.emilyriederer.com/post/py-rgo/11 Sam Tyner's blog post on Lessons from "Tidy Data": https://medium.com/@sctyner90/10-lessons-from-tidy-data-on-its-10th-anniversary-dbe2195a82b7 Other: Hadley Wickham's cocktails website: https://cocktails.hadley.nz5 Posit subscription management to find out about new tools, events, etc.: https://posit.co/about/subscription-management/ New to Posit? Posit builds enterprise solutions and open source tools for people who do data science with R and Python. (We are also the company formerly called RStudio) We'd love to have you join us for future community events! Every Thursday from 12-1pm ET we host a Data Science Hangout with the community and invite you to join us! You can add that event to your calendar with this link: https://www.addevent.com/event/Qv9211919

Hadley Wickham

DuckDB and the future of databases | Hannes Mühleisen | 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 Hannes Mühleisen, Co-founder and CEO at DuckDB Labs, to chat about the evolution of database systems, the unique architecture of DuckDB, and how to find opportunities in areas others might consider "boring." He also showed us a picture of the real life duck, Wilbur, that inspired the name DuckDB! 🦆 In this Hangout, we explore how DuckDB is changing the traditional concept of a database by making it accessible to a wide range of users and use cases. We also discuss its origins and how it was inspired by the challenges of data analysis and the importance of focusing on real user problems when building tools. What is a database and where does it live? DuckDB is challenging database assumptions by saying... maybe your expensive laptop can hold a database instead of just pinging one? Maybe it can do more than just run web browsers! Hannes wants you to know that database doesn't have to be a bad word, and that you can actually have a great experience with one. If the data community's affinity and enthusiasm for DuckDB is any indication, we think he's right. We hope you listen in to hear Hannes talk about: a simple explanation of what DuckDB is, DuckDB's in-process architecture and why it's so cool, different DuckDB use cases (should you be using DuckDB?), DuckDB's compatibility with cloud data systems, and more. Resources mentioned in the video and zoom chat: DuckDB Website → https://duckdb.org/ DuckDB Labs Website → https://duckdblabs.com/ Posit Conf talk by Hannes → https://www.youtube.com/watch?v=GELhdezYmP0 Sarah Alman's webinar on using DuckDB and Shiny → https://www.youtube.com/watch?v=6AGroJb4zPM Forbes Article on Imposter Syndrome → https://www.forbes.com/sites/marycrossan/2024/12/18/how-to-combat-imposter-syndrome-by-developing-character/ MotherDuck → https://motherduck.com/ MotherDuck Blog Post "Big Data is Dead" → https://motherduck.com/blog/big-data-is-dead/ Posit Blog post on Shiny with Databases → https://posit.co/blog/shiny-with-databases/ DSH episode with Marco Gorelli → https://www.youtube.com/watch?v=lhAc51QtTHk Emil Hvitfeldt’s talk at posit::conf about orbital → https://youtu.be/Qnm1y0KPxVM Marcos Huerta's Blog post on DuckDB and Bert → https://marcoshuerta.com/posts/duckdb-and-bert/ If you didn’t join live, one great discussion you missed from the zoom chat was about whether industry teams who use and benefit from open source tools could devote 5-10% of their time to giving back to the open source projects with code contributions or other support. Let us know below if you’d like to hear more about this topic! ► 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!

Emil Hvitfeldt

Real-World Python Dashboard Project w/ Quarto! (Airbnb Review Analysis)

In this video we use real-world Airbnb data to put together a dashboard with Quarto & Python. We start with the basics of layout and simple components and then progress to more advanced topics such as integrating Shiny within your Quarto doc. - Github Repo: https://github.com/KeithGalli/quarto-projects - Check out the recent Quarto Crash Course Video! https://youtu.be/_VKxTPWDhA4?si=sf7cbvSJGj6gnlCl - Check out Mine’s Quarto Dashboards with R Code Videos! https://youtu.be/HW7QbqI4fH0?si=oyJhLaJ0n3Vg4v7Y - Learn more about Shiny for Dashboards! https://youtu.be/I2W7i7QyJPI?si=Osqk5odwSOZ0ub01 - Bootstrap Icons: https://icons.getbootstrap.com/ Video Timeline! 0:00 - Video Overview 0:41 - About our Data & Get Started with the Code 1:38 - Basic Quarto Dashboard Layout Information 5:08 - Adding Value Boxes to our Dashboard 10:56 - Prepping our Airbnb Data for our Dashboard 17:00 - Adding Matplotlib Data Visualizations to our Dashboard (line graph, bar chart) 26:26 - Add a Map of Airbnb Listings using Latitude & Longitude (Folium Library) 33:18 - Adding Additional Dashboard Pages with Interactive Tables (itables library) 42:23 - When to use Quarto versus Shiny for Dashboards? 44:00 - Using Shiny within a Quarto Project 49:14 - Hosting your Quarto Documents with Posit Connect Cloud #python #quarto #dashboards #pythoncontent

Sharpening your axe and the BAU trap | Steph Locke | 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 Steph Locke, Digital and App Innovation Leader at Microsoft, to chat about how to persuade your manager to give you more time for professional development, why "business as usual" (BAU) work can choke development, and how killing projects is actually a good thing. In this Hangout, we explore the importance of investing time in skill development and how this can lead to long-term gains in efficiency and quality. Steph shares advice on how to talk to managers about the value of "sharpening your axe," and why it is more efficient to train in order to do things well initially than to spend time on continuous maintenance of subpar work. Is a bunch of "business as usual" work bogging down the potential output of development teams? This is where Steph's concept of investing in high quality work up-front comes in. She talks about the dangers of rushing to release products that aren't built with high quality and low ongoing maintenance in mind: "...when [people] don't necessarily have time to invest in doing things in a way that's going to have high quality and low maintainability requirements and is easy to extend and create new things, when people aren't doing that, anything they ship is going to then cost them more time to do something to to look after whatever they've shipped. That then gives them less time to ship the next thing." If this resonates with you, give Steph a follow on LinkedIn and make sure you read her article. Resources mentioned in the video and zoom chat: Steph's article on how BAU chokes development → https://www.linkedin.com/pulse/developer-velocity-choked-bau-stephanie-locke-fsiqe Posit's documentation on using copilot in the RStudio IDE → https://docs.posit.co/ide/user/ide/guide/tools/copilot.html A YouTube video about using Shiny apps for data entry into a backend database → https://www.youtube.com/watch?v=zDJc8sXh2qw If you didn’t join live, one great discussion you missed from the zoom chat was around the discrepancies in pay and responsibilities between individual contributor (IC) and management tracks in tech companies, and the perception that management roles often have better compensation and advancement opportunities, even when the work may not be more valuable than IC contributions. Let us know below if you’d like to hear more about this topic! Is there a need for more non-people-leader technical leadership roles for highly skilled individual contributors? ► 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!

Workflow Demo Live Q&A - December 18th!

This is the Live Q&A session for our Workflow Demo on December 18th to show how to build a Shiny app that reads from and writes to a database - using DuckDB. The demo will be here: https://youtu.be/6AGroJb4zPM Sara covers how to: 1. Set up a connection to DuckDB from a Shiny app 2. Query the database using R or Python 3. Use editable tables to enable users to write back to the database 4. Securely deploy your app to Posit Connect Resources mentioned in this Q&A: Connect Authentication documentation: https://docs.posit.co/connect/user/oauth-integrations/ Git backed deployment in Posit Connect: https://posit.co/blog/git-backed-deployment-in-posit-connect/ shinylive: https://posit-dev.github.io/r-shinylive/ Mastering Shiny Best Practices: https://mastering-shiny.org/best-practices.html#best-practices Blogs: https://blog.stephenturner.us/p/duckdb-vs-dplyr-vs-base-r https://outsiderdata.netlify.app/posts/2024-04-10-the-truth-about-tidy-wrappers/benchmark_wrappers.html Using Posit tools with data in DuckDB, Databricks, and Snowflake: https://posit.co/blog/databases-with-posit/ Creating a Shiny app that interacts with a database: https://posit.co/blog/shiny-with-databases/ Appsilon has a lot of resources on the topic: https://www.appsilon.com/post/r-shiny-duckd Please note, while the monthly Posit Team Workflow Series is usually the last Wednesday of the month - this will be a week earlier. Cheers to a festive holiday season and a fantastic year ahead for you and yours! To add future Monthly Workflow Demo events to your calendar → https://www.addevent.com/event/Eg16505674 You can view all the previous workflow demos here → https://www.youtube.com/playlist?list=PL9HYL-VRX0oRsUB5AgNMQuKuHPpNDLBVt

Connecting Shiny Apps to Databases with Posit Team

Many of us learned to work with data on our laptop, but at work data is increasingly stored in databases. Join us on Wednesday, Dec 18th at 11am ET with Sara Altman, who will lead us through building a Shiny app that reads from and writes to a database - using DuckDB 🦆 Sara will cover how to: 1. Set up a connection to DuckDB from a Shiny app 2. Query the database using R or Python 3. Use editable tables to enable users to write back to the database 4. Securely deploy your app to Posit Connect Q&A Recording: https://youtube.com/live/C8j3d46AacM?feature=share Resources mentioned in this Q&A: Connect Authentication documentation: https://docs.posit.co/connect/user/oauth-integrations/ Git backed deployment in Posit Connect: https://posit.co/blog/git-backed-deployment-in-posit-connect/ shinylive: https://posit-dev.github.io/r-shinylive/ Mastering Shiny Best Practices: https://mastering-shiny.org/best-practices.html#best-practices Blogs: https://blog.stephenturner.us/p/duckdb-vs-dplyr-vs-base-r https://outsiderdata.netlify.app/posts/2024-04-10-the-truth-about-tidy-wrappers/benchmark_wrappers.html Using Posit tools with data in DuckDB, Databricks, and Snowflake: https://posit.co/blog/databases-with-posit/ Creating a Shiny app that interacts with a database: https://posit.co/blog/shiny-with-databases/ Appsilon has a lot of resources on the topic: https://www.appsilon.com/post/r-shiny-duckd Please note, while the monthly Posit Team Workflow Series is usually the last Wednesday of the month - this will be a week earlier. Cheers to a festive holiday season and a fantastic year ahead for you and yours! To add future Monthly Workflow Demo events to your calendar → https://www.addevent.com/event/Eg16505674 You can view all the previous workflow demos here → https://www.youtube.com/playlist?list=PL9HYL-VRX0oRsUB5AgNMQuKuHPpNDLBVt

From paramedic to leading analytics in pharma | Dan Haight | 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 Dan Haight, Director of Continuous Improvement Analytics at Merck, to talk about his unconventional career path, the value of lateral career moves (check out his book recommendation on this!), and the importance of creating "great charters" for successful stakeholder communication in projects. Dan's advice about project management in this episode is so valuable. He recognizes how tempting it is to rush into a project without knowing all the facts beforehand, but then your scope starts to balloon, you see the project getting behind, and there are all these constraints you weren't aware of. So, he says to take time to build a charter, be upfront with stakeholders about realistic timelines, and then use the charter as a contract to negotiate scope changes and resource allocation. He also discusses the challenges of working with incomplete data and the need to triangulate information from multiple sources to ensure accuracy and build confidence in the findings. If you're a job seeker or looking to transition, Dan came with great advice to pursue continuous learning, network, and hone the ability to effectively communicate the value of their work. You'll have to listen to learn more! If you didn't attend live, you missed the party in the zoom chat People were excited about posit::conf 2025 early bird tickets getting released, and there was a SUPER great discussion about how to share your work when it's all under NDA or very private due to security reasons. There was some great suggestions, like: 🥸 Anonymize data if it's possible, or present a similar project abstractly Use public data to demonstrate the methods you used, even if you can't showcase the findings Emphasize lessons learned during a project (ah-hah moments) instead of the business impacts IF the overall project failed or wasn't implemented (as is the fate of many DS projects!) Document projects as you go, in a format that you can safely take with you, so that you can remember all these things even after you leave your role Lean on your friends and colleagues to help you describe the impacts you had on a project, or the importance of what you did (we all need to be hyped up sometimes when it comes to writing resumes!!) Resources mentioned in the video and zoom chat: Up is Not the Only Way Book → https://www.amazon.com/Up-Not-Only-Way-Rethinking/dp/1523083484 Shiny Assistant helps you build shiny apps → https://shiny.posit.co/blog/posts/shiny-assistant/ Brag Documents - Julia Evans → https://jvns.ca/blog/brag-documents/ Lessons From Four Senior Leaders in the Data Space → https://posit.co/blog/lessons-from-four-senior-leaders-in-the-data-space/ ► 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 - 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

Quarto Dashboards 3: Theming and Styling | Mine Çetinkaya-Rundel | Posit

Theming and styling Quarto dashboards built with R and/or Python. Before watching this video, you might want to watch Parts 1 & 2. This video takes you through 0:00 - Theming (including Bootswatch themes, light/dark mode, customizing themes with SCSS) 3:55 - Styling 4:55 - Live coding demo Slides can be found at https://mine.quarto.pub/quarto-dashboards/3-theming-styling and the starter documents for the accompanying exercises at https://github.com/mine-cetinkaya-rundel/olympicdash. Materials for all parts of the videos can be accessed at https://mine.quarto.pub/quarto-dashboards. You already analyze and summarize your data in computational notebooks with R and/or Python. What’s next? You can share your insights or allow others to make their own conclusions in eye-catching dashboards and straight-forward to author, design, and deploy Quarto Dashboards, regardless of the language of your data processing, visualization, analysis, etc. With Quarto Dashboards, you can create elegant and production-ready dashboards using a variety of components, including static graphics (ggplot2, Matplotlib, Seaborn, etc.), interactive widgets (Plotly, Leaflet, Jupyter Widgets, htmlwidgets, etc.), tabular data, value boxes, text annotations, and more. Additionally, with intelligent resizing of components, your Quarto Dashboards look great on devices of all sizes. And importantly, you can author Quarto Dashboards without leaving the comfort of your “home” – in plain text markdown with any text editor (VS Code, RStudio, Neovim, etc.) or any notebook editor (JupyterLab, etc.). This workshop will walk you through building an increasingly complex dashboard using various layout options and deploy them as static web pages (with no special server required) as well as with a Shiny Server on the backend for enhanced interactivity. This course is for you if you: * do data analysis in computational notebooks * share your results with your audience in static or interactive dashboards * want to improve the design, user interface, and experience of your dashboards

Mine Çetinkaya-Rundel

{mirai} and {crew}: next-generation async to supercharge {promises}, Plumber, Shiny, and {targets}

{mirai} is a minimalist, futuristic, and reliable way to parallelise computations – either on the local machine, or across the network. It combines the latest scheduling technologies with fast, secure connection types. With built-in integration to {promises}, {mirai} provides a simple and efficient asynchronous back-end for Shiny and Plumber apps. The {crew} package extends {mirai} to batch computing environments for massively parallel statistical pipelines, e.g. Bayesian modeling, simulations, and machine learning. It consolidates tasks in a central {R6} controller, auto-scales workers, and helps users create plug-ins for platforms like SLURM and AWS Batch. It is the new workhorse powering high-performance computing in {targets}. Talk by Charlie Gao and Will Landau Slides: https://wlandau.github.io/posit2024 GitHub Repo: https://github.com/wlandau/posit2024 `mirai`: https://shikokuchuo.net/mirai/ `crew`: https://wlandau.github.io/crew/

Charlie Gao

Aleksander Dietrichson - AI for Gaming: How I Built a Bot to Play a Video-Game with R and Python

I recently undertook to build a robot to play a video game online. Using reinforcement learning, a custom computer vision model, and browser automation –all implemented in R/Python– I was able to create an AI that played the game to perfection. In this presentation, I will share the lessons learned as I went through this process and some hints to avoid the pitfalls I tackled. I will present some real-world business cases to answer the obvious why-question. For colleagues who teach Data Science and AI, I will show how an activity such as this can provide the entry point and basis for discussion for more than half a dozen topics, ranging from formal logic, game theory, and empirical inference, all the way to Shiny and Quarto. Talk by Aleksander Dietrichson Write-up: https://chi2labs.github.io/x-mas-3/q/ GitHub Repo: https://github.com/chi2labs/x-mas-3

Alex Chisholm - Deploying data applications and documents to the cloud

Creating engaging data content has never been easier, yet easily sharing remains a challenge. And that's the point, right? You cleaned the data, wrangled it, and summarized everything for others to benefit. But where do you put that final result? If you're still using R Markdown, perhaps it's rpubs.com. If you've adopted Quarto, it could be quartopub.com. Have a Jupyter notebook? Well, that's a different service. And this is just for docs. Want to deploy a streamlit app? Head to streamlit.io. Shiny? Log into shinyapps.io. Dash? You could use ploomber.io, if you have a docker file - and know what that is. This session summarizes the landscape for online data sharing and describes a new tool that Posit is working on to simplify your process. Talk by Alex Chisholm Slides: https://docs.google.com/presentation/d/1zulnuaT2Dm_vM0l9Gd3vS26KWJuAf0gJ1pcFKjTUNbI/edit?usp=sharing

Andrew Bates (replacing Mike Stackhouse) - Making an App a System

What data processing in your Shiny app is redundant or must happen within the app at all? What makes Shiny beautiful is how it blends data visualization into a compact bundle of code. That said, there are challenges to overcome to get from a developer’s console to users’ screens. Tools like Posit Connect help with this process, but as an app matures, developers and their users may encounter different performance issues. To address this, sometimes this means evolving and introducing separate data pipelines. In this presentation, we will overview some different types of scaling issues for a Shiny app. Additionally, we will introduce the new package {matte}, which provides support for adding data pipelines to your app that live outside Shiny. Talk by Andrew Bates

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

Brennan Antone - Democratizing Organizational Surveys with Quarto and Shiny

When gathering data from groups (e.g., surveys), where does it go, and who does it help? How can we deliver value directly back to all survey participants, not just top organizational decision-makers? In this talk, I discuss re-designing how we report on organizational feedback surveys, moving from a top-down to a bottom-up approach to organizational change. Interactive dashboards can make data and feedback accessible to all. This tackles challenges with data quality, privacy, and power - allowing everyone to benefit directly from their data. I examine how Quarto and Shiny enable the creation of "flipped reports", and describe takeaways from implementing them with two Fortune 500 companies. This talk teaches how personalized tools can make data accessible to all, and can alter the power dynamics around how organizations enact change. Talk by Brennan Antone Slides: https://github.com/BrennanAntone/positconf24 Professional Website: https://brennanantone.com/

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

Computing and recommending company-wide employee training pair decisions at scale... posit conf 2024

Regis A. James developed MAGNETRON AI, an innovative, patent-pending tool that automates at-scale generation of high-quality mentor/mentee matches at Regeneron to enable rapid, yet accurate, company-wide pairings between employees seeking skill training/growth in any domain and others specifically capable of facilitating it. Built using R, Python, LLMs, shiny, MySQL, Neo4j, JavaScript, CSS, HTML, and bash, it transforms months of manual collaborative work into days. The reticulate, bs4dash, DT, plumber API, dbplyr, and neo4r packages were particularly helpful in enabling its full-stack data science. The expert recommendation engine of the AI tool has been successfully used for training a 400-member data science community of practice, and also for larger career development mentoring cohorts for thousands of employees across the company, demonstrating its practical value and potential for wider application. Talk by Regis A. James Slides: https://drive.google.com/file/d/1jq-WjuFz1Lp3m6v0SYjNoW1WcCBKPMs3/view?usp=sharing Referenced talks: https://www.youtube.com/@datadrivendecisionmaking Full Title: Computing and recommending company-wide employee training pair decisions at scale via an AI matching and administrative workflow platform developed completely in-house

Emily Riederer - Python Rgonomics

Data science languages are increasingly interoperable with advances like Arrow, Quarto, and Posit Connect. But data scientists are not. Learning the basic syntax of a new language is easy, but relearning the ergonomics that help us be hyperproductive is hard. In this talk, I will explore the influential ergonomics of R's tidyverse. Next, I will recommend a curated stack that mirrors these ergonomics while also being genuinely truly Pythonic. In particular, we will explore packages (polars, seaborn objects, greattables), frameworks (Shiny, Quarto), dev tools (pyenv, ruff, and pdm), and IDEs (VS Code extensions). The audience should leave feeling inspired to try Python while benefiting from their current knowledge and expertise. Talk by Emily Riederer

Eric Nantz - A New Era for Shiny-based Clinical Submissions using WebAssembly

In life sciences, Shiny has enabled tremendous innovations to produce web interfaces as front-ends to sophisticated analyses, interactive visualizations, and clinical reporting. While industry sponsors have widely adopted Shiny, a relatively unexplored frontier has been the inclusion of a Shiny application inside a submission package to the FDA. The R Consortium R-Submissions Working Group has continued the momentum of previous submission pilots, such as the successful Shiny app submission to the FDA in 2023. In this talk, I will share the journey of how we used containers and WebAssembly for a new and innovative approach to sharing a Shiny application directly with the FDA, paving the way for new innovation in the clinical submission process. Talk by Eric Nantz Slides: https://github.com/rpodcast/shiny-webr-posit2024 GitHub Repo: https://github.com/RConsortium/submissions-pilot4-webR

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

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

Joseph Richey - Leveraging Data in a Volunteer Fire Department

The majority of fire departments in the United States are volunteer-based organizations. As an emerging professional in the field of data science, I was able to help my local fire department track, manage, and analyze data using R Shiny, Python, and AWS. This has allowed for increased efficiency within the department, and better transparency for fire department and local government officials. Talk by Joseph Richey Slides: https://docs.google.com/presentation/d/1JjjjfDBox7W1MK6CwBmu3cIFpzSEnLu_/edit?usp=sharing&ouid=117509225446346298730&rtpof=true&sd=true GitHub Repo: https://github.com/JosephRichey/fire-data

Lovekumar Patel - Empowering Decisions: Advanced Portfolio Analysis and Management through Shiny

This talk explores the creation of an advanced portfolio analysis system using Shiny and Plumber API. Focused on delivering real-time insights and interactive tools, the system transforms financial analysis with user-centric design and reusable Shiny modules. The talk will delve into how complex financial data is made dynamic and interactive via an internal R package integrating with an ag-grid javascript library to enhance user engagement and decision-making efficiency. A highlight is the Plumber API's dual role: powering the current system and hosting other enterprise applications in other languages (python), demonstrating remarkable cross-platform integration. This system exemplifies the innovative potential of R in financial analytics. Talk by Lovekumar Patel Slides: https://docs.google.com/presentation/d/1dJJRBTxPL4x6anK_b8ya3iU4aIoFrC-z/edit?usp=sharing&ouid=110604780241045194549&rtpof=true&sd=true GitHub Repo: https://github.com/lkptl

Marcin Dubel - Shiny in Action: Transforming Film Production with TARS

Behind every 'Lights! Camera! Action!' is a complex choreography of 20+ departments, complicated by the manual creation of 50+ weekly or monthly reports over each production's 2-3 year span. Our R/Shiny app ("TARS") streamlines communication and coordination of this process via data integrations, interactive UIs, customizable notifications, and reports. This presentation will unpack the layers of our app's functionality, spotlighting Shiny and R's pivotal roles in modernizing the business of film production, data confidentiality, and inter-departmental synergy. Developers will learn about methodologies for enhancing data flow, security measures, and custom notifications, offering inspiration for navigating similar challenges. Talk by Marcin Dubel

Mark Wang - Using GitHub Copilot in R Shiny Development

Generative AI tools, like the GitHub Copilot, are revolutionizing software development, by automating routine tasks and boosting programmers' productivity. R Shiny development is uniquely positioned to benefit from GitHub Copilot. Copilot can accelerate the process by automating front-end tasks, especially those involving HTML and JavaScript, as well as testing and documentation, thus letting R Shiny developers focus more on the value-added aspects of data science and statistics. The basic workflow of using GitHub copilot in R Shiny development has three parts: prompt, context, and iteration. Three types of prompts: command, question, and lead-in, all have strong use cases in R development. Specific prompts create more helpful results as compared to vague ones, and Copilot can help add more specificity to your prompts when you are not familiar with the domain topic. The most important source of context for Copilot is typically your codebase, which should be well-organized and open in your IDE. Additionally, knowledge on the internet, as well as simple and concrete examples, can also be valuable contexts. However, sensitive personal information in your context can stop Copilot from generating appropriate responses. Iteration is modifying and enriching your prompt and context to improve the quality of Copilot's responses. Function and module documentation is a valuable step of iteration. As R Shiny is often used with fast-hanging data, Copilot serves as a powerful tool in the iteration from static to dynamic app testing in the shinytest2 framework. As we iterate over our prompt and context to generate better responses from Copilot, it is worthwhile to build an internal knowledge base in the form of prompt dictionaries. A Copilot knowledge base can include information specific to your organization that can be reused across projects, such as security and compliance conventions, code and documentation standards, and employment process and environment. Talk by Mark Wang Slides: https://1drv.ms/b/c/fd70c8a06be32527/ER8WuxYEw_NKksTI6t5wCDgBrO9slTr0HaumYp1eg2xYYA?e=KwQSfb GitHub Repo: https://github.com/ZIBOWANGKANGYU/posit_2024_prez/tree/master/presentation

Melissa van Bussel - Practical Tips for Using Generative AI in Data Science Workflows

Now that we're a couple of years into the age of Generative AI, it's clear that this technology has the power to transform the way that we work. As Generative AI continues to evolve, the ways that we use these models should evolve, too. In this talk, we'll explore how we, as data professionals, can maximize the benefits of these tools in 2024 and how they can be incorporated into our everyday workflows. We'll also look at creative use cases that might not seem immediately obvious, but that will allow us to combine Generative AI with other data science tools that we already know and love, like Quarto and Shiny. Talk by Melissa van Bussel Slides: https://github.com/melissavanbussel/posit-conf-2024/blob/main/slides.pdf GitHub Repo: https://github.com/melissavanbussel/posit-conf-2024

Vasant Marur - Quality Control to avoid GIGO in Deep Learning Models

Deep Learning models help answer scientific questions, but they are only as accurate as the data we feed them. To ensure accurate models, we can implement quality control (QC) methods to ensure only high-quality data is used in training these models. Scientists generate thousands of images as part of Image-Based High Content Screening assays. To help them quickly assess the quality of these images before considerable time is spent analyzing them, we developed an interactive tool using Shiny that displays which images were flagged as part of QC. In this talk, I’ll explain how we created this QC tool and share ideas on how you could leverage your existing code and turn it into a stand-alone web app your stakeholders can use. Talk by Vasant Marur

Wait, that’s Shiny? Building feature-full, user-friendly interactive data explorers - Posit Conf

In my work I am often asked to develop interactive data explorers for public-use data sets, with an emphasis on making the tools engaging, easy to use, and understandable for a general audience. I’d like to talk about the work my team does to develop user-friendly Shiny applications that look and feel like full websites and share some of the tools we use. This includes things like designing landing pages, creating detailed “About” pages, letting users share links to specific charts or download static versions, adding social media sharing links, site meta tags, sub-URLs, and so much more. After attending this talk, I hope others are excited about leveraging tools to make their users say “Wait, that’s Shiny?” Talk by Kiegan Rice Full title: Wait, that’s Shiny? Building feature-full, user-friendly interactive data explorers with Shiny and friends GitHub Repo: https://github.com/kiegan/wait-thats-shiny

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

PDF Palooza 🎉 Save time with dynamic PDFs powered by Quarto, Shiny & Posit

Many of us need to produce multiple PDF versions for monthly business reports. This workflow demonstrates how to save time by dynamically creating PDFs using Quarto and Shiny, while also showcasing the beautiful possibilities Typst offers for PDF design. You will learn: 1. What is Typst and its advantages over LaTeX. 2. Typst formats: posters, docs, flyers, articles, etc. 3. New Quarto 1.5 feature - Typst CSS 4. How to use a Shiny application to create Typst PDFs dynamically Helpful resources for this workflow: GitHub Repo: https://github.com/ryjohnson09/pdfpalooza Q&A Recording: https://youtube.com/live/RTr5D4xV5_Q?feature=share We host these Workflow Demos the last Wednesday of every month, and you can add them to your calendar with this link: https://www.addevent.com/event/Eg16505674

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

Workflow Demo Live Q&A - October 30th!

Please join us for the live Q&A session for the October 30th Workflow Demo - this Q&A room will open up immediately following the demo. Please note that the demo itself will play from here: Save time with dynamic & professional PDFs powered by Shiny & Posit: https://youtu.be/dCoHNIPQzJE Anonymous questions: https://pos.it/demo-questions Demo: 11 am ET Q&A: ~11:30 am ET Helpful resources for this workflow: Repo: https://github.com/ryjohnson09/pdfpalooza Recording: https://youtu.be/dCoHNIPQzJE

The importance of relevant analytics | Nechama Katan @ Pfizer | Data Science Hangout

We were recently joined by Nechama Katan, Director of Innovative Data Analytics at Pfizer, for a conversation about relevant analytics, the importance of understanding business context, and strategies for bridging silos within organizations. "Technology on its own doesn't do you any good." Nechama highlighted the common pitfall of organizations prioritizing technology over business needs. She stressed that technology is only valuable when it directly addresses a business problem. Often, companies invest in complex data infrastructure and tools without a clear understanding of how they will be used to answer critical business questions. This can lead to frustration and a lack of adoption by business users. Nechama encouraged data professionals to prioritize understanding the business context behind the data. By asking questions, collaborating with colleagues in other departments, and actively seeking to understand the challenges and goals of the business, data scientists can ensure their work delivers tangible value. How would you recommend acquiring the business background needed to succeed? In our Hangout chat, Nechama stressed the importance of building relationships and breaking down silos within organizations. She encouraged data professionals to: ● Be curious: Ask questions relentlessly, seeking to understand the perspectives and challenges of colleagues in other departments. ● Offer help: Identify areas where your expertise can be valuable to others and proactively offer assistance. ● Be kind: Approach interactions with empathy and a genuine desire to build connections. In sharing her career advice, Nechama advocated for "managing down," prioritizing collaboration and support for peers. Building strong relationships and fostering a culture of teamwork is essential for solving problems and achieving impactful outcomes Resources from the Chat: [Mosaic Crochet Shiny App](https://apps.machlis.com/shiny/crochetapp/) [Cascades: How to Create a Movement that Drives Transformational Change by Greg Satell](https://www.amazon.com/Cascades-Create-Movement-Drives-Transformational/dp/1260454010) [Launching DyslexicU, the World's First University of Dyslexic Thinking](https://www.virgin.com/branson-family/richard-branson-blog/launching-dyslexicu-the-worlds-first-university-of-dyslexic-thinking) [Move Fast and Break Shit: Burning Man's Lessons for Success in Work and Life by Heather White](https://www.amazon.com/Move-Fast-Break-Shit-Burn-ebook/dp/B08JNWBQ9Y) [One Data Scientist’s Assimilation of the Product Lexicon](https://medium.com/@eugene.geis/one-data-scientists-assimilation-of-the-product-lexicon-3dd0e7b05be1) [Spurious Correlations](https://tylervigen.com/spurious-correlations) [There's Only One R in Pfizer](https://www.youtube.com/watch?v=bnRdI6jvGpM) ► 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!) Thanks for hanging out with us!

Build Shiny apps with AI ✨

View the full video here: https://www.youtube.com/watch?v=fJNKdwdVQ8Q Try it out here, free: https://gallery.shinyapps.io/assistant/ Get started with Shiny for R and Python: https://shiny.posit.co #pythoncontent

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

Hands-on Session: GenAI to Enhance Your Statistical Programming - Phil Bowsher & Cole Arendt

GenAI in Pharma 2024 kicks off with Posit's Phil Bowsher and Cole Arendt leading an interactive session on utilizing generative AI tools to enhance statistical programming. Resources mentioned in the session: * PharmaSUG workshop "GenAI to Enhance Your Statistical Programming": https://colorado.posit.co/rsc/genai_R_pharmasug/slides.html * AI Exploration and Innovation for the Clinical Data Scientist: https://www.lexjansen.com/phuse-us/2024/et/PAP_ET08.pdf * Shiny Chat - Using chatstream to show how easy an OpenAI chat app is! https://github.com/colearendt/shiny-chat * GitHub Copilot on Posit Cloud: https://posit.co/blog/github-copilot-on-posit-cloud/ * Introducing Shiny Templates: https://www.youtube.com/watch?v=zQJiMRStYE8&ab_channel=PositPBC * Introducing Shiny Express: https://shiny.posit.co/blog/posts/shiny-express/

Ralph Asher @ Data Driven Supply Chain | Data Science Hangout

In this Hangout, Ralph talks about his experiences in the supply chain industry - a hidden gem of a data job field - and his educational background in Operations Research. He talks about the types of problems supply chain analysts work to solve, how 2020 reshaped the landscape of supply chain, and how he decided to start his own business. He also gives some great advice about marketing yourself, whether you’re starting your own consulting company or looking for a new role: be specific about what you want and the problems you solve. If you’ve been curious about supply chain jobs, you’ll want to hear Ralph’s perspective! Speaker bio: Ralph Asher is the founder of Data Driven Supply Chain LLC, a Minneapolis-based consultancy working at the intersection of supply chain and decision science. Since 2021, Ralph and his team have used decision science and data science to build advanced supply chain models, helping clients make tough supply chain decisions around network design, inventory optimization, and more. Timestamps: 03:00 About Ralph Asher 05:35 What type of problems do supply chain analysts work on? 07:55 What type of data jobs are there in the Supply Chain Industry? 10:15 How did COVID-19 impact supply chain jobs? 13:10 How do you know you’re ready to start a consulting business? 15:25 With so much data, how do you make sure insights are actionable and not irrelevant? 17:30 What are some examples of data management or governance challenges in supply chain? 18:15 What career advice would you give new grads or people looking to switch careers? 21:10 Why being specific about what you want to do gets you job opportunities 23:55 Book recommendation: The Black Swan and preserving optionality, keeping doors open 25:20 Is a supply chain consultant more valuable and effective than a supply chain department? 26:50 How do you learn all the parts of running a business by yourself? The E-Myth Revisited book 29:20 Do you ever have to convince people to move past Excel? Supply chain runs on Excel. 31:05 Career advice - lean into something you’re good at. The Algebra of Wealth book 33:30 How do you manage data and metadata? How do you manage knowledge for your business? 36:25 How do you determine which clients to accept and which to turn away as a consultant? 37:45 How do you do discovery work with a consulting client to make sure they’re a fit? 39:10 Saying no to the wrong jobs so that you can say yes to the right jobs 40:00 Can client discovery be done as a paid project? Could it be its own product? 44:00 As a consultant, how do you make the unseen hours of labor visible? 46:10 What is a good entry point for a company that doesn’t have a dedicated supply chain team? 47:35 Should you go back to school for another degree to get a job that feels out of reach? 49:10 How does your career growth change between IC and management? 50:55 What are some supply chain communities to join? 52:10 Do supply chain teams work within data teams or separately? 55:50 As a consultant on your own, how do you keep your skills sharp and up to date? 57:20 How do you use Shiny in your supply chain consulting jobs? Resources mentioned in the episode: The Black Swan by Nassim Taleb: https://www.randomhousebooks.com/books/176226/ The E-Myth Revisited by Michael Gerber: https://www.michaelegerbercompanies.com/product/the-e-myth-revisited/ The Irresistible Consultant’s Guide to Winning Clients by David Fields: https://www.davidafields.com/books/#section-1 The Algebra of Wealth by Scott Galloway: https://www.penguinrandomhouse.com/books/730881/the-algebra-of-wealth-by-scott-galloway/ Notion: https://www.notion.so/ HubSpot: https://www.hubspot.com/products/crm CSCMP, Council for Supply Chain Management Professionals: https://cscmp.org/ ASCM, the Association for Supply Chain Management: https://www.ascm.org/ ISM, Institute for Supply Management: https://www.ismworld.org/ INFORMS, Institute for Operations Research and Management Sciences: https://www.informs.org/ ________________________ ► 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 The Hangout is a gathering place for the whole data science community to chat about data science leadership and questions you're all facing that happens every Thursday at 12 ET. To join future data science hangouts, add to your calendar here: https://pos.it/dsh We'd love to have you join us in the conversation live! Thanks for hanging out with us!

Deploy an LLM-powered Shiny for Python app to Connect Cloud in minutes!

Connect Cloud lets you quickly deploy data applications and documents from public GitHub repositories for Python and R projects. This short demo showcases secret variable management on Connect Cloud to help deploy an LLM-powered Shiny for Python application. → Signup for a free Connect Cloud account → https://connect.posit.cloud/ → View the how-to guide → https://docs.posit.co/connect-cloud/how-to/python/llm-shiny-python.html

Next Generation Shiny Apps with {bslib}

In this workshop, led by Garrick Aden-Buie, a software engineer for Shiny at Posit, you will learn how to build Shiny apps using modern user interfaces and layouts with bslib, the next generation of Shiny UI. Garrick will guide you through creating stylish and convenient dashboard layouts and components, demonstrating how bslib can effectively replace shinydashboard. Additionally, you will explore innovative techniques for deploying Shiny apps using shinylive, enabling the creation of static sites that run entirely in the user’s browser without the need for a Shiny server. Main Sections 00:00 Introduction 11:00 Shiny 14:57 How bslib started 18:29 Theming from start to advanced 22:19 College Scorecard Data 39:24 bslib layouts 01:20:25 Advanced layouts 01:49:18 Filling Layouts 02:42:09 Details on demand 02:50:01 New inputs 02:53:15 Wrap up More resources R Validation Hub Site: https://www.pharmar.org/ Main Site: https://www.r-consortium.org/ News: https://www.r-consortium.org/news Blog: https://www.r-consortium.org/news/blog Join: https://www.r-consortium.org/about/join Twitter: https://twitter.com/rconsortium?lang=en LinkedIn: https://www.linkedin.com/company/r-consortium Mastodon: https://fosstodon.org/@RConsortium

Garrick Aden-Buie

Creating tests for Shiny for Python apps | Karan Gathani | Posit

With the Shiny for Python v1.0 release, Shiny provides a simple way to create a test file for your Shiny app. The shiny add test command is a helpful CLI tool for Shiny app developers. It simplifies the process of creating test files for their applications. When you run this command, it prompts you to input two pieces of information: the path to your Shiny app file and the desired location for the new test file. Once you provide these details, the command automatically generates a test file at the specified location. This new file includes a pre-made test template, giving you a solid starting point for writing your app's tests. Reference documentation - https://shiny.posit.co/py/docs/unit-testing.html https://shiny.posit.co/py/docs/playwright-testing.html

Karan Gathani

Using controllers to write robust Shiny for Python app tests | Karan Gathani | Posit

With the Shiny for Python v1.0 release, controllers were exposed to provide a structured and consistent way for users to interact with and test UI components in Shiny applications. They offer an abstraction layer that encapsulates the complexity of interacting with specific UI elements, making it easier for developers to write robust tests and automate interactions with their Shiny apps. Reference documentation - https://shiny.posit.co/py/api/testing/ https://shiny.posit.co/py/docs/playwright-testing.html

Karan Gathani

What did journalism teach you about data storytelling? | Sharon Machlis | Data Science Hangout

In this episode, Sharon Machlis shares her journey from journalist to journalist-who-codes. You’ll hear her talk about the serendipitous way she found herself covering business and technical news, the lessons she learned about storytelling with data over the years, and how she knew it was time to retire. You’ll also learn how to find the data community on social media in a post-twitter world, including a primer on Mastodon and how it works without an algorithm. Timestamps: 02:45 About Sharon Machlis 04:55 How did you decide to start using R? 07:45 What did journalism teach you about data storytelling? 10:15 What’s your favorite headline you ever wrote? 10:45 How do you write high quality articles quickly? 12:30 How do you find people to follow on Mastodon? 15:35 How do you decide what new data topics to learn about or focus on? 20:55 What do you think about specialization in a world where everyone now codes? 23:25 Is domain expertise in data jobs undervalued? 27:00 What resources do you have for learning to write well? 32:00 Have you ever had a career setback that was a blessing in disguise? 34:05 How do you make data presentations more interesting? 37:00 Where is the data community now that Twitter is dead? Bluesky? Threads? 40:45 Has the evolution of graphics like the New York Times uses increased interest in data? 42:15 How did you decide you were ready to retire? 45:30 What data journalists should we be following? 47:55 What factors contribute to someone deciding to retire? 50:35 What projects can you focus on in retirement that you weren’t able to do before? 55:35 What resources do you recommend for learning Python? 57:25 Career advice from a data journalist Links mentioned in this episode: Sharon’s retirement journey: https://nextchapter.machlis.com Links Sharon shared in the chat: https://apps.machlis.com/shiny/positconf/ One way to see public posts on Mastodon with the #rstats hashtag without needing an account: https://fosstodon.org/tags/rstats Guide to R: https://www.computerworld.com/article/1533880/beginners-guide-to-r-introduction.html How to find better content on Mastodon by Sharon: https://www.infoworld.com/article/2338712/6-ways-to-find-better-content-on-mastodon.html Resources Sharon shared after the Hangout Suggested prompts to use LLMs to help you learn a skill, by Lilach Mollick and Ethan Mollick https://www.moreusefulthings.com/instructor-prompts Journalism-related resources for learning Python: 1. First Python Notebook: A step-by-step guide to analyzing data with Python and the Jupyter notebook, by Ben Welsh, currently news applications editor at Retures https://palewi.re/docs/first-python-notebook/ 2. Python's Not (Just) for Unicorns, by J Soma, journalism prof at Columbia University https://littlecolumns.com/learn/python/ Journalism-related resources to learn R - both a bit old but still work: 1. R for Journalists by Andrew Ba Tran, investigative data reporter at the Washington Post https://learn.r-journalism.com/en/ 2. My book Practical R for Mass Communication and Journalism Several chapters free: https://www.machlis.com/R4Journalists/ My Shiny app with a searchable list of Mastodon accounts who post about R with the #RStats hashtag: https://apps.machlis.com/shiny/rstats/ Searchable table of all my Mastodon posts (it's a public Shiny app, you don't need a Mastodon account): https://www.machlis.com/mastodon.php Mosaic crochet Shiny app, the most popular app I ever published https://apps.machlis.com/shiny/crochetapp/ Additional Shiny apps: https://apps.machlis.com/ Thoughts on using generative AI to help with your writing: How to . . . use ChatGPT to boost your writing: https://www.oneusefulthing.org/p/how-to-use-chatgpt-to-boost-your or I, Cyborg: Using Co-Intellgience: https://www.oneusefulthing.org/p/i-cyborg-using-co-intelligence both by Ethan Mollick

Workflow Demo Live Q&A - August 28th!

Please join us for the live Q&A session for the August 28th Workflow Demo - this Q&A room will open up immediately following the demo. How to use pins + Shiny for ever-changing data: https://youtu.be/u2OK8IWJWhk Anonymous questions: https://pos.it/demo-questions Demo: 11 am ET [https://youtu.be/u2OK8IWJWhk] Q&A: ~11:30 am ET

How to automatically detect data changes for your Shiny Calendar app (ft: Jira, pins, Posit Connect)

Do you manage constantly changing data and need your Shiny app to automatically update? On August 28th at 11 am ET, Isabella Velásquez demonstrated a streamlined workflow for handling frequently updated datasets in Shiny. You'll see how to simplify your process for keeping dynamic data current and how to reflect those changes in your app or dashboard. Github repo to follow along or make it your own! https://github.com/posit-marketing/shiny-calendar Timestamps: 1:03 - Introduction of the project (end goal: calendar that integrates with Jira to track and visualize a schedule for managing deadlines of content) 2:26 - Pulling data from an API in Python or R 2:56 - Introduction to pins (and scheduling automatic refreshes of it in Posit Connect) 4:30 - Introduction to Shiny for both Python and R (its power lies in reactivity) 5:10 - Enter pin_reactive_read() function 6:12 - Introduction to Posit Team 6:37 - Opening a new session within Posit Workbench and overview of code needed to create the calendar [Github repo: https://github.com/posit-marketing/shiny-calendar] 12:07 - toastui package used for Calendar (ex: adding colors to labels) 12:47 - Writing clean data to Posit Connect board 13:16 - Rendered Quarto doc for pulling Jira data from the board 14:00 - Deploying Quarto to Posit Connect (using push button deployment) and scheduling to run 16:54 - Using the data just pinned in the Shiny app 21:17 - Overview of Shiny Content Calendar application 23:04 - Creating an issue in Jira board and adjusting schedule in Posit Connect to show new item in Shiny calendar. 24:00 - pin_reactive_read automatically detects change and shows it in the Shiny app During this workflow demo, you will learn: 1. How {pins} stores and retrieves ever-changing data with ease 2. How to use pin_reactive_read() in Shiny to automatically trigger updates when your data changes 3. How Posit Connect can be set up to rerun your {pin} on a schedule, ensuring your app is updated without disruption 4. How to deploy an always-up-to-date app for seamless sharing with stakeholders Other helpful links: pin_reactive_read: https://pins.rstudio.com/reference/pin_reactive_read.html Basic reactivity in Mastering Shiny: https://mastering-shiny.org/basic-reactivity.html#reactive-programming Understanding reactivity on the Shiny site: https://shiny.posit.co/r/articles/build/understanding-reactivity/ Github repo: https://github.com/posit-marketing/shiny-calendar Shiny Calendar: https://pub.demo.posit.team/public/shiny-calendar/ Q&A Recording If you like these workflow demos, you can join us monthly! They happen the last Wednesday of every month at 11 am ET. Add it to your calendar here: https://pos.it/team-demo

Share your data apps and docs easily with Connect Cloud

Turning your data work into applications and documents for others to consume is one of the most rewarding parts of data science. It can also be one of the most complex. You shouldn’t need a systems engineer to deploy your Shiny application or publish your Quarto document. Now, in Public Alpha, Connect Cloud makes it simple to publish and share your favorite Python and R frameworks within a simple cloud environment in just a few minutes. All you need is code in a public GitHub repository. Connect Cloud does the rest. This live event will demonstrate how Connect Cloud fits into your workflow and returns a URL for your deployments that you can share with the world. Try Connect Cloud: https://connect.posit.cloud/

Workflow Demo Live Q&A - July 31st

Please join us for the live Q&A session for the July 31st Workflow Demo - this Q&A room will open up immediately following the demo. How to create editable data tables in Shiny for Python Anonymous questions: https://pos.it/demo-questions Demo: 11 am ET [https://youtu.be/zDJc8sXh2qw?feature=shared] Q&A: ~11:30 am ET

How to create editable data tables in Shiny for Python

You built a beautiful Shiny app…but someone just asked you where the Excel doc is. Well, what if they had the ability to edit a table within the app, as if it were a spreadsheet?! Editable tables are a recently developed feature for Shiny for Python, allowing the table itself to become an input value, so your app can react to—and use—the data your user enters. On Wednesday, July 31st at 11 am, Garrett Grolemund will walk through building a basic app using an editable table and discuss the many potential use cases now enabled. Helpful links: WSJF App - https://github.com/garrettgman/wsjf-app Interest Calculator App - https://github.com/garrettgman/mortgage-app Value Change App - https://github.com/garrettgman/value-changer-app To do a free trial of Posit Connect: https://pos.it/chat-with-us Posit Connect Cloud: https://connect.posit.cloud/ Q&A Session: https://youtube.com/live/-nG5aco-g84?feature=share Ps. We host these workflow demo events the last Wednesday of every month! We'd love to have you join us again! You can add it to your calendar here: https://pos.it/team-demo If you have any questions or suggestions for future sessions, let us know in the comments below :) #python

How to Perfect Your Python Dashboard with Advanced Styling! (HTML/CSS - Shiny for Python)

This is part 5 of our multi-part series on creating professional dashboards with Shiny for Python. In this video, we dive into advanced styling techniques to enhance the visual appeal and professionalism of your Shiny dashboards. We'll cover: - Adding a logo and custom title - Making use of custom HTML elements - Using CSS to style Shiny components - Customizing Altair charts for a polished look - Advanced Plotly chart modifications - Applying a consistent color theme and layout By the end of this video, you'll have a styled dashboard, ready for a professional presentation. Access the GitHub repo with all parts of this project: https://github.com/KeithGalli/shiny-python-projects Shiny for Python Homepage: https://shiny.posit.co/py/ Check out the complete documentation here: https://shiny.posit.co/py/api/express/ Video by @KeithGalli **Video Timeline:** 0:00 - Video Overview & Setup 1:50 - Modifying HTML and CSS in Shiny 7:44 - Adding a Logo Image 10:26 - Styling Labels and Containers (Aligning our Image w/ the Title — Custom Divs) 20:20 - Customizing Altair Charts (Gridlines, Font, Axis Labels, Etc.) 27:49 - Customizing Plotly Visualizations 37:16 - Customizing Seaborn & Folium Heatmaps 44:15 - Final Touches, Clean Up, Recap and Next Steps If you enjoyed this series, give it a thumbs up and subscribe to the channel to stay updated! 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

How to combine Matplotlib, Plotly, Seaborn, & more in a single Python Dashboard! (Shiny for Python)

This is part 4 of our multi-part series on creating professional dashboards with Shiny for Python. In this video, we'll explore how to integrate popular Python visualization libraries like Matplotlib, Plotly, Seaborn, and Altair into your Shiny apps. This allows you to leverage your existing visualization skills and seamlessly include them in interactive dashboards. We'll cover: - Integrating Matplotlib and Seaborn for detailed visualizations - Utilizing Altair and Plotly for dynamic charts - Implementing Folium for interactive maps - Customizing data tables with additional filters and selection modes By the end of this video, you'll have a rich and diverse set of visualizations in your Shiny dashboard, setting the stage for the final styling touches in the next video. Shiny for Python Homepage: https://shiny.posit.co/py/ Access the GitHub repo with all parts of this project: https://github.com/KeithGalli/shiny-python-projects Check out the complete documentation here: https://shiny.posit.co/py/api/express/ Video by @KeithGalli Video Timeline! 0:00 - Video Overview & Recap of Previous Video Dashboards 1:38 - Getting Setup with the Code (cloning branch from GitHub) 3:15 - Adding Matplotlib-based visualizations (render.plot Shiny for Python decorator) 10:15 - Create a Seaborn Heatmap Chart (Sales Volume by Hour of the Day) 14:59 - Creating Interactive Charts with Jupyter Widgets (Plotly, Altair, Bokeh, Pydeck, & More…) | render_widget decorator 20:14 - Implementing Folium for Location-Based Heatmaps (render.ui decorator) 25:32 - Enhancing DataFrames with Filters and Selection Modes (render.data_frame, render.DataGrid, render.DataTable, etc.) 28:49 - Additional Rendering Options, Final Touches and Next Steps Stay tuned for part 5, where we'll focus on styling and finalizing our dashboard. If you enjoyed this video, give it a thumbs up and subscribe to the channel to stay updated! 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

Data engineering for the 99% | Will Hipson @ HIAA | Data Science Hangout

We were recently joined by Will Hipson, Data Engineer at Halifax International Airport Authority to chat about scrappy data engineering for the 99% - managing the full data lifecycle from extraction to presentation with a team of one. Speaker bio: Will Hipson is a data engineer at a medium-sized Canadian airport at the early stages of democratizing its data access. Will has a PhD in Psychology and Quantitative Analysis but transitioned out of academia after falling in love with R and data science. Now, he works across all areas of the data lifecycle, from building pipelines and maintaining databases to developing Shiny apps and Quarto docs for presenting data. He believes data engineering doesn't need to be synonymous with massive enterprise platforms or bleeding edge LLMs. Instead, most organizations simply need help finding data and making sense of it. At HIAA, he helped architect a data platform around data discovery, data literacy, and data governance. He built creative solutions for orchestrating data pipelines that resulted in the development of an R package called maestro (https://github.com/whipson/maestro/) that they recently released to the community. Links mentioned: maestro package: https://github.com/whipson/maestro/ HIAA x Posit Success Story: https://posit.co/about/customer-stories/halifax-airport/ ________________________ ► 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 The Hangout is a gathering place for the whole data science community to chat about data science leadership and questions you're all facing that happens every Thursday at 12 ET. To join future data science hangouts, add to your calendar here: https://pos.it/dsh We'd love to have you join us in the conversation live! Thanks for hanging out with us!

How to make your Python Dashboard look Professional! (Layouts in Shiny)

This is part 3 of our multi-part series on creating professional dashboards with Shiny for Python. In this video, we focus on enhancing the visual appeal and structure of your Shiny dashboards using various layout components. We'll cover: - Implementing layout templates for quick setup - Using cards and sidebars for a clean, organized look - Customizing columns and grids for better data presentation - Adding tab options for multiple views within a dashboard By the end of this video, you'll have a more polished and professional-looking dashboard, setting the stage for advanced visualizations in upcoming videos. Shiny for Python Homepage: https://shiny.posit.co/py/ Access the GitHub repo with all parts of this project: https://github.com/KeithGalli/shiny-python-projects Check out the complete documentation here: https://shiny.posit.co/py/api/express/ Video by @KeithGalli Video Timeline! 0:00 - Video Overview & Progress Thus Far 1:28 - Using Shiny Templates to Get Started Fast 3:21 - Using Layout Components to Customize our Apps (Cards, Sidebars, Tabs, etc.) 7:55 - Adding a Sidebar within a Card 12:38 - Adding a Card with Tabs to Display Various Visualizations 17:35 - Structuring Data in Columns / Grids (layout_columns() & layout_column_wrap()) 26:30 - Final Touches & Tips (Filling in Visualizations into our Tab Views) Stay tuned for part 4, where we'll add more advanced visualizations, and part 5, where we'll focus on customizing styles and adding final touches. If you enjoyed this video, give it a thumbs up and subscribe to the channel to stay updated! 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

Predicting Lending Rates with Databricks, tidymodels, and Posit Team

Machine learning algorithms are reshaping financial decision-making, changing how the industry manages financial risk. For our workflow demo today on June 26th at 11 am ET, Garrett Grolemund at Posit will show how to use both Posit and Databricks to apply machine learning methods to the consumer credit market, where accurately predicting lending rates is critical for customer acquisition. *Please note that while the workflow focuses on a financial example, the general workflow will be useful to those using Databricks and R together across any industry. During this workflow demo, you will learn how to: 1. Connect to historical lending rate data stored in Databricks Delta Lake 2. Tune and cross-validate a penalized linear regression (LASSO) that predicts interest rates 3. Select variables with the penalized linear regression model (LASSO) 4. Build an interactive Shiny app to provide a customer-facing user interface for our model 5. Deploy the app to production on Posit Connect, and arrange for the app to access Databricks Resources for the demo: GitHub repo for today's materials: https://github.com/posit-dev/databricks-finance-app Accompanying Guide: https://pub.demo.posit.team/public/predicting-lending-rates/lending-rate-prediction.html Q&A Recording: https://youtube.com/live/wNI3AhHP7uM Additional follow-up links: GitHub Repo: https://github.com/posit-dev/databricks-finance-app Accompanying Guide: https://pub.demo.posit.team/content/fec42b3d-3aa9-43e1-8312-0ff553d09851/lending-rate-prediction.html While this demo uses ODBC package to connect to Databricks, you can also use sparklyr R package. Learn more about both here: https://docs.posit.co/ide/server-pro/user/rstudio-pro/guide/databricks.html Example using sparklyr instead of ODBC: https://posit.co/blog/reporting-on-nyc-taxi-data-with-rstudio-and-databricks/ Posit Workbench provides additional features for managing Databricks Credentials, learn more here: https://docs.posit.co/ide/server-pro/user/posit-workbench/guide/databricks.html#databricks-with-r For more on the Posit x Databricks partnership: https://posit.co/solutions/databricks/ Blog post on Edgar’s workshop on Databricks at conf: https://posit.co/blog/using-databricks-with-r-conf-workshop/ Solutions article on ODBC and Databricks: https://solutions.posit.co/connections/db/databases/databricks/ Want to chat more with Posit? To talk with Posit about integrating Posit & Databricks: https://posit.co/schedule-a-call/?booking_calendar__c=DatabricksJune2024Demo Had fun and want to join again? You can add the monthly recurring event to your calendar with this link: https://pos.it/team-demo

Alex Freberg @ Analyst Builder | Data Science Hangout

We were recently joined by Alex Freberg (@AlexTheAnalyst) Founder at Analyst Builder to chat about teaching and advocating for data analytics. Speaker bio: Alex is the host of YouTube channel “Alex The Analyst”, Founder of Alex Analytics Consulting, and Founder of Analyst Builder. Lover of all things data. Timestamps: 2:41 - Start of Hangout (past intros and welcome) 5:55 - Lessons learned on influencing others in your company 11:03 - Upcoming Shiny/Quarto tutorials preview 14:20 - Pivot into becoming a data science influencer 20:35 - As someone who teaches, how do YOU like to learn 28:50 - Alex's process for creating tutorial videos 40:32 - Advice for starting your own consulting company 54:36 - Working with clients who are just getting started with data literacy 1:00:00 - Most excited about in the year ahead ________________________ ► 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 The Hangout is a gathering place for the whole data science community to chat about data science leadership and questions you're all facing that happens every Thursday at 12 ET. To join future data science hangouts, add to your calendar here: https://pos.it/dsh We'd love to have you join us in the conversation live! Thanks for hanging out with us!

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

Max Kuhn -SHINYLIVE IS SO EASY

SHINYLIVE IS SO EASY by Max Kuhn Visit https://rstats.ai for information on upcoming conferences. Abstract: shinylive is an extension to the Quarto open-source scientific and technical publishing system. It enables shiny applications to run locally, without a shiny server using WebAssembly. I’ll show examples and discuss the limitations of using shinylive. Bio: Max Kuhn is a software engineer at Posit PBC (nee RStudio). He is working on improving R’s modeling capabilities and maintaining about 30 packages, including caret. He was a Senior Director of Nonclinical Statistics at Pfizer Global R&D in Connecticut. He has been applying models in the pharmaceutical and diagnostic industries for over 18 years. Max has a Ph.D. in Biostatistics. He and Kjell Johnson wrote the book Applied Predictive Modeling, which won the Ziegel award from the American Statistical Association, which recognizes the best book reviewed in Technometrics in 2015. He has co-written several other books: Feature Engineering and Selection, Tidy Models with R, and Applied Machine Learning for Tabular Data (in process). Twitter: https://twitter.com/topepos Presented at the 2024 New York R Conference (May 17, 2024) Hosted by Lander Analytics (https://landeranalytics.com)

Max Kuhn

{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

Communicating Data Science with Shiny! 🚀 Garrick Aden-Buie #datascience #datavisualization #shiny

Ever seen this diagram? It's from R for Data Science, outlining the journey of tackling new data problems. 1️⃣ Start: Import and tidy your data. 2️⃣ Cycle: Transform, visualize, and model your data. 3️⃣ Communicate: Share your findings. But communication isn't just the end—it's an ongoing process! Shiny apps are your secret weapon for this. Scenario 1: Quick Shiny app for colleague feedback ️ refine your work. Scenario 2: Small app grows into a full-featured web application. From small, quick-use apps to robust final products, Shiny evolves with your project needs. Discover why Shiny is essential for every data scientist! Get Started: https://shiny.posit.co

Garrick Aden-Buie

How to: add Dark Mode on your Shiny R apps✨#datascience #datavisualization

How-to: Dark Mode on Shiny for Python apps✨

How to Build, Deploy, & Share a Python Application in 20 minutes! (Using Shiny)

This is a quick-start guide to Shiny for Python. It's part 1 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 walk you through the basics of setting up Shiny for Python, creating your first app, and deploying it so others can use it. We'll cover: - Installing Shiny and necessary dependencies - Writing and running your first Shiny app - Basic UI and server structure - Deploying your app online - Helpful Links Shiny for Python Homepage: https://shiny.posit.co/py/ The link to the final app can be found here: https://keithgalli.shinyapps.io/final-app/ Follow along with the code examples provided in this repository: https://github.com/KeithGalli/shiny-python-projects Check out the complete documentation here: https://shiny.posit.co/py/api/express/ Stay tuned for part 2, where we'll dive deeper into advanced features and customization options. --- Video Timeline! 0:00 - Intro to Shiny & Video Overview 1:43 - Getting Started with the Shinylive Playground 2:44 - Building a custom visualization with Shinylive 5:18 - Easily sharing the code/application for a Shinylive app 6:12 - Building a Shiny Express App locally (VSCode) 9:40 - How to run app if you're not using VSCode 10:17 - Further customization of our app (adding title, using CSV data, dynamic input) 17:15 - Deploying our Shiny app to the web 21:20 - Conclusion & what's coming next in the series Video by @KeithGalli 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

Future of Shiny to the FDA with WebR ✨

For more on How Pharma is Pioneering WebAssembly with webR & Shiny for FDA Clinical Trial Submissions: https://posit.co/blog/webr-fda-pilot/

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

Shiny + Databricks 🫶

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

Shiny for Python vs Streamlit

Rizz + shiny for python = masterpiece

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

Debug your Shiny Apps with VS Code

Resources for Python Data Scientists | Shiny for Python is here✨

Workflow Demo Live Q&A - February 28th

Q&A session from the February 28th Workflow Demo -- Simplify Python web app development with Shiny Express and Posit Team: https://youtu.be/pBPF00M_bfU?feature=shared Anonymous questions: pos.it/demo-questions Demo: 11 am ET Q&A: ~11:30 am ET

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

Workflow Demo Live Q&A - January 31st

Please join us for the live Q&A session for the January 31st Workflow Demo - this will start immediately following the demo. Theming Shiny apps with your company brand" session: https://youtu.be/O6WLERr5bKU Anonymous questions: pos.it/demo-questions Demo: 11 am ET Q&A: ~11:40 am ET

How to bring modern UI to your Shiny apps

Looking for ways to make your Shiny apps a little…shinier? Join Garrett Grolemund at Posit on Wednesday, January 31st at 11 am ET to learn how to theme and brand your own apps. The session will highlight how to: Layout an app with the bslib package (modern UI toolkit with no knowledge of CSS required) Add cards, value boxes, and logos Customize the theme of the app Tweak the theme by swapping out primary colors, secondary colors, and more. Quickly apply the theme to every plot in the app Work with bootstrap classes Helpful Resources: ️ Code at : https://github.com/garrettgman/shiny-styling-demo bslib package: https://rstudio.github.io/bslib/ bsicons package: https://github.com/rstudio/bsicons ️ Bootstrap icons: https://icons.getbootstrap.com/ ️ Bootstrap CSS classes: https://bootstrapshuffle.com/classes thematic package: https://rstudio.github.io/thematic/ gitlink package: https://github.com/colearendt/gitlink ️ Follow-up links: Posit Team: https://posit.co/products/enterprise/team/ Request evaluation: pos.it/chat-with-us Posit Team demo resources: pos.it/demo-resources LIVE Q&A ROOM for ~11:45 am on January 31st: https://youtube.com/live/1G8ZM6kbt8c?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

How to collaborate effectively with other data scientists (version control, project sharing, etc.)

Tis the season for joy and connection, and what better time to extend that collaborative spirit into your data science endeavors By popular demand, our upcoming monthly workflow with Ryan Johnson on December 27th is dedicated to enhancing teamwork. It's recorded, so no worries if you're out! Or perhaps you’ll add us to the mix of holiday movies and watch from the couch! This Month's Focus: All Things Collaborative Working Version control Git-backed deployment Project sharing Date & Time: Wednesday, December 27th at 11 am ET. Packages mentioned: Shiny: https://shiny.posit.co/ bslib: https://rstudio.github.io/bslib/ ️ Follow-up links: Posit Team: https://posit.co/products/enterprise/... Talk to us directly: pos.it/chat-with-us Posit Team demo resources: pos.it/demo-resources 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. We will use this thread on the Posit Community Forum for follow-up Q&A from this month's session: https://community.rstudio.com/t/event-on-12-27-collaborative-workflows-w-posit-team-version-control-git-backed-deployment-project-sharing/179181 (shortlink: pos.it/workflow-dec-23) Happy holidays! Cheers to 2024!

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

Building a Flexible, Scaleable Self-Serve Reporting System with Shiny - posit::conf(2023)

Presented by Natalie O'Shea Working in the high-touch world of consulting, our team needed to develop a reporting system that was flexible enough to be tailored to the specific needs of any given partner while still reducing the highly manual nature of populating client-ready slide decks with various metrics and data visualizations. Utilizing the extensive resources developed by the R user community, I was able to create a flexible, scalable reporting system that allows users to populate templated Google slide decks with metrics and professional-grade visualizations using data pulled directly from our database at the time of query. This streamlined approach enables our consultants to spend less time copy-pasting data from one channel to another and instead focus on what they do best: surfacing business-relevant insights and recommendations for our partners. By sharing my approach to customizable self-serve reporting in Shiny, I hope attendees will walk away with new ideas about how to combine parameterized reporting and dashboard development to get the best of both worlds. Additionally, I hope to end by sharing how this project was pivotal in making the business case for procuring Posit products for my broader organization. Presented at Posit Conference, between Sept 19-20 2023, Learn more at posit.co/conference. -------------------------- Talk Track: Bridging the gap between data scientists and decision makers. Session Code: TALK-1075

Coding Tools for Industry R&D – Development Lessons from an Analytical Lab - posit::conf(2023)

Presented by Camila Saez Cabezas Are you considering or curious about developing code-based tools for scientists? Whether you are an experienced developer or a fellow Posit Academy graduate who might be stepping into this role for the first time, the aim of my story is to inspire you and help you navigate this process. While developing custom R functions, packages, and Shiny apps for diverse analytical capabilities and users in R&D, I learned why it's important to collect certain information at the start before writing any tidying, analysis, visualization, and web application code. In this talk, I will share the essential technical questions that help me define and plan for success. Presented at Posit Conference, between Sept 19-20 2023, Learn more at posit.co/conference. -------------------------- Talk Track: Lightning talks. Session Code: TALK-1168

Combining R and Python for the Belgian Justice Department - posit::conf(2023)

Presented by Thomas Michem We build a great case on how to combine R and Python in a production environment. So the justice department's back office monitors the smooth processing of all traffic fines in Belgium. They gather that data from all police departments and check if any anomalies occur. The back-office monitors that using a shiny application where they can see traffic signs showing the status of the whole operation and the status is built using Python scripts that perform anomaly detection if the number of fines is in line with what they expect daily. And the results of those checks are delivered to a front-end shiny application with Python flask API. Presented at Posit Conference, between Sept 19-20 2023, Learn more at posit.co/conference. -------------------------- Talk Track: R or Python? Why not both!. Session Code: TALK-1122

Developing a Prototyping Competency in a Statistical Science Organization - posit::conf(2023)

Presented by Daniel Woodie The introduction of new tools, methods, and processes can be a struggle within a statistical science organization. Being deliberate and investing in the creation of a prototyping competency can help in accelerating progress. Prototyping allows organizations to quickly experiment with new ideas, reduce the risk of failure, identify potential issues early, and iterate until the desired outcome is achieved. I will highlight the key areas we have focused on accelerating, our framework for developing this competency, how we use Shiny, and the lessons we've learned along the way. Developing a prototyping competency is crucial for statistical science organizations that wish to stay competitive and innovative in today's rapidly changing landscape. Presented at Posit Conference, between Sept 19-20 2023, Learn more at posit.co/conference. -------------------------- Talk Track: Building effective data science teams. Session Code: TALK-1059

Diversify Your Career with Shiny for Python - posit::conf(2023)

Presented by Gordon Shotwell A few years ago my company made a sudden shift from R to Python which was quite bad for my career because I didn't really know Python. The main issue was that I couldn't find a niche that allowed me to use my existing knowledge while learning the new language. Shiny for Python is a great niche for R users because none of the Python web frameworks can do what Shiny can do. Additionally, almost all of your knowledge of the R package is applicable to the Python one. This talk will provide an overview of the Python web application landscape and articulate what Shiny adds to this landscape, and then go through the five things that R users need to know before developing their first Shiny for Python application. Presented at Posit Conference, between Sept 19-20 2023, Learn more at posit.co/conference. -------------------------- Talk Track: Data science with Python. Session Code: TALK-1138

epoxy: Super Glue for Data-driven Reports and Shiny Apps - posit::conf(2023)

Presented by Garrick Aden-Buie R Markdown, Quarto, and Shiny are powerful frameworks that allow authors to create data-driven reports and apps. But truly excellent reports require a lot of work in the final steps to get numerical and stylistic formatting just right. {epoxy} is a new package that uses {glue} to give authors templating superpowers. Epoxy works in R Markdown and Quarto, in markdown, LaTeX, and HTML outputs. It also provides easy templating for Shiny apps for dynamic data-driven reporting. Beyond epoxy's features, this talk will also touch on tips and approaches for data-driven reporting that will be useful to a wide audience, from R Markdown experts to the Quarto and Shiny curious. Presented at Posit Conference, between Sept 19-20 2023, Learn more at posit.co/conference. -------------------------- Talk Track: Elevating your reports. Session Code: TALK-1155

Garrick Aden-Buie

FOCAL Point: Utilizing Python, R, and Shiny to Capture, Process, and Visualize Motion - posit::conf

Presented by Justin Markel & Alyssa Burritt One of the fastest movements in modern sports is a golf swing. Capturing this motion using a high-speed camera system creates many unique challenges in processing, analyzing, and visualizing the thousands of data points that are generated. These spatial coordinates can be quickly translated through Python scripts to well-known, industry-specific performance metrics and graphics in Shiny. Down the line, R utilities aid more complicated analyses and optimizations, driving new product innovations. This talk will cover our company's process of implementing these tools into our workflow and highlight key program features that have helped successfully combine these applications for users with a variety of technical backgrounds. Presented at Posit Conference, between Sept 19-20 2023, Learn more at posit.co/conference. -------------------------- Talk Track: R or Python? Why not both!. Session Code: TALK-1120

From Concept to Impact: Building and Launching Shiny Apps in the Workplace - posit::conf(2023)

Presented by Tiger Tang Learn to build and launch a Shiny app like you are working on a start-up! Unlock the potential of Shiny apps for your organization! Join Tiger as he shares insights from implementing Shiny apps at his workplace, handling over 160,000 internal requests. Discover a practical mindmap to find, build, and enhance Shiny app use cases, ensuring robustness and improved user engagement. Materials: https://tigertang.org/posit_conf_2023/ Presented at Posit Conference, between Sept 19-20 2023, Learn more at posit.co/conference. -------------------------- Talk Track: Bridging the gap between data scientists and decision makers. Session Code: TALK-1074

How to Help Developers Make Apps Users Love - posit::conf(2023)

Presented by Michał Parkoła There are many resources that can help you design better apps. But what if your org creates many apps? Scaling good design to larger groups dials the challenge up to 11. In this talk, I will share how we approach the problem at Appsilon. - I will present our in-house Design Guide. - I will share the successes and failures we've had building it and helping a wide variety of developers use it - I will then share some tips about what you might want to consider if you want to help your org build better apps at scale. Presented at Posit Conference, between Sept 19-20 2023, Learn more at posit.co/conference. -------------------------- Talk Track: Shiny user interfaces. Session Code: TALK-1127

How You Get Value as a 1-Person Posit Connect Team - posit::conf(2023)

Presented by Sean Nguyen Sean, a sole Posit Connect developer, shares his experience in delivering business impact. He narrates his transition from crafting one-off reports to developing and deploying robust data science web applications using Python and R with Posit Connect. Despite its common association with large enterprise teams, Sean demonstrates how Posit Connect can be effectively utilized in smaller settings. He presents his work on creating and deploying end-to-end machine learning pipelines in Python, hosting them as APIs, and seamlessly integrating with Shiny apps via Posit Connect. This talk imparts practical strategies and techniques to foster user and executive adoption of Posit Connect within lean (and large) organizations. Presented at Posit Conference, between Sept 19-20 2023, Learn more at posit.co/conference. -------------------------- Talk Track: Getting %$!@ done: productive workflows for data science. Session Code: TALK-1093

HTML and CSS for R Users - posit::conf(2023)

Presented by Albert Rapp You can get the most out of popular R tools by combining them with easy-to-learn HTML & CSS commands. It's easy to think that R users do not need HTML and CSS. After all, R is a language designed for data analysis, right? But the reality is that these web standards are everywhere, even in R. In fact, many great tools like {ggtext}, {gt}, {shiny}, and Quarto unlock their full potential when you know a little bit of HTML & CSS. In this talk, I will demonstrate specific examples where R users can benefit from HTML and CSS and show you how to get started with these two languages. Materials: - Here's the link to the video that I mention in the talk: https://youtu.be/QU8wSya-Y9E?si=zw59OSFPl1eJSY7M - Part 1 of this two part series can be found at https://www.youtube.com/watch?v=jX4_Dnzhl0M Presented at Posit Conference, between Sept 19-20 2023, Learn more at posit.co/conference. -------------------------- Talk Track: Compelling design for apps and reports. Session Code: TALK-1105

Making a (Python) Web App is easy! - posit::conf(2023)

Presented by Marcos Huerta Making Python Web apps using Dash, Streamlit, and Shiny for Python This talk describes how to make distribution-free prediction intervals for regression models via the tidymodels framework. By creating and deploying an interactive web application you can better share your data, code, and ideas easily with a broad audience. I plan to talk about several Python web application frameworks, and how you can use them to turn a class, function, or data set visualization into an interactive web page to share with the world. I plan to discuss building simple web applications with Plotly Dash, Streamlit, and Shiny for Python. Materials: - Comprehensive talk notes here: https://marcoshuerta.com/posts/positconf2023/ - https://www.tidymodels.org/learn/models/conformal-regression/ - https://probably.tidymodels.org/reference/index.html#regression-predictions Corrections: In my live remarks, I said a Dash callback can have only one output: that is not correct, a Dash callback can update multiple outputs. I was trying to say that a Dash output can only be updated by one callback, but even that is no longer true as of Dash 2.9. https://dash.plotly.com/duplicate-callback-outputs"" Presented at Posit Conference, between Sept 19-20 2023, Learn more at posit.co/conference. -------------------------- Talk Track: The future is Shiny. Session Code: TALK-1086

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

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

Scale Your Data Validation Workflow With {pointblank} and Posit Connect - posit::conf(2023)

Presented by Michael Garcia For the Data Services team at Medable, our number one priority is to ensure the data we collect and deliver to our clients is of the highest quality. The {pointblank} package, along with Posit Connect, modernizes how we tackle data validation within Data Services. In this talk, I will briefly summarize how we develop test code with {pointblank}, share with {pins}, execute with {rmarkdown}, and report findings with {blastula}. Finally, I will show how we aggregate data from test results across projects into a holistic view using {shiny}. Presented at Posit Conference, between Sept 19-20 2023, Learn more at posit.co/conference. -------------------------- Talk Track: Leave it to the robots: automating your work. Session Code: TALK-1058

Shiny Developer Secrets: Insights From Over 1200 Applicants and What You MUST Know to Shine

Presented by Vedha Viyash Over 1,200 candidates applied for the R/Shiny developer role at Appsilon in the last year, and I will be sharing some insights that we have gained from going through the qualitative and quantitative feedback collected from every round of the interview process. I will be sharing some key takeaways that would help you focus on things that will make you a better Shiny developer. From reactivity to software testing, there are multiple skills that make up a good Shiny developer and you will get to know the major gaps and how to focus on them. Presented at Posit Conference, between Sept 19-20 2023, Learn more at posit.co/conference. -------------------------- Talk Track: Lightning talks. Session Code: TALK-1173

Shiny for Python Machine Learning Apps with pandas, scikit-learn and TensorFlow - posit::conf(2023)

Presented by Chelsea Parlett-Pelleriti With the introduction of Shiny for Python in 2022, users can now use the power of reactivity with their favorite Python packages. Shiny can be used to build interactive reports, dashboards, and web apps, that make sharing insights and results both simple and dynamic. This includes apps to display and explore popular Machine Learning models built with staple Python packages like pandas, scikit-learn, and TensorFlow. This talk will demonstrate how to build simple Shiny for Python apps that interface with these packages, and discuss some of the benefits of using Shiny for Python to build your web apps. Presented at Posit Conference, between Sept 19-20 2023, Learn more at posit.co/conference. -------------------------- Talk Track: The future is Shiny. Session Code: TALK-1087

Shiny New Tools for Scaling your Shiny Apps - posit::conf(2023)

Presented by Joe Kirincic So you have a Shiny app your org loves, but as adoption grows, performance starts getting sluggish. Profiling reveals your cool interactive plots are the culprit. What can you do to make things snappy again? We can increase the number of app instances, sure, but suppose that isn't an option for us. Another approach is to shift the plotting work from the server onto the client. In this talk, we'll learn how to leverage two Javascript projects, DuckDB-WASM and Observable's Plot.js, in our Shiny app to create fast, flexible interactive visualizations in the browser without burdening our app's server function. The end result is an app that can scale to more users without needing to increase compute resources. Presented at Posit Conference, between Sept 19-20 2023, Learn more at posit.co/conference. -------------------------- Talk Track: The future is Shiny. Session Code: TALK-1088

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

Speeding Up Plots in R/Shiny - posit::conf(2023)

Presented by Ryszard Szymański A slow plots can ruin the user experience of our dashboard. This talk covers techniques for speeding up the rendering process of our visualisations. Slow dashboards lead to a poor user experience and cause users to lose interest, or even become frustrated. A common culprit of this situation is a slowly rendering plot. During the talk, we will dive deeper into how plots are rendered in Shiny, identify common bottlenecks that can occur during the rendering process, and learn various techniques for improving the speed of plots in R/Shiny dashboards. These techniques will range from more efficient data processing to library-specific optimisations at the browser level. Materials: I'd like to include a link to my linkedin profile: https://www.linkedin.com/in/ryszard-szyma%C5%84ski-310a7017a/ Presented at Posit Conference, between Sept 19-20 2023, Learn more at posit.co/conference. -------------------------- Talk Track: Lightning talks. Session Code: TALK-1172

The Power of Prototyping in R Shiny: Saving Millions by Building the Right Tool - posit::conf(2023)

Presented by Maria Grycuk The development of software can be costly and time-consuming. If the end users are not involved in the process from the start the tool we built may not meet their needs. In this presentation, I will discuss how prototyping in Shiny can help you build the right tool and save you from spending millions of dollars on a tool no one will use. I will explore the advantages of using Shiny for prototyping, particularly its ability to rapidly build interactive applications. I will also discuss how to design effective prototypes, including techniques for gathering user feedback and using that feedback to refine your tool. I will emphasize the importance of presenting real-life data, particularly when building data-driven tools. Presented at Posit Conference, between Sept 19-20 2023, Learn more at posit.co/conference. -------------------------- Talk Track: Shiny user interfaces. Session Code: TALK-1125

The Road to Easier Shiny App Deployments - posit::conf(2023)

Presented by Liam Kalita We're often helping developers to assess, fix and improve their Shiny apps, and often the first thing we do is see if we can deploy the app. If you can't deploy your Shiny app, it's a waste of time. If you can deploy it successfully, then at the very least it runs, so we've got something to work with. There are a bunch of reasons why apps fail to deploy. They can be easy to fix, like Hardcoded secrets, fonts, or missing libraries. Or they can be intractable and super frustrating to deal with, like manifest mismatches, resource starvation, and missing libraries. At the end of this talk, I want you to know how to identify, investigate and proactively prevent Shiny app deployment failures from happening. Presented at Posit Conference, between Sept 19-20 2023, Learn more at posit.co/conference. -------------------------- Talk Track: The future is Shiny. Session Code: TALK-1089

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

Using R to develop production modeling workflows at Mayo Clinic - posit::conf(2023)

Presented by Brendan Broderick Developing workflows that help train models and also help deploy them can be a difficult task. In this talk I will share some tools and workflow tips that I use to build production model pipelines using R. I will use a project of predicting patients who need specialized respiratory care after leaving the ICU as an example. I will show how to use the targets package to create a reproducible and easy to manage modeling and prediction pipeline, how to use the renv package to ensure a consistent environment for development and deployment, and how to use plumber, vetiver, and shiny applications to make the model accessible to care providers. Presented at Posit Conference, between Sept 19-20 2023, Learn more at posit.co/conference. -------------------------- Talk Track: Leave it to the robots: automating your work. Session Code: TALK-1149

Using R, Python, and Cloud Infrastructure to Battle Aquatic Invasive Species - posit::conf(2023)

Presented by Uli Muellner and Nicholas Snellgrove Invasive species are a huge threat to lake ecosystems in Minnesota. With over 10,000 water bodies across the state, having up-to-date data and decision support is critical. Researchers at the University of Minnesota have created four complex R and Python models to support lake managers, all pulled together and presented with the most recent infestation data available. Come along with us to see how we connected these models in the AIS Explorer, a decision support application built in Shiny to help prioritize risks and placing watercraft inspectors, using tools like OCPU and cloud toolings like Lambda, EventBridge and AWS S3. Presented at Posit Conference, between Sept 19-20 2023, Learn more at posit.co/conference. -------------------------- Talk Track: R or Python? Why not both!. Session Code: TALK-1118

Why You Should Add Logging To Your Code (and make it more helpful) - posit::conf(2023)

Presented by Daren Eiri Learn how the log4r package can help you better understand the errors your code may produce, and how to also get promptly alerted for severe errors by leveraging cloud monitoring solutions like Azure Monitor or AWS CloudWatch When an error happens in your API, Shiny App, or quarto document, it is not always clear what line of code you need to look at, and the error messages aren’t always helpful. By walking through a simple API example, I show how you can use logging packages like log4r to provide error messages that make sense to you. I also show how you can use cloud-based data collection platforms like Azure Monitor or AWS CloudWatch to set up alerts, so you can get notified by email or text message for those severe errors that you need to be immediately aware of. Gain more visibility into the health of your code by incorporating logging and pushing your logs to the cloud. Materials: https://dareneiri.github.io/positconf2023/ Presented at Posit Conference, between Sept 19-20 2023, Learn more at posit.co/conference. -------------------------- Talk Track: Lightning talks. Session Code: TALK-1164

Shiny in Production 2023: George Stagg - R Shiny without a server: webR and Shinylive

R Shiny without a server: webR and Shinylive by George Stagg at the Shiny in Production 2023 conference, hosted by Jumping Rivers! Note from the speaker: Shinylive is now available on CRAN! https://cran.r-project.org/web/packages/shinylive/index.html Abstract -------------- WebAssembly (Wasm) is a technology that enables software that’s normally compiled for a specific computer system to instead run anywhere, including inside web browsers. WebR is a version of the R interpreter compiled for Wasm, bringing this technology to the R world. Earlier this year, the initial version of webR was released and users have already begun building new interactive experiences with R on the web. The latest release, version 0.2.0, includes improvements to graphics, accessibility and internationalisation, developer API updates, and introduces a new webR REPL app. The release also includes expanded support for Wasm R packages, including the ability to run fully client‐side Shiny apps. In this talk, I’ll introduce webR with some simple examples and discuss some details of how the system works. I’ll talk about how JavaScript APIs can be used to integrate webR into wider web applications and describe webR’s communication channel. Finally, I’ll give a description of how Shiny apps can be run using webR without an R server, ending with a demo of an in‐development “Shinylive for R”. This event was sponsored by: - Jumping Rivers - National Innovation Centre for Data - NU Solve - Posit - R Consortium - Royal Statistical Society

George Stagg

Eric Nantz, Alex Lauer, Rich Iannone - A Pivotal Year of Milestones in R Consortium Working Groups

A Pivotal Year of Milestones: R Submissions Working Group and R Tables for Regulatory Submissions updates - Eric Nantz, Alexandra Lauer, and Rich Iannone Resources mentioned in the presentation: - R Submissions Working Group: https://rconsortium.github.io/submissions-wg/ - R Tables eBook: https://rconsortium.github.io/rtrs-wg Abstract: Within the life sciences industry, Shiny has enabled tremendous innovations to produce web interfaces as frontends to sophisticated analyses, dynamic visualizations, and automation of clinical reporting across drug development. While industry sponsors have widely adopted Shiny as part of their analytics and reporting toolset, a relatively unexplored frontier has been the inclusion of a Shiny application inside a clinical submission package to regulatory agencies such as the FDA. The R Consortium R Submissions Working Group has continued the positive momentum of previous submission pilots to achieve substantial progress in this domain. In this talk, we will share the development journey of the working group’s Pilot 2 successful submission of a Shiny application to the FDA, along with the progress on the use of novel technologies such as Linux containers and web assembly to bundle a Shiny application into a self-contained package, facilitating a smoother process of both transferring and executing the application. The R Consortium’s R Tables for Regulatory Submissions (RTRS) Working Group has released the first edition of (Tables in Clinical Trials with R)[ https//rconsortium.github.io/rtrs-wg/] as a free and openly accessible ebook. The book contributes to the development of a theory of displaying tabular information by identifying a small number of table archetypes that may be used to generate the most common tables employed in clinical submissions. Chapters in the book demonstrate how these tables may be rendered in different R Packages including flextable, gt, rtables (with and without tern), tables, tfrmt and tidytlg. All tables are generated from CDISC-compliant data. Comparing the code showcases the robustness of R for aggregating and displaying tabular information and illuminates the flexibility and design tradeoff of the various R packages. The talk will discuss the motivation for the book, present the idea of table archetypes, show some representative tables, and make the case for R as a superb language for analyzing clinical trial data. The RTRS working group expects Tables in Clinical Trials with R to become a primary resource of clinical programming teams. Speaker Bios: Eric Nantz is a director within the statistical innovation center at Eli Lilly and Company, creating analytical pipelines and capabilities of advanced statistical methodologies for clinical design used in multiple phases of development. Outside of his day job, Eric is passionate about connecting with and showcasing the brilliant R community in multiple ways. You may recognize his voice from the R-Podcast that he launched in 2012. Eric is also the creator of the Shiny Developer Series where he interviews authors of Shiny-related packages and practitioners developing applications, as well as sharing his own R and Shiny adventures via livestreams on his Twitch channel. In addition, Eric is a curator for the RWeekly project and co-host of the RWeekly Highlights podcast which accompanies every issue. Alexandra Lauer is a Senior Principal Statistical Analyst at Merck KGaA, Darmstadt, Germany, with a background in mathematics. She specializes in bridging psychometrics and biostatistics, with a primary focus on Health-Related Quality of Life evaluations. Alex is an R enthusiast, co-leading the Merck-internal R User Group. Rich Iannone: My background is in programming, data analysis, and data visualization. Much of my current software engineering work on R packages is intended to make working with data easier. I truly believe that with the right approach, tools like these can be both powerful and easy to use. Presented at the 2023 R/Pharma Conference (October 26, 2023)

Rich Iannone

Gordon Shotwell & Tracy Teal - Build Simple and Scalable Apps with Shiny | PyData NYC 2023

www.pydata.org https://gshotwell.github.io/shiny-algorithm This talk explores the intuitive algorithm behind Shiny for Python and shows how it allows you to scale your apps from prototype to product. Shiny infers a reactive computation graph from your application and uses this graph to efficiently re-render components. This eliminates the need for data caching, state management, or callback functions which lets you build scalable applications quickly. 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

How to build a model annotation tool with FastAPI, Quarto & Shiny for Python

Gordon Shotwell, Senior Software Engineer at Posit walks through an end-to-end machine learning workflow with Posit Team. This demo will give you a robust pattern for hosting and sharing models on Connect before you deploy them to a customer-facing system. This includes * How and why to use an API layer to serve and authenticate internal models * Why you should wrap your APIs in Python packages * Using Shiny for Python to build a data annotation app * Using Quarto to retrain models on a schedule Agenda: 11am - Quick introduction 11:02am - Demo 11:40am Q&A Session (https://youtube.com/live/zhN8IZUBCAg?feature=share) Timestamps: 1:27 - Quick overview of text classification model used in this example 2:15 - Overview of the people that will need to use the model (modellers, leadership, data team, annotators, other systems) 4:11 - Why APIs before UIs is a good rule 5:57 - What about Python packages? 8:23 - Advantages to using an API here 9:18 - Big picture overview of the workflow 11:17 - FastAPI on Posit Connect (Swagger interface) 15:55 - The way this model will be used (authorization by validating user) 19:00 - Building a delightful user experience by wrapping API in a package 25:07 - Quarto report for leadership team showing model statistics & deploying to Connect 26:34 - Retraining the model by scheduling Quarto doc on Connect 28:37 - Shiny for Python app for Annotators (people checking if model is producing correct results & helping improve the model) 35:28 - Overview / summary of this machine learning workflow Helpful links: Github: https://github.com/gshotwell/connect-e2e-model Anonymous questions: pos.it/demo-questions If you want to book a call with our team to chat more about Posit products: pos.it/chat-with-us Don't want to meet yet, but curious who else on your team is using Posit? pos.it/connect-us Machine learning workflow with R: https://solutions.posit.co/gallery/bike_predict/ In this month’s Workflows with Posit Team session (Wednesday, November 29th at 11am ET) you will learn how to use Posit Connect as an end-to-end Python platform for hosting internal machine learning models. This will give you a robust pattern for hosting and sharing models on Connect before you deploy them to a customer-facing system. This will include: 1. How and why to use an API layer to serve and authenticate internal models 2. Why you should wrap your APIs in Python packages 3. Using Shiny for Python to build a data annotation app 4. Using Quarto to retrain models on a schedule During the event, we’ll be joined by Gordon Shotwell, Senior Software Engineer at Posit who will walk us through this end-to-end machine learning workflow with Posit Team. No registration is required to attend - simply add it to your calendar using this link: pos.it/team-demo Ps. We host these end-to-end workflow demos on the last Wednesday of every month. If you ever have ideas for topics or questions about them, leave a comment below :)

webR 0.2: R Packages and Shiny for WebAssembly | George Stagg | Posit

WebR makes it possible to run R code in the browser without the need for an R server to execute the code: the R interpreter runs directly on the user’s machine. But just running R isn't enough, you need the R packages you use every day too. webR 0.2.0 makes many new packages available (10,324 packages - about 51% of CRAN!) and it's now possible to run Shiny apps under webR, entirely client side. George Stagg shares how to load packages with webR, know what ones are available, and get started running Shiny apps in the web browser. There’s a demo webR Shiny app too! 00:15 Loading R packages with webR 01:50 Wasm system libraries available for use with webR 05:30 Tidyverse, tidymodels, geospatial data, and database packages available 08:00 Shiny and httpuv: running Shiny apps under webR 11:05 Example Shiny app running in the web browser 12:05 Links with where to learn more Shiny webR demo app: https://shinylive.io/r/examples/ Website: https://docs.r-wasm.org/ webR REPL example: https://webr.r-wasm.org/latest/ Demo webR Shiny app in this video: https://shiny-standalone-webr-demo.netlify.app/ Source: https://github.com/georgestagg/shiny-standalone-webr-demo/ See the overview of what's new in webR 0.2.0: https://youtu.be/Mpq9a6yMl_w

George Stagg

Shiny is available for Python and is super easy to customize the look and feel of your app😍

Learn more about Shiny for Python: https://shiny.posit.co/py/

How does Shiny render things? | Gordon Shotwell

Discussion on the Shiny Python Discord channel from Gordon Shotwell. Gordon talks about how Shiny renders things with reactive programming, how other frameworks work, and how Shiny scales for complex applications. 0:00 - How Shiny renders things - reactivity 2:31 - How do other frameworks work 3:51 - Event driven programming, what's a better way? 6:53 - Runtime tracing 8:25 - Declarative programming 9:20 - Drawing a graph 12:05 - How reactivity scales 13:30 - Reactive calculus 18:45 - Question and answer Shiny for Python: https://shiny.posit.co/py/ Shiny for Python Discord server: https://discord.com/invite/yMGCamUMnS

"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

July 2023 Webinar: Shiny in Production

Shiny in Production Wednesday 19th July 2023 With Ryan Johnson, Data Science Advisor at Posit About the webinar: In this session, we’ll discuss how to create production-ready Shiny apps in R that can scale to thousands of concurrent users

Hadley Wickham @ Posit | Giving benefit to people using what you build | Data Science Hangout

We were recently joined by Hadley Wickham, Chief Scientist at Posit PBC. Listen in to hear our chat about building tools (like the tidyverse) to make data science easier, faster, and more fun. 36:57 - While I'm bought into developing open source packages to help deliver better processes, any advice to those of us doing that development in getting their company bought in? You have to give some benefit to the people using (what you’re building) You’ve got to either remove pain or add pleasure in some way because if you can't do that and you're not someone's direct supervisor, it's hard to get people to change. The way I think about the tidyverse is, how do we give people some sort of quick wins so they can be motivated to do the things that are slower where they're gonna have to learn some new ideas or some new tools. You kind of build up some equity with that person. They build trust that you've helped them in the past and now they're willing to invest a little bit more time before they see the payoff. But in the early days, it's all about delivering payoffs as quickly as possible. And I think if you're doing, like, you know “my company's first R package” - the easy pain points are: make themes for your company corporate style guide, make a ggplot2 theme, make an R Markdown, a Quarto theme. Make a Shiny theme that people can just use to get, you know, something that's reasonably close to whatever your corporate style guide dictates. That just feels like an easy win for people because it makes them look good inside the corporation and because you've put in all the hard work, it's like three seconds for them to type the right function name to get the right theme. I think the other bit is making it easier to get access to data. Set up some wrappers around DBI connections to the most important data sources. Provide some conventions around authentication so that stuff just works so that they're not struggling with “What packages do I need to install? What's the password? Where's the path I need?” Just give them some, like, a list of the top ten most common data sources and people will love you by and large. *Follow-up question:* Once you identify the things that you think would be useful for people - do you have a philosophy or a way in which you approach putting things together? When you're in an environment of scarcity when you've only got so much time that you can take out of your everyday job to invest in writing a package, it's really tough to balance. Like, how do I add new stuff versus making sure the old stuff continues to work? I think, again, some of it's about building up trust. So, give people some wins so that when you inevitably break stuff, you've got some kind of cushion so people aren't going to be really angry with you right away. They're gonna be like, ok, well there’s a little bit of suffering now, but this person saved me so much time. But yeah, it's really hard. And particularly as you're starting out, like, you're going to make mistakes. That's inevitable. You’re going to do things that when you look back a year later, you're like, why on earth did I do it that way? You’ll want to rip out the whole thing and ride it from scratch. And I think that if it feels horrible, you have to remember, that's great. It means you've grown immensely as a programmer. Certainly if you have my kind of mindset, you have to resist the temptation to rip things out and redo them as much as possible and just focus on making the next generation better rather than breaking what stuff people already have. So I don't have any great answers here, but I think you just have to think about those tensions of “how do I keep my forward velocity up while getting better as a programmer and evolving over time, but also thinking about how do you make the things you did a long time ago better?” ______ ► 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!