RStudio

Seriously, have you tried this AI stuff? I've never written code like this in my life.

Unearned confidence #datascience #datasciencetok #python #swe #datavisualization #dataanalytics #codinglife #vscode #ide #rstudio #positron #pycharm #jupyter #cursor #windsurf

AI-Powered Data Engineering Workflows: Positron for Databricks Users

Modern data engineering demands more. Move beyond the limitations of hosted notebooks and embrace the power of an IDE for modern data engineering. We’ll show you how Positron combines the best of local development with the scale of Databricks. In this session led by James Blair at Posit, we’ll cover: 1. AI-Driven Development: Moving from concept to code faster with built-in AI. 2. Seamless Exploration: Navigating data effortlessly with the Catalog Explorer. 3. Production-Grade Pipelines: Building, testing, and deploying robust workflows. Helpful Links: Download Positron: https://positron.posit.co/ Databricks Asset Bundles: http://docs.databricks.com/dev-tools/bundles GitHub Repo for Demo: https://github.com/blairj09/databricks-data-engineering Lakeflow Declarative Pipelines: http://docs.databricks.com/aws/en/ldp Talk to us about integrating Posit & Databricks: https://posit.co/schedule-a-call/

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

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

Take Positron to Work with Positron Pro

While you've downloaded Positron on your desktop and are loving it, you may still have a few questions about using it at work: 1. What happens when my analysis requires more memory than my laptop has? 2. How can I bring Positron into my company's secure environment? 3. How can I access data in Databricks or Snowflake from Positron? Nick Rohrbaugh, Senior Product Marketing Manager at Posit shares how Positron Pro, available exclusively within Posit Workbench, transforms from a powerful desktop editor into a fully governed, enterprise-ready IDE. In this webinar, you will learn how: 1. Data teams get immediate access to scalable, server-side compute and secure, one-click data authorization. 2. IT leaders can centralize, secure, and manage Positron alongside RStudio, Jupyter, and VS Code, all from a single platform. Helpful links: Positron: https://posit.co/products/ide/positron/ Posit Workbench: https://posit.co/products/enterprise/workbench/

AI-Powered Data Science in Positron

We're so excited to introduce Positron, a free, next-generation data science IDE that makes it easy to work in both R and Python. Positron builds on our years of experience developing RStudio and is a fork of VS Code, designed specifically for data work. This means you get a modern coding interface with features tailored for data science, like a built-in data explorer, AI assistance, interpreter management, and more. This is our 2nd event in our Positron series and focused on AI-Powered Data Science. Here at Posit, we strive to create products where AI works with you, not against you. In efforts to continue this mission, we are excited to introduce agentic AI capabilities in Positron, our new, free code editor for R and Python, that are designed from the ground up to follow these principles. Positron’s AI capabilities automate the tedious parts of the data science workflow, but always keep you, the expert, in control. 00:00 Introduction 00:32 What is Positron? (The Next-Gen Data Science IDE) 03:43 Introducing Positron Assistant 05:10 Bring your own LLM 05:47 Your environment as context 07:19 Inline code suggestions 07:58 Introducing Databot 08:22 The WEAR loop 10:15 Demo time 10:56 Opening Positron Pro in Posit Team 14:29 Opening a new folder in Positron 15:22 Cloning a repo from GitHub 17:24 Positron icons 19:15 Positron search bar and command palette 20:18 Changing interpreters and opening a Quarto document 21:30 Running code and populating the Variables Pane 22:41 Using the Data Explorer 25:28 Creating a plot and debugging with Positron Assistant 30:46 Editing code using inline code suggestions 34:42 Sharing a Quarto document 36:12 Opening Databot 37:02 Exploring data with Databot 43:37 Creating a report using Databot findings 45:12 Wrap up Additional resources: GitHub Repo for this Example: https://github.com/posit-dev/positron-ai-workshop Getting Started with Positron: Quick Tour: https://posit.co/resources/videos/get-started-with-positron-a-quick-tour-and-community-qa/ Introducing Databot (Blog Post): https://posit.co/blog/introducing-databot/ Posit AI Newsletter: https://posit.co/blog/2025-09-26-ai-newsletter/ Positron Assistant: https://positron.posit.co/assistant.html

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

Top AI Powered Coding Assistants

which have you tried? #datascience #datasciencetok #python #swe #datavisualization #dataanalytics #codinglife #vscode #ide #rstudio #positron #pycharm #jupyter #cursor #windsurf

What can you do with Positron Assistant?

Positron Assistant is an AI client integrated within Positron, designed to enhance data science workflows. Positron Assistant brings LLM integration for both chat and inline code completions.This tool is built to assist with a range of tasks, including generating and refactoring code, answering questions, providing debugging support, and offering insightful suggestions for next steps in your projects. It can interact with the Variables pane, Plots pane, and the Console in your IDE. Capabilities include: • Editor inline chat (chat with Positron Assistant in your script to augment your code) • Contextual code completion (add instructional comments to your scripts to complete code) • Agent-assisted workflows (allow Positron Assistant to execute tasks autonomously) Learn more about Positron Assistant: https://positron.posit.co/assistant.html Sign up for our Workflow Demo on October 29, where we will demonstrate Positron Assistant: https://posit.co/workflow-demo/ai-powered-data-science-in-positron/

Deploy a Streamlit web app with me

deploy all the things! #datascience #datasciencetok #python #swe #datavisualization #dataanalytics #codinglife #vscode #ide #rstudio #positron #pycharm #jupyternotebook

10 tips for data science beginners

Do you have any to add? #datascience #datasciencetok #python #swe #datavisualization #dataanalytics #codinglife #vscode #ide #rstudio #positron #pycharm #jupyternotebook

Let's try Positron Assistant for the first time together

lil ai buddy #datascience #datasciencetok #python #swe #datavisualization #dataanalytics #codinglife #vscode #ide #rstudio #positron #pycharm #jupyter

Data Exploration 101

Don't skimp #datascience #datasciencetok #python #swe #datavisualization #dataanalytics #codinglife #vscode #ide #rstudio #positron #pycharm #jupyternotebook

Positron 101: Make your DS life easier

Personally, I think the Plots pane is #datascience #datasciencetok #python #swe #datavisualization #dataanalytics #codinglife #vscode #ide #rstudio #positron #pycharm #jupyter

Set up your first coding project in less than 10 minutes

What are you waiting for #datascience #datasciencetok #python #swe #datavisualization #dataanalytics #codinglife #vscode #ide #rstudio #positron #pycharm #jupyter

Get starting with data - load data into your IDE

Finding the data is the hardest part, prove me wrong #datascience #datasciencetok #python #swe #datavisualization #dataanalytics #codinglife #vscode #ide #rstudio #positron #pycharm #jupyternotebook

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/

What is an IDE & which one should you use as a beginner

Did you have a first? #datascience #datasciencetok #python #swe #datavisualization #dataanalytics #codinglife #vscode #ide #rstudio #positron #pycharm #jupyter

Next-gen data science: a conversation with the Ravit Show and Eric Pité

Eric Pité, SVP of Product & Strategy, sat down with the Ravit Show at Databricks Data + AI Summit to have a conversation about the evolution of open source data science, the Posit and Databricks integration, and the place of AI in modern data science. Some highlights from the conversation are below: -- The evolution from RStudio to Posit It’s more than just a name change — it’s a signal of how seriously they’re embracing Python while staying true to their R roots and open-source mission. -- Open source meets enterprise Eric shared how Posit is navigating the balance between community contribution and commercial sustainability — and why that mission still matters in an AI-first world. -- Positron + Databricks Their strategic partnership is one to watch. Positron is making it easier to do high-quality data science (in R and Python) inside the Databricks ecosystem, with an emphasis on collaboration, reproducibility, and performance. -- AI’s place in modern data science Eric and Ravit chatted about how Posit sees the role of AI in helping data teams be more productive, without losing rigor or transparency. -- The power of storytelling with code One of our favorite parts is the emphasis on communication. Building models is not enough—data scientists need to share insights clearly, and Posit is building for that. Learn more about the Databricks and Posit partnership by exploring the partnership page and resources: https://posit.co/use-cases/databricks/

Monthly Workflow Demos now on Zoom Sessions | Recordings still shared below

Please note while we previously hosted the Posit Workflow Demos here on YouTube, we have moved over to Zoom Sessions for a seamless event experience and more interactive Q&A. You can view upcoming workflow demos and register to join us here: https://events.zoom.us/ev/Ajss5j9VeRMe0zw-AtFKf7AUAsthzYhaYjYPeEIu1uYAQe1K0ud1~Agb_hSt1UGxd9fUyIDC32e6jAdEtbl7G_AaLZUYhRvyZR5cGpY5Kp_A0-w

Welcome to PydyTuesday! | How to Level Up your Python Skills

In this video, you'll learn where to find the PydyTuesday github landing page, where data lives on the tidytuesday repo, and how to get started to try stuff out and build new things! We hope you join us in participating in PydyTuesday! Don't forget to use the hashtags #TidyTuesday and #PydyTuesday wherever you like to hangout online - Bluesky, Mastodon, LinkedIn, etc. - have fun out there! We can't wait to see the predictive models, visualizations, dashboards, and data apps that you create Resources and Repos to star: TidyTuesday GitHub Repo: https://github.com/rfordatascience/ti... Posit PydyTuesday GitHub Repo: https://github.com/posit-dev/python-t... TidyTuesday hashtag search on Bluesky: https://bsky.app/search?q=tidytuesday Other videos in this PydyTuesday playlist: • PydyTuesday | Python How-to Videos #pythoncontent

Let's set up your Python environment with only 2 steps | PydyTuesday Python Projects

In this video, let's get your project set up. Learn how to install Positron, create a new Python project, and set up a virtual environment. We hope you join us in participating in PydyTuesday! Don't forget to use the hashtags #TidyTuesday and #PydyTuesday wherever you like to hangout online - Bluesky, Mastodon, LinkedIn, etc. - have fun out there! We can't wait to see the predictive models, visualizations, dashboards, and data apps that you create Resources and Repos to star: TidyTuesday GitHub Repo: https://github.com/rfordatascience/ti... Posit PydyTuesday GitHub Repo: https://github.com/posit-dev/python-t... TidyTuesday hashtag search on Bluesky: https://bsky.app/search?q=tidytuesday Other videos in this PydyTuesday playlist: • PydyTuesday | Python How-to Videos #pythoncontent

Let's install your first Python library in 2 minutes

Here is how to get set up to install your Python library in Positron. Learn how to use the terminal to install your first Python library, in this case pydytuesday. Also, learn the basics for managing packages using "pip." We hope you join us in participating in PydyTuesday! Don't forget to use the hashtags #TidyTuesday and #PydyTuesday wherever you like to hangout online - Bluesky, Mastodon, LinkedIn, etc. - have fun out there! We can't wait to see the predictive models, visualizations, dashboards, and data apps that you create Resources and Repos to star: TidyTuesday GitHub Repo: https://github.com/rfordatascience/ti... Posit PydyTuesday GitHub Repo: https://github.com/posit-dev/python-t... TidyTuesday hashtag search on Bluesky: https://bsky.app/search?q=tidytuesday Other videos in this PydyTuesday playlist: • PydyTuesday | Python How-to Videos #pythoncontent

Let's Import Free, High-Quality Datasets into your Python IDE (using Positron and PydyTuesday)

Let's download data. Learn how to install a dataset using the pydytuesday package and do some basic visualization of the data using Positron's data viewers. We hope you join us in participating in PydyTuesday! Don't forget to use the hashtags #TidyTuesday and #PydyTuesday wherever you like to hangout online - Bluesky, Mastodon, LinkedIn, etc. - have fun out there! We can't wait to see the predictive models, visualizations, dashboards, and data apps that you create Resources and Repos to star: TidyTuesday GitHub Repo: https://github.com/rfordatascience/ti... Posit PydyTuesday GitHub Repo: https://github.com/posit-dev/python-t... TidyTuesday hashtag search on Bluesky: https://bsky.app/search?q=tidytuesday Other videos in this PydyTuesday playlist: • PydyTuesday | Python How-to Videos #pythoncontent

Great Tables 3: Data Color and Polishing

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

Michael Chow

Great Tables 2: Introducing Units Notation

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

Michael Chow

Great Tables 1: Structure, Format, and Style

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

Michael Chow

Johnson & Johnson's Open Source Journey with R in Clinical Trials

Learn how Johnson & Johnson embraces R and open-source tooling in clinical trials. Abstract: Embracing open source has been a transformative journey for J&J, fueled by a commitment to collaboration, transparency, and innovation. Our R journey began with a mindset shift—transitioning from decades-old solutions to actively contributing to and harnessing the power of open-source communities. We navigated the challenges of cultural adaptation while cultivating a programmer-friendly environment that promotes sharing and continuous learning. We enhanced our technical capabilities by open-sourcing key projects focused on R and strengthened our ecosystem and industry partnerships. This webinar reflects on our experiences, lessons learned, and the strategic impact of embracing R. Speakers: Sumesh Kalappurakal, Tadeusz Lewandowski, Nicholas Masel, and Mark Bynens. Learn more about Posit's work in Pharma: https://posit.co/use-cases/pharma/

Build a Python table in under 1 minute using Great Tables

Create wonderful-looking tables directly from Pandas or Polars DataFrames with the Great Tables package. Typically, Great Tables is used in a notebook environment or within a Quarto document and rendered in HTML or as an image file. Ready to build some awesome tables? Install from PyPI with: $ pip install great_tables. GitHub Repo: https://github.com/posit-dev/great-tables Design Philosophy of Great Tables: https://posit-dev.github.io/great-tables/blog/design-philosophy/

TidyTuesday + Posit | PydyTuesday | Weekly Community Python Data Project

Posit software engineer Isabel Zimmerman discusses the TidyTuesday project and the Posit PydyTuesday Initiative. Learn how to participate in weekly TidyTuesday projects, watch Isabel explore Central Park squirrel data, and discover how to deploy your work to Posit Connect Cloud. Find her code here: https://github.com/isabelizimm/pydy-tuesday Check out these repositories to join the TidyTuesday and the Posit PydyTuesday Initiative: TidyTuesday repo with datasets: https://github.com/rfordatascience/tidytuesday Posit PydyTuesday repo: https://github.com/posit-dev/python-tidytuesday Learn more about Quarto and Connect Cloud: Quarto website: https://quarto.org/ Posit Connect Cloud: https://connect.posit.cloud/ Other videos in this Posit PydyTuesday playlist: https://www.youtube.com/playlist?list=PL9HYL-VRX0oSDQjicFMLIIdcLv5NuvDp9 #pythoncontent

Isabel Zimmerman

Create Quarto dashboards with Python

Learn how to create Quarto dashboards with Python! Senior Product Marketing Manager Isabella Velásquez walks through building a Quarto dashboard from scratch, using water insecurity data from the TidyTuesday project. You'll learn how to structure a Quarto document, preview dashboards, and customize layouts and themes. See Isabella's code here: https://github.com/ivelasq/water-insecurity-dashboard And the dashboard here: https://ivelasq-water-insecurity-dashboard.share.connect.posit.cloud/ Resources: Quarto dashboards guide: https://quarto.org/docs/dashboards/ Posit Connect Cloud: connect.posit.cloud Hello, Dashboards!: https://www.youtube.com/watch?v=HW7QbqI4fH0&t=590s 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

Free AI packages for R and Python #pythoncontent

Some free R and Python packages that can help when working with LLMs #datascience #artificialintelligence #machinelearning #openai #pythonprogramming #pythonprojects #dataanalysis #dataanalytics

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

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

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

Who are the data heroes of...data heroes? 💫

Create slideshows with Markdown & Python Code! (Quarto Tutorial)

Learn how to transform Markdown and Python code into interactive slide presentations using Quarto and reveal.js. This tutorial covers essential features like code execution, data visualization, LaTeX equations, custom styling, and slide transitions. Starting with basic slides, we'll explore advanced functionality including background customization, animations, chalkboard annotations, and brand theming. Perfect for data scientists, educators, and developers looking to create engaging technical presentations. Github repo: https://github.com/KeithGalli/quarto-projects Quarto slideshow demo page: https://quarto.org/docs/presentations/revealjs/ Quarto crash course video: https://youtu.be/_VKxTPWDhA4?si=VZxkW3kgtx1W_AIW Blog article on _brand.yml: https://posit.co/blog/unified-branding-across-posit-tools-with-brand-yml/ Video by @KeithGalli Video timeline! 0:00 - Video Overview 0:39 - Getting Started with the Code (link in description) 2:22 - Quarto Slideshow Basics 6:15 - Generating Powerpoint (pptx) Presentation Outputs 7:14 - RevealJS HTML Output Options & Features (Code Animation, Line Highlighting) 11:00 - Data Visualization in Quarto (Matplotlib, Plotly, Seaborn) 14:40 - Displaying Dataframes on Slides 18:15 - Presentation Features (Incrementally Revealing Items, Image Positioning, Slide Transitions, etc.) 25:02 - Keyboard Shortcuts Functionality (Zoom in, Chalkboard, Save Presentation as PDF, etc.) 29:14 - Styling Presentations with a _brand.yml File (New in Quarto 1.6) 34:39 - Jupyter Notebook to RevealJS Slideshow #Python #Quarto #DataVisualization #pythoncontent

Pharma Open-Source Packages and the R Validation Hub | A conversation with Aaron Clark

Posit's Director of Life Sciences, Phil Bowsher, sat down with Aaron Clark, Senior Principal Clinical Scientist at Arcus Biosciences, to discuss various topics within the open-source clinical reporting space including Aaron's career in pharma, the R Validation Hub, the open-source package riskmetric, and more. More about Posit's work in the pharma space: https://posit.co/use-cases/pharma/

Open Source in Clinical Reporting | A Conversation with Ben Arancibia at GSK

Posit's Director of Life Sciences, Phil Bowsher, sat down with GSK's Director of Data Science, Ben Arancibia, to discuss various topics within the open-source clinical reporting space. More about Posit's work in the pharma space: https://posit.co/use-cases/pharma/ Watch GSK's latest web event with Posit: https://www.youtube.com/watch?v=xDrt6txplek

Generate 100s of custom reports in minutes with Python & Quarto! (Parameterized report automation)

A practical guide to generating hundreds of customized reports using Quarto and Python. Learn how to leverage Quarto's parameter system to create PDFs and HTML reports at scale. Using a movie dataset example, we'll cover: - How to automate report generation with Python and Quarto - Create dynamic templates with data visualization and formatting - Adapt parameters to work with both Python and R code - Build scalable reporting workflows for any dataset This tutorial demonstrates how to transform what could be hours of manual reporting work into an efficient automated process. Quarto Crash Course Video: https://youtu.be/_VKxTPWDhA4?si=Q09V5xXlyo1YVQqs Generating Analytics Reports (typst) Video: https://youtu.be/Q3phTByW138?si=FIMiAWAHP6HhUnhG Link to Code (starting): https://github.com/KeithGalli/quarto-crash-course Link to Code (finished): https://github.com/KeithGalli/quarto-crash-course/tree/parameterized-reports Information on the dataset can be found here: https://github.com/KeithGalli/quarto-crash-course/tree/master?tab=readme-ov-file#resources Video timeline! 0:00 - Video Overview 0:58 - Walking through some starter code (linked in description) 3:20 - Passing parameters with Python into Quarto Markdown Files 4:27 - Passing parameters using R 5:18 - Using a Python script to render many reports with variable parameters. 6:36 - Dynamically generating markdown sections with Python (output: asis - execution option) 11:56 - Adding images, table of contents, & pagebreaks to our reports 15:00 - Adding graphs to our reports 17:54 - Tying everything together 21:47 - Adding fenced divs & styling/formatting dynamically with code

Quarto Websites 4: Add lists of content with listings | Charlotte Wickham | Posit

Adding a listing page to your website is a great way to showcase your projects, talks, publications or blog posts. In this video you’ll learn how to create a listing page in Quarto and see two ways to populate it with content: Quarto documents, or a yaml file. In this video: 0:50 Use a listing to add a blog 3:36 Listing options 5:47 Why use a listing? 7:22 Use a YAML file to populate a project portfolio 9:50 Customize the display of a listing 12:10 Advanced customization of listings 13:42 Remove pages Links: Listings: https://quarto.org/docs/websites/website-listings.html Andrew Heiss’ teaching listing: https://www.andrewheiss.com/teaching/ Code: Starter source code: https://github.com/cwickham/quarto-website-video/tree/v0.3 Final source code: https://github.com/cwickham/quarto-website-video/tree/v0.4 For more in-depth coverage and slides check out: https://posit-conf-2024.github.io/quarto-websites/ Do you need a professional website to showcase your work? If you’ve used Quarto to produce a document, you’ve already got the technical skills to create a Quarto website. In this video series, you’ll learn everything else you need to build a website and customize its appearance. This video series is for you if you: - Have used Quarto to generate documents (e.g. HTML, PDF, MS Word etc.) - Are comfortable editing plain text documents (e.g .qmd) in your IDE (e.g. RStudio, Visual Studio Code etc.) - Want to walk away with your own personal website Taught by: Charlotte Wickham (https://www.cwick.co.nz/) Emil Hvitfeldt (https://emilhvitfeldt.com/) Videos in this series: 1. Build your homepage [https://youtu.be/l7r24gTEkEY] 2. Add pages and navigation [https://youtu.be/k65E-8PXZmA] 3: Customize appearance with CSS/SCSS [https://youtu.be/pAN2Hiq0XGs] 4: Add lists of content with listings [https://youtu.be/bv_Cw-3HI1Y]

Charlotte Wickham, Emil Hvitfeldt

Quarto Websites 3: Customize appearance with CSS/SCSS | Emil Hvitfeldt | Posit

You now have a set of content you are happy with on your website, but how do you customize the look and feel of your site beyond options set in YAML? In this video, you’ll start by learning the basics of CSS and SCSS and how to make good design choices. Then, you’ll see how to apply these choices to your Quarto website. In this video: 0:14 What is HTML? 3:23 CSS Selectors 8:05 CSS Attributes 8:25 Layout attributes 10:24 Reducing repetition with SASS/SCSS? 15:26 Consistent design 16:36 Choosing colors 17:50 Choosing fonts 19:28 Maintaining accessibility 22:13 Apply SCSS to your website 24:16 Change the appearance of headings 25:28 Change the appearance of navigation bar 30:30 Use google fonts Links: Color contrast checker: https://colourcontrast.cc/ Google fonts: https://fonts.google.com/ Code: Starter source code: https://github.com/cwickham/quarto-website-video/tree/v0.2 Final source code: https://github.com/cwickham/quarto-website-video/tree/v0.3 For more in-depth coverage and slides check out: https://posit-conf-2024.github.io/quarto-websites/ Do you need a professional website to showcase your work? If you’ve used Quarto to produce a document, you’ve already got the technical skills to create a Quarto website. In this video series, you’ll learn everything else you need to build a website and customize its appearance. This video series is for you if you: - Have used Quarto to generate documents (e.g. HTML, PDF, MS Word etc.) - Are comfortable editing plain text documents (e.g .qmd) in your IDE (e.g. RStudio, Visual Studio Code etc.) - Want to walk away with your own personal website Taught by: Charlotte Wickham (https://www.cwick.co.nz/) Emil Hvitfeldt (https://emilhvitfeldt.com/) Videos in this series: 1. Build your homepage [https://youtu.be/l7r24gTEkEY] 2. Add pages and navigation [https://youtu.be/k65E-8PXZmA] 3: Customize appearance with CSS/SCSS [https://youtu.be/pAN2Hiq0XGs] 4: Add lists of content with listings [https://youtu.be/bv_Cw-3HI1Y]

Charlotte Wickham, Emil Hvitfeldt

Quarto Websites 2: Add pages and navigation | Charlotte Wickham | Posit

Now you’ve got a homepage, you’ll likely want to add some other pages. In this video, learn how to add pages to your website, and help people find them, by adding them to your website navigation. In this video: 1:00 Add a page to your website 2:54 Your file structure determines your URL structure 5:49 Add a link to your page in navigation 7:50 Customize navigation item text and icon 9:12 Control where items appear in the navigation bar 10:16 Navigation bar options 11:11 Switch to side navigation 12:22 Other types of navigation 16:30 Wrap Up Links: List of icons you can use in navigation items: https://icons.getbootstrap.com/ Top navigation bar options: https://quarto.org/docs/websites/website-navigation.html#top-navigation Quarto website navigation: https://quarto.org/docs/websites/website-navigation.html Code: Starter source code: https://github.com/cwickham/quarto-website-video/tree/v0.1 Final source code: https://github.com/cwickham/quarto-website-video/tree/v0.2 For more in-depth coverage and slides check out: https://posit-conf-2024.github.io/quarto-websites/ Do you need a professional website to showcase your work? If you’ve used Quarto to produce a document, you’ve already got the technical skills to create a Quarto website. In this video series, you’ll learn everything else you need to build a website and customize its appearance. This video series is for you if you: - Have used Quarto to generate documents (e.g. HTML, PDF, MS Word etc.) - Are comfortable editing plain text documents (e.g .qmd) in your IDE (e.g. RStudio, Visual Studio Code etc.) - Want to walk away with your own personal website Taught by: Charlotte Wickham (https://www.cwick.co.nz/) Emil Hvitfeldt (https://emilhvitfeldt.com/) Videos in this series: 1. Build your homepage [https://youtu.be/l7r24gTEkEY] 2. Add pages and navigation [https://youtu.be/k65E-8PXZmA] 3: Customize appearance with CSS/SCSS [https://youtu.be/pAN2Hiq0XGs] 4: Add lists of content with listings [https://youtu.be/bv_Cw-3HI1Y]

Charlotte Wickham, Emil Hvitfeldt

Quarto Websites 1: Build your homepage | Charlotte Wickham & Emil Hvitfeldt | Posit

In this video, you’ll get a running start by using a template we've designed to be functional and attractive, and that will serve as a foundation for the rest of the video series. You’ll customize the content of your homepage, and how it looks, and along the way learn about the two key files in a Quarto website index.qmd and _quarto.yml. Finally, you’ll learn one way to publish your website so other people can see it. In this video: 0:21 Use a template to get started 2:33 Preview the template homepage, index.qmd 4:12 Customize the content of your homepage 5:45 “About” pages 7:22 Customize the image on your homepage 9:24 Website configuration, _quarto.yml 10:40 Customize colors with YAML 13:45 Customize fonts with YAML 17:00 Publish your site Links: About pages: https://quarto.org/docs/websites/website-about.html Appearance options you can set in YAML: https://quarto.org/docs/output-formats/html-themes.html#basic-options Code: Starter source code: https://github.com/EmilHvitfeldt/website-template Final source code: https://github.com/cwickham/quarto-website-video/tree/v0.1 For more in-depth coverage and slides check out: https://posit-conf-2024.github.io/quarto-websites/ Do you need a professional website to showcase your work? If you’ve used Quarto to produce a document, you’ve already got the technical skills to create a Quarto website. In this video series, you’ll learn everything else you need to build a website and customize its appearance. This video series is for you if you: - Have used Quarto to generate documents (e.g. HTML, PDF, MS Word etc.) - Are comfortable editing plain text documents (e.g .qmd) in your IDE (e.g. RStudio, Visual Studio Code etc.) - Want to walk away with your own personal website Taught by: Charlotte Wickham (https://www.cwick.co.nz/) Emil Hvitfeldt (https://emilhvitfeldt.com/) Videos in this series: 1. Build your homepage [https://youtu.be/l7r24gTEkEY] 2. Add pages and navigation [https://youtu.be/k65E-8PXZmA] 3: Customize appearance with CSS/SCSS [https://youtu.be/pAN2Hiq0XGs] 4: Add lists of content with listings [https://youtu.be/bv_Cw-3HI1Y]

Charlotte Wickham, Emil Hvitfeldt

pandas vs Polars DataFrames? 👨🏻‍🍳 #python

Here's Marco Gorelli's take on why lazy execution matters So with pandas, everything happens eagerly. You give the library some instructions, and it evaluates your instructions the moment you give them. With Polars, there's an option to give it some instructions, it can wait a bit, and then do them all together in the most optimal way that it can detect. If I was to tell you to cook me a recipe ‍ ...and I gave you the steps one at a time ...and for each step, you have to go out and buy the ingredients that you need for that step ^ This is going to be a pretty inefficient way of making a cake But if I can give you the recipe beforehand: ...you can buy all the ingredients together ...you can maybe do 2 steps at the same time ^ This is going to be a much nicer cooking experience

Quarto Crash Course | Create Professional Reports, Dashboards & Websites w/ Markdown & Python Code!

Welcome to this comprehensive Quarto crash course using Python! Whether you're a complete beginner or an experienced user, this tutorial covers the topics you need to know about the Quarto publishing system. We'll explore: - Basic setup and installation - Creating HTML reports, PDFs, and interactive dashboards from your Python script or Jupyter notebook. - Building presentations with Revealjs - Customizing outputs with CSS and layouts (fenced divs, classes, and more) - Working with parameters for dynamic reports - Publishing to Posit Connect Cloud - Creating complete websites - Automated report generation Perfect for data scientists, analysts, and developers looking to create beautiful, reproducible reports from their code. We'll use Python throughout the tutorial with real-world examples using movie analytics data. Let's dive in! Video by @KeithGalli Github repo: https://github.com/KeithGalli/quarto-crash-course Deploy with Posit Connect Cloud! https://pos.it/keith_qc #python #quarto #posit — Resources Mentioned — Slideshow example: https://quarto.org/docs/presentations/revealjs/demo/#/title-slide Slideshow example (source code): https://github.com/quarto-dev/quarto-web/blob/main/docs/presentations/revealjs/demo/index.qmd Example HTML report: https://019302a7-e9e3-3454-3575-23148999a7f7.share.connect.posit.cloud/ Quarto Gallery: https://quarto.org/docs/gallery/ Bootstrap Icons: https://icons.getbootstrap.com/ Video timeline! 0:00 - About the Crash Course 0:50 - Quarto Overview 2:12 - Installation & Setup 6:22 - Markdown Basics 8:46 - Quarto Markdown Features 19:37 - Quarto Styling & Formatting (fenced divs, CSS classes, etc.) 34:53 - Parameters & CLI Options 40:46 - HTML & Publishing 49:46 - Static Docs (PDFs, Docx) 54:53 - Dashboards 1:06:50 - Slideshows (Revealjs) 1:16:11 - Websites 1:19:52 - Automated Report Generation (Parameterized Reports)

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

Quarto Dashboards 2: Components | Mine Çetinkaya-Rundel | Posit

Building dashboards in R and/or Python with Quarto, one component at a time. Before watching this video, you might want to watch Part 1. This video takes you through 0:00 - An overview of dashboard components 0:11 - Navigation bar and pages 4:55 - Sidebars, rows, columns, and tabsets 11:07 - Cards 22:40 - Live coding demo Slides can be found at https://mine.quarto.pub/quarto-dashboards/2-dashboard-components 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

Mine Çetinkaya-Rundel

Quarto Dashboards 1: Hello, Dashboards! | Mine Çetinkaya-Rundel | Posit

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 video takes you through 0:00 - Overview of building dashboards with Quarto 0:15 - Dashboard basics 7:40 - First dashboard in R 10:30 - First dashboard in Python 11:43 - Live coding demo Slides can be found at https://mine.quarto.pub/quarto-dashboards/1-hello-dashboards/#/title-slide 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

Mine Çetinkaya-Rundel

Updates from Posit, with Hadley Wickham, Charlotte Wickham, George Stagg, and James Blair

6:45 Hadley introduces the conference. 10:37 Hadley on Posit, PBC. Who are we, and what we do. 20:41 Charlotte Wickham on Quarto, an open-source scientific and technical publishing system. 31:05 George Stagg on webR, R for WebAssembly. Execute R code in your web browser. 43:34 James Blair with the latest on Posit's partnerships with Databricks and Snowflake. Please join us for our first Posit Conf 2024 keynote, where we’ll tell you about our mission, our products, and some of the exciting things we’ve been working on over the last year. Hadley Wickham, Chief Scientist, will talk briefly about Posit’s mission and products, before introducing the three speakers who will update you on some of the coolest projects we’ve worked on over the last year. James Blair, Senior Product Manager, will give you the latest on our partnerships with Databricks and Snowflake, and how we’re building seamless integrations that let you focus on data science instead of dealing with technical details. Charlotte Wickham, Developer Educator, will show you what’s new in Quarto, focusing on new ways to build beautiful PDFs with Typst. Finally, George Stagg, Senior Software Engineer, will tell you about the latest innovations in teaching using webR, a tool that lets you compile your R code into standalone HTML files. Talk by Hadley Wickham, James Blair, Charlotte Wickham, and George Stagg

Charlotte Wickham, George Stagg, Hadley Wickham

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

How Can Data Teams Get Out of Their Own Way (Alex Gold) - KNN Ep. 196

Today, I had the pleasure of interviewing Alex Gold. Alex is the Director of Solutions Engineering + Support at posit and author of DevOps for Data Science. In this episode, we talk about Alex's experience working in data for presidential campaigns, his experience in solutions engineering, and the role that DevOps plays in the data domain. Book: https://www.routledge.com/DevOps-for-Data-Science/Gold/p/book/9781003213345 (You can use Code AFLY04 for a 20% discount) Alex's Links: LinkedIn - https://www.linkedin.com/in/alexkgold/ Twitter - https://x.com/alexkgold Podcast Sponsors, Affiliates, and Partners: - Pathrise - http://pathrise.com/KenJee | Career mentorship for job applicants (Free till you land a job) - Taro - http://jointaro.com/r/kenj308 (20% discount) | Career mentorship if you already have a job - 365 Data Science (57% discount) - https://365datascience.pxf.io/P0jbBY | Learn data science today - Interview Query (10% discount) - https://www.interviewquery.com/?ref=kenjee | Interview prep questions Listen to Ken's Nearest Neighbors on all the main podcast platforms! On Apple Podcasts: https://podcasts.apple.com/us/podcast/kens-nearest-neighbors/id1538368692 (Please rate if you enjoy it!) On Spotify: https://open.spotify.com/show/7fJsuxiZl4TS1hqPUmDFbl On Google: https://podcasts.google.com/feed/aHR0cHM6Ly9mZWVkcy5idXp6c3Byb3V0LmNvbS8xNDMwMDQxLnJzcw?sa=X&ved=0CAMQ4aUDahcKEwjQ2bGBhfbsAhUAAAAAHQAAAAAQAQ MORE DATA SCIENCE CONTENT HERE: My Twitter - https://twitter.com/KenJee_DS LinkedIn - https://www.linkedin.com/in/kenjee/ Kaggle - https://www.kaggle.com/kenjee Medium Articles - https://medium.com/@kenneth.b.jee Github - https://github.com/PlayingNumbers My Sports Blog - https://www.playingnumbers.com ️ 66DaysOfData Discord Server - https://discord.com/invite/4p37sy5muZ

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

What AI skill should we learn? 🌱

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

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

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

GenAI and Pharma: Learning as we go | Episode 1: Copilot

In this episode, Phil and Cole discuss using Copilot in clinical trial submissions. Due to an industry-wide shift in pharma, statistical programmers are transitioning to open-source tooling in drug development. This skills gap that occurs when moving to open source is one area that can be aided with generative AI tools. In this episode, Cole and Phil show some of the features and functionality of a popular tool in the data science space, Copilot. More about open source in Pharma: https://posit.co/solutions/pharma/

Parallelize R code using user-defined functions in sparklyr

If you’re an Apache Spark user, you benefit from its speed and scalability for big data processing. However, you might still want to leverage R’s extensive ecosystem of packages and intuitive syntax. One effective way to do this is by writing user-defined functions (UDFs) with sparklyr. UDFs enable you to execute R functions within Spark, harnessing Spark’s processing power and combining the strengths of both tools. In this tutorial, you'll learn how to: - Open Posit Workbench as a Databricks user - Start a Databricks cluster within Posit Workbench - Connect to a cluster within Posit Workbench - View Databricks data in RStudio - Create a prediction function - Create a user-defined function with sparklyr Read our most recent blog that covers parallelizing R code using user-defined functions (UDFs) in sparklyr: https://posit.co/blog/databricks-udfs/ Learn more about our Databricks partnership: https://posit.co/solutions/databricks/ Watch other tutorials on using Databricks and RStudio: https://youtube.com/playlist?list=PL9HYL-VRX0oR-3AgWbXtlfdr29626EjRJ&feature=shared

Reproducible data science with webR and Shinylive | George Stagg | Posit

A fundamental principle of the scientific method is peer review and independent verification of results. Good science depends on transparency and reproducibility. However, in a recent study a substantial 74% of research code failed to run without errors, often caused by diverse computing environments. This talk will discuss the principles of numerical reproducibility in research and show how software can be pinned to specific versions and self-contained as a universal binary package using WebAssembly. This ensures seamless reproducibility on any machine equipped with a modern web browser and, using tools such as Shinylive, could provide a new way for researchers to share results with the community. webR demo website: https://webr.r-wasm.org/v0.3.2/ Shinylive examples: https://shinylive.io/r/ https://shinylive.io/py/ Documentation: https://docs.r-wasm.org/webr/v0.3.2/ https://github.com/posit-dev/shinylive https://github.com/quarto-ext/shinylive

George Stagg

Quarto: Elevating R Markdown for Advanced Publishing | Christophe Dervieux

In the dynamic landscape of data analysis and scientific publishing, R Markdown has been pivotal for the R community, allowing users to seamlessly blend code, narrative and results in a cohesive narrative. Now, Quarto emerges as a powerful tool that builds on years of experience but also goes beyond R Markdown, providing more flexibility and power in scientific communication. This talk aims to present Quarto as the new alternative for scientific publishing. We will delve into how Quarto enhances the user experience for R enthusiasts, maintaining the syntax familiarity of R Markdown while introducing innovative and improved functionalities across multiple formats, similar to R Markdown ones. Why switch to Quarto from R Markdown? In which cases? How does Quarto integrate with existing workflows? Hopefully everyone will feel inspired to try out Quarto! https://quarto.org/docs/get-started/ Timestamps: 0:00 Introduction 0:41 Quarto is an open-source, scientific and technical publishing system 1:22 Computational documents and scientific markdown made easy for single source publishing 3:08 How to use Quarto 4:24 Quarto works with VS Code, Positron, Jupyter, & RStudio 5:22 Quarto's multi-language workflow 7:21 Quarto syntax 8:40 Quarto formats (html, pdf, docx, typst, beamer, pptx, revealjs, etc.) 12:19 HTML Theming 14:10 Typst CSS for nice table output in PDF 16:24 Publishing (Quarto Pub, GitHub Pages, Posit Connect, Posit Cloud, Netlify, Confluence, Hugging Face, etc.) 17:36 Shortcodes 19:10 Quarto Extensions 19:49 Quarto Projects 22:53 Project configuration examples for a website and a book 23:42 Resources to get started!

Christophe Dervieux

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

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

Michael Chow, Rich Iannone

Your mission matters: A sustainable future with citizen data science at Dow

How do we keep food fresh? How do we use less water in our everyday lives? How do we make trash...valuable? How do we innovate to make the world a better place? The team at Dow Chemical is pushing the boundaries of material innovation for a more sustainable planet. To reach net zero carbon emissions by 2050, requires creativity and ingenuity from all different functions across the company. With Posit Academy and their citizen data science program, they have grown from a handful of researchers to over 300 people using Posit Workbench and deploying to Posit Connect

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

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

When creating tutorials for beginners, keep this in mind

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

Being SO good they can't ignore you

Tom recommended the book So Good They Can't Ignore You in a recent Data Science Hangout. Libby also keeps this awesome list of Hangout book recommendations: https://datahumans.notion.site/2f4552fd18be4d439b6b6977077e6ca5?v=738d0654fd81490890b8f741a2ef0a3c

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

{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

How to inspire people to make a change ✨

Key takeaways from our conversation on the path to effective data stewardship: 1. Change management is hard. To inspire people to change, make it as easy as possible for them to see the path to get there by creating tools to make new tasks easy to complete. A problem not only has to exist, but that problem needs to be recognized to exist. In the data governance space, legal regulations can help push us forward because they create urgency. 2. Data stewardship and data governance enable innovation. You see more of what’s possible when you know what data exists. Core systems form the foundation that enables cutting-edge work like AI development. 3. People have good intentions and want to get their work done and impact the organization. Don’t create processes where the only way to get your job done is to break the process. In the act of governing, remember why you started pulling data together in the first place. 4. Community engagement is incredibly powerful and hearing different perspectives is how we grow. We all face similar problems regardless of our role or industry. An internal community for cross-organizational collaboration is vital for knowing what other people are working on and collaborating. This not only helps you with your data, but also with your career. 5. Implementing effective data stewardship is a journey with companies at all different stages. Those further along the journey may have teams and infrastructure dedicated to this, along with executive buy-in. Others are working to make it happen at the individual level – where it often starts with writing down the definitions of your data (who created it, when it was sourced, intended use, etc.) and recognizing that someone else will use your data output, potentially not in the way you initially intended

Analyze and explore data stored in Snowflake using R

James Blair, Senior Product Manager, Cloud Integrations at Posit, will demonstrate using the R language to analyze and explore data stored in Snowflake. He will also show you how easy it is to set up an R environment inside Posit Workbench that runs as a native app on Snowpark Container Services. You also find out how using the dbplyr interface can be used to push computation data into Snowflake, giving you access to greater memory and compute power than in a standard R session. It's easy to get started. In just a few minutes, you can work in your R session securely inside Snowflake using the RStudio Pro IDE in Posit Workbench. Posit also supports VS Code and Jupyter for data scientists who prefer to work in other languages like Python, so you can continue to use the tools you know and love. Learn more about the Snowflake and Posit integration: https://posit.co/solutions/snowflake/

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

Lessons in career growth from gardening 🌱

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

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/

Shiny + Databricks 🫶

AI in the 50s and 60s 👀

How to overcome fear when applying to a new job

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

Most important thing a data scientist can do 💰

Data Science Hangout with Greg Shick, Director of Analytics at Charles Schwab. ‍️ Join us live at the Data Science Hangouts on Thursday from 12-1 ET: pos.it/dsh

Observing the creation of your data 🍕

Data Science Hangout with Zack Fragoso, Head of MLOps at Domino's Pizza. ‍️ Join us live at the Data Science Hangouts on Thursday from 12-1 ET: pos.it/dsh

Starting a People Analytics team

Data Science Hangout with Elizabeth Esarove, Lead Advanced Analytics, People Analytics at AT&T to chat about using data science to provide supporting evidence for decisions regarding employee outcomes and business objectives. ‍️ Join us live at the Data Science Hangouts on Thursday from 12-1 ET: pos.it/dsh

Follow these tips when asking for a raise 👀

Data Science Hangout with Elizabeth Esarove, Lead Advanced Analytics, People Analytics at AT&T to chat about using data science to provide supporting evidence for decisions regarding employee outcomes and business objectives. ‍️ Join us live at the Data Science Hangouts on Thursday from 12-1 ET: pos.it/dsh

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

70/20/10 model for upskilling at US FDA

Data Science Hangout with Kevin Snyder & Raju Rayavarapu @ U.S. FDA to chat about democratizing data science and utilizing principles of systems biology, pharmacology, toxicology, bioinformatics, and statistics to collaboratively develop open-source software solutions that support decision making and policy development. ‍️ Join us live at the Data Science Hangouts on Thursday from 12-1 ET: pos.it/dsh

Evolve your perspective by leaning into these 2 things

Data Science Hangout with Brad Zielke, Sr. Director Data Sciences at Target on leaning into empathy and humility to surround yourself with diverse perspectives and evolve your perspective as a leader. ‍️ Join us live at the Data Science Hangouts on Thursday from 12-1 ET: pos.it/dsh

This ONE THING is what hiring managers are looking for🤯

Data Science Hangout with Jamie Warner, Managing Director at Plymouth Rock Assurance. ‍️ Join us live at the Data Science Hangouts on Thursday from 12-1 ET: pos.it/dsh

How to get your boss to pay attention to your work 👀

How do you capture your boss' imagination and show the value of your data science project? Data Science Hangout with Michael Derstine, Vice President at Wells Fargo & Company. ‍️ Join us live at the Data Science Hangouts on Thursday from 12-1 ET: pos.it/dsh

Deploying Databricks-backed content on Posit Connect

After you connect to Databricks using sparklyr and create your content, you'll want to deploy and share your work. With the new pysparklyr::deploy_databricks() function, you can deploy your content to Posit Connect. Run the function and confirm to start deployment. The deploy_databricks() function will gather your document location, credentials, and URLs. It uses this information to deploy to Posit Connect. After it's done, click the URL to see the deployed content on Posit Connect. Open the content from the publisher view. Click around and check out your work. In Posit Connect, you can edit sharing permissions, create a vanity URL, and more. Open the content URL to see how your work would look to stakeholders. Learn more: - Databricks x Posit: https://posit.co/solutions/databricks/ - Empowering R and Python Developers: Databricks and Posit Announce New Integrations: https://posit.co/blog/databricks-and-posit-announce-new-integrations/ - Posit Connect: https://posit.co/products/enterprise/connect/ - sparklyr and Databricks Connect v2: https://spark.posit.co/deployment/databricks-connect.html - Deploying to Posit Connect: https://spark.posit.co/deployment/databricks-posit-connect.html Contact our sales team to schedule a demo: https://posit.co/schedule-a-call/?booking_calendar__c=Databricks

Databricks Pro Driver in Posit Workbench

We've added a Databricks driver to our Professional Drivers. The RStudio Connections Pane allows users to connect to their Databricks clusters from the IDE. Select the Databricks driver from the list of available drivers. Select the Driver to establish the connection. The driver can be used with the new databricks() function from the odbc package to connect to Databricks clusters and SQL warehouses. Learn more: - Databricks x Posit: https://posit.co/solutions/databricks/ - Empowering R and Python Developers: Databricks and Posit Announce New Integrations: https://posit.co/blog/databricks-and-posit-announce-new-integrations/ - RStudio IDE and Posit Workbench 2023.12.0: What’s New: https://posit.co/blog/rstudio-2023-12-0-whats-new/ - Posit Professional Drivers 2024.03.0: Support for Apple Silicon: https://posit.co/blog/pro-drivers-2024-03-0/ Contact our sales team to schedule a demo: https://posit.co/schedule-a-call/?booking_calendar__c=Databricks

Databricks Pane in Posit Workbench

We've introduced a Databricks Pane in RStudio Pro for discovering and managing Databricks clusters. Users can stay in RStudio Pro without navigating to the Databricks web interface to see their clusters. Click on the 'Connect to' icon to open up a new Databricks Connection pop-up. This forms the initial connection to Databricks. Once you click 'ok', you will be connected to Databricks. Learn more: - Databricks x Posit: https://posit.co/solutions/databricks/ - Empowering R and Python Developers: Databricks and Posit Announce New Integrations: https://posit.co/blog/databricks-and-posit-announce-new-integrations/ - RStudio IDE and Posit Workbench 2023.12.0: What’s New: https://posit.co/blog/rstudio-2023-12-0-whats-new/ - Posit Professional Drivers 2024.03.0: Support for Apple Silicon: https://posit.co/blog/pro-drivers-2024-03-0/ Contact our sales team to schedule a demo: https://posit.co/schedule-a-call/?booking_calendar__c=Databricks

Databricks Authentication in Posit Workbench

Posit Workbench now has delegated Databricks credentials. Users can log into a Databricks Workspace when starting an RStudio or VS Code session. Authentication relies on OAuth-backed refresh tokens rather than Personal Access Tokens (PATs). This allows for more granular control over permissions, built-in expiration, and defined scopes. Once logged in, you can interact directly with your Databricks clusters in that Workspace in your preferred environment. Learn more: - Databricks x Posit: https://posit.co/solutions/databricks/ - Empowering R and Python Developers: Databricks and Posit Announce New Integrations: https://posit.co/blog/databricks-and-posit-announce-new-integrations/ - RStudio IDE and Posit Workbench 2023.12.0: What’s New: https://posit.co/blog/rstudio-2023-12-0-whats-new/ - Posit Professional Drivers 2024.03.0: Support for Apple Silicon: https://posit.co/blog/pro-drivers-2024-03-0/ Contact our sales team to schedule a demo: https://posit.co/schedule-a-call/?booking_calendar__c=Databricks

Connecting RStudio and Databricks with sparklyr

You can connect RStudio and Databricks with the sparklyr package. First, load the necessary packages. Next, set up the connection with sparklyr::spark_connect(). See your data in the Connections pane. Check which databases you're connected to. Navigate the data structure by expanding the levels. Navigate to the table you want to explore...and analyze your data in RStudio. Learn more: - Databricks x Posit: https://posit.co/solutions/databricks/ - Empowering R and Python Developers: Databricks and Posit Announce New Integrations: https://posit.co/blog/databricks-and-posit-announce-new-integrations/ - Posit Connect: https://posit.co/products/enterprise/connect/ - sparklyr and Databricks Connect v2: https://spark.posit.co/deployment/databricks-connect.html - Deploying to Posit Connect: https://spark.posit.co/deployment/databricks-posit-connect.html Contact our sales team to schedule a demo: https://posit.co/schedule-a-call/?booking_calendar__c=Databricks

Connecting RStudio and Databricks with ODBC

The odbc package, in conjunction with a driver, provides DBI support and an ODBC connection. With the new odbc::databricks_connect function, you can create an ODBC connection to determine and configure the necessary settings to access your Databricks account. Your Databricks HTTP path is the only argument you need to run databricks_connect(). Provide your HTTP path and you will be able to see your Databricks data in the RStudio Connections Pane. Then, you can analyze your data in RStudio. Learn more: - Databricks x Posit: https://posit.co/solutions/databricks/ - Empowering R and Python Developers: Databricks and Posit Announce New Integrations: https://posit.co/blog/databricks-and-posit-announce-new-integrations/ - RStudio IDE and Posit Workbench 2023.12.0: What’s New: https://posit.co/blog/rstudio-2023-12-0-whats-new/ - Posit Professional Drivers 2024.03.0: Support for Apple Silicon: https://posit.co/blog/pro-drivers-2024-03-0/ Contact our sales team to schedule a demo: https://posit.co/schedule-a-call/?booking_calendar__c=Databricks

GitHub Copilot on Posit Cloud

Speed up your coding projects in the RStudio IDE on Posit Cloud with GitHub Copilot, an AI coding assistant. Learn more in our blog post: https://posit.co/blog/github-copilot-on-posit-cloud/ Posit Cloud: https://posit.cloud/ GitHub Copilot: https://github.com/features/copilot RStudio User Guide: https://docs.posit.co/ide/user/ide/guide/tools/copilot.html

Make data science slides with code using Quarto

You Can Lead a Horse to Water...Changing the Data Science Culture for Veterinary Scientists

Presented by Jill MacKay A retrospective look at supporting data science skills in a research-focussed veterinary school This is a talk about environment management, but not in the way you're thinking. In many industries, domain-specific experts need enough understanding of data science to support their work and communicate with data scientists, but often have insufficient training in these skills, and limited time with which to obtain data science skills and practice them. This is particularly challenging for those who are interdisciplinary and have limited control over their workload, such as medics and field scientists. In this talk, an educational scientist describes the previous 10 years of supporting veterinary scientists to adopt open science practices surrounding data science. What worked, what failed miserably, and reflections on why it can be so hard to get a horse to drink. Materials: - https://github.com/jillymackay/positconf2023_vetdata - https://jillymackay.com/post/positconf2023/ Presented at Posit Conference, between Sept 19-20 2023, Learn more at posit.co/conference. -------------------------- Talk Track: Teaching data science. Session Code: TALK-1095

Why You Should Stop Networking and Start Making Friends - posit::conf(2023)

Presented by Libby Heeren When we think about making connections, we think about networking. I'd like you to forget about networking and start thinking about making friends. I'll share my perspective as a community builder and host of the Data Humans podcast on how I cultivated a community of practice for myself and how I became a force multiplier who increases engagement. You'll learn how I made genuine human connections, the practical steps to making data friends, the power of vulnerability, and why we all benefit when we show up as our whole selves. Presented at Posit Conference, between Sept 19-20 2023, Learn more at posit.co/conference. -------------------------- Talk Track: Lightning talks. Session Code: TALK-1167

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

What's New in the Torch Ecosystem - posit::conf(2023)

Presented by Daniel Falbel torch is an R port of PyTorch, a scientific computing library that enables fast and easy creation and training of deep learning models. In this talk, you will learn about the latest features and developments in torch, such as luz, a higher-level interface that simplifies your model training code, and vetiver, a new integration that allows you to deploy your torch models with just a few lines of code. You will also see how torch works well with other R packages and tools to enhance your data science workflow. Whether you are new to torch or already an experienced user, this talk will show you how torch can help you tackle your data science challenges and inspire you to build your own models. Presented at Posit Conference, between Sept 19-20 2023, Learn more at posit.co/conference. -------------------------- Talk Track: Lightning talks. Session Code: TALK-1163

Daniel Falbel

What's New in Quarto?* - posit::conf(2023)

Presented by Charlotte Wickham It's been over a year since Quarto 1.0, an open-source scientific and technical publishing system, was announced at rstudio::conf(2022). In this talk, I'll highlight some of the improvements to Quarto since then. You'll learn about new formats, options, tools, and ways to supercharge your content. And, if you haven't used Quarto yet, come to see some reasons to try it out. Presented at Posit Conference, between Sept 19-20 2023, Learn more at posit.co/conference. -------------------------- Talk Track: Quarto (1). Session Code: TALK-1072

Charlotte Wickham

What I Wish I Knew Before Becoming a Data Scientist - posit::conf(2023)

Presented by Kaitlin Bustos In this talk, I'm sharing my personal journey as a data scientist and the key lessons learned along the way. I'll emphasize the importance of finding a positive community of like minded-allies, persevering through setbacks as success is not linear, and exploring by embracing the broad nature of the data science field. By sharing my experiences and acknowledging the challenges I've faced attendees will gain a fresh perspective on what it takes to succeed in a data science career and inspire them to pursue their passions in the field. Overall, this talk aims to provide a glimpse into the reality of a data science career. Attendees will take away a sense of motivation and empowerment to find their own unique path to success. Presented at Posit Conference, between Sept 19-20 2023, Learn more at posit.co/conference. -------------------------- Talk Track: Lightning talks. Session Code: TALK-1169

What an Early 2000s Reality Show Taught Me about File Management - posit::conf(2023)

Presented by Reiko Okamoto Clutter, whether it's physical or digital, destroys our ability to focus; home organization ideas can be extended to create an workspace where analysts feel inspired to work with data. Ideas from home organization shows are surprisingly applicable to file management. Using a room divider to establish dedicated zones for different activities in a studio apartment is analogous to creating self-contained projects in RStudio. Likewise, swapping mismatched hangers with matching ones to tidy a closet resembles the adoption of a file naming convention to make a directory easier to navigate. In this talk, I will share good practices in file management through the lens of home organization. We all know that clutter, whether it is in our physical space or on our machine, destroys our ability to focus. These practices will help R users of all levels create a serene, relaxing environment where they feel inspired to work with data. https://reikookamoto.github.io/; https://github.com/reikookamoto/posit-conf-2023-neat 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-1090

We Converted our Documentation to Quarto - posit::conf(2023)

Presented by Melissa Van Bussel Elevate your Quarto projects to new heights with these practical tips and tricks! "Wiki", "User Guide", "Handbook" -- whatever you call yours, we converted ours to Quarto! A year ago, my team's documentation, which had been created using Microsoft Word, was large and lacked version control. Scrolling through the document was slow, and, due to confidentiality reasons, only one person could edit it at a time, which was a significant challenge for our team of multiple developers. After realizing we needed a more flexible solution, we successfully converted our documentation to Quarto. In this talk, I'll discuss our journey converting to Quarto, the challenges we faced along the way, and tips and tricks for anyone else who might be looking to adopt Quarto too. Slides: https://melissavanbussel.quarto.pub/posit-conf-2023; Code for slides: https://github.com/melissavanbussel/posit-conf-2023; My YouTube: https://www.youtube.com/c/ggnot2; My website: https://www.melissavanbussel.com/; My Twitter: https://twitter.com/melvanbussel; My LinkedIn: https://www.linkedin.com/in/melissavanbussel/ Presented at Posit Conference, between Sept 19-20 2023, Learn more at posit.co/conference. -------------------------- Talk Track: Quarto (2). Session Code: TALK-1140

Visualizing Data Analysis Pipelines with Pandas Tutor and Tidy Data Tutor - posit::conf(2023)

Presented by Sean Kross The data frame is a fundamental data structure for data scientists using Python and R. Pandas and the tidyverse are designed to center building pipelines for the transformation of data frames. However, within these pipelines it is not always clear how each operation is changing the underlying data frame. To explain each step in a pipeline data science instructors resort to hand-drawing diagrams to illustrate the semantics of operations such as filtering, sorting, and grouping. In this talk, I will introduce Pandas Tutor and Tidy Data Tutor, step-by-step visual representation engines of data frame transformations. Both tools illustrate the row, column, and cell-wise relationships between an operation's input and output data frames. Presented at Posit Conference, between Sept 19-20 2023, Learn more at posit.co/conference. -------------------------- Talk Track: Teaching data science. Session Code: TALK-1096

Validating and Testing R Dataframes with Pandera via reticulate - R-Python Interoperability

Presented by Niels Bantilan Original Full Title: Validating and Testing R Dataframes with Pandera via reticulate: A Case Study in R-Python Interoperability Data science and machine learning practitioners work with data every day to analyze and model them for insights and predictions. A major component of any project is data quality, which is a process of cleaning, and protecting against flaws in data that may invalidate the analysis or model. Pandera is an open source data testing toolkit for dataframes in the Python ecosystem: but can it validate R dataframes? This talk is composed of three parts: first I'll describe what data testing is and motivate why you need it. Then, I'll introduce the iterative process of creating and refining dataframe schemas in Pandera. Finally, I'll demonstrate how to use it in R with the reticulate package using a simple modeling exercise as an example. 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-1123

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

Using R with Databricks Connect - posit::conf(2023)

Presented by Edgar Ruiz Spark Connect, and Databricks Connect, enable the ability to interact with Spark stand-alone clusters remotely. This improves our ability to perform Data Science at-scale. We will share the work in `sparklyr`, and other products, that will make it easier for R users to take advantage this new framework. Presented at Posit Conference, between Sept 19-20 2023, Learn more at posit.co/conference. -------------------------- Talk Track: Tidy up your models. Session Code: TALK-1084

Edgar Ruiz