Coding

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

Rodrigo Silva Ferreira-When Rivers Speak Analyzing Massive Water Quality Datasets-PyData Boston 2025

Rivers have long been storytellers of human history. From the Nile to the Yangtze, they have shaped trade, migration, settlement, and the rise of civilizations. They reveal the traces of human ambition... and the costs of it. Today, from the Charles to the Golden Gate, US rivers continue to tell stories, especially through data. Over the past decades, extensive water quality monitoring efforts have generated vast public datasets: millions of measurements of pH, dissolved oxygen, temperature, and conductivity collected across the country. These records are more than environmental snapshots; they are archives of political priorities, regulatory choices, and ecological disruptions. Ultimately, they are evidence of how societies interact with their environments, often unevenly. In this talk, I’ll explore how Python and modern data workflows can help us "listen" to these stories at scale. Using the United States Geological Survey (USGS) Water Data APIs and Remote SSH in Positron, I’ll process terabytes of sensor data spanning several years and regions. I’ll demonstrate that, while Parquet and DuckDB enable scalable exploration of historical records, using Remote SSH is paramount in order to enable large-scale data analysis. By doing so, I hope to answer some analytical questions that can surface patterns linked to industrial growth, regulatory shifts, and climate change. By treating rivers as both ecological systems and social mirrors, we can begin to see how environmental data encodes histories of inequality, resilience, and transformation. Whether your interest lies in data engineering, environmental analytics, or the human dimensions of climate and infrastructure, this talk will explore topics at the intersection of environmental science, will offer both technical methods and sociological lenses to understand the stories rivers continue to tell

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

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/

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/

KEYNOTE: Dr. Jeroen Janssens - Embrace the Unix Command Line and Supercharge Your PyData Workflow

www.pydata.org Discover why the Unix command line remains a powerful and relevant tool for data scientists, even in a Python-dominated landscape. This talk will demonstrate how embracing the command line and leveraging its many tools can significantly enhance your productivity, streamline data workflows, and complement your Python skills. Jeroen Janssens, PhD, is a polyglot data science consultant and certified instructor. His expertise lies in visualizing data, implementing machine learning models, and building solutions using Python, R, JavaScript, and Bash. Jeroen is passionate about open source and sharing knowledge. He is the author of Data Science at the Command Line (O’Reilly, 2021) and is currently writing Python Polars: The Definitive Guide (O’Reilly, 2025). Every now and then he blogs at https://jeroenjanssens.com. PyData is an educational program of NumFOCUS, a 501(c)3 non-profit organization in the United States. PyData provides a forum for the international community of users and developers of data analysis tools to share ideas and learn from each other. The global PyData network promotes discussion of best practices, new approaches, and emerging technologies for data management, processing, analytics, and visualization. PyData communities approach data science using many languages, including (but not limited to) Python, Julia, and R. PyData conferences aim to be accessible and community-driven, with novice to advanced level presentations. PyData tutorials and talks bring attendees the latest project features along with cutting-edge use cases. 00:00 Welcome! 00:10 Help us add time stamps or captions to this video! See the description for details. Want to help add timestamps to our YouTube videos to help with discoverability? Find out more here: https://github.com/numfocus/YouTubeVideoTimestamps

Jeroen Janssens

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

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

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 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

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

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

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

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

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

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

It's All About Perspective: Making a Case for Generative Art - posit::conf(2023)

Presented by Meghan Santiago Harris This talk explores how to create art in the R language while highlighting some similarities between the skills required for creating generative art and those needed to perform data science tasks in R. Because the field of data science is inherently task-oriented, it is no wonder that most people struggle to see the utility of generative art past the bounds of a casual hobby. This talk will invite the participant to learn about generative art while focusing on ""why"" people should create it and its potential place in data science. This talk is suitable for all disciplines and artistic abilities. Furthermore, this talk will aim to expand the participant's perspective on generative art with the following concepts: - What is generative art and how can it be created in R or Python - Justifications for generative art within Data Science - Examples of programming skills that are transferrable between generative art and pragmatic data science projects Materials: - Link to the talk repo: https://github.com/Meghansaha/a_case_for_genart - Link to the slides: https://meghansaha.github.io/a_case_for_genart/#/title-slide - Link to the artpack package site: https://meghansaha.github.io/artpack/ - Personal Site: https://thetidytrekker.com/ Presented at Posit Conference, between Sept 19-20 2023, Learn more at posit.co/conference. -------------------------- Talk Track: Developing your skillset; building your career. Session Code: TALK-1109

A hacker's guide to open source LLMs - posit::conf(2023)

Presented by Jeremy Howard In this deeply informative video, Jeremy Howard, co-founder of fast.ai and creator of the ULMFiT approach on which all modern language models (LMs) are based, takes you on a comprehensive journey through the fascinating landscape of LMs. Starting with the foundational concepts, Jeremy introduces the architecture and mechanics that make these AI systems tick. He then delves into critical evaluations of GPT-4, illuminates practical uses of language models in code writing and data analysis, and offers hands-on tips for working with the OpenAI API. The video also provides expert guidance on technical topics such as fine-tuning, decoding tokens, and running private instances of GPT models. As we move further into the intricacies, Jeremy unpacks advanced strategies for model testing and optimization, utilizing tools like GPTQ and Hugging Face Transformers. He also explores the potential of specialized datasets like Orca and Platypus for fine-tuning and discusses cutting-edge trends in Retrieval Augmented Generation and information retrieval. Whether you're new to the field or an established professional, this presentation offers a wealth of insights to help you navigate the ever-evolving world of language models. (The above summary was, of course, created by an LLM!) For the notebook used in this talk, see https://github.com/fastai/lm-hackers. Presented at Posit Conference, between Sept 19-20 2023, Learn more at posit.co/conference. -------------------------- Talk Track: Notebooks+LLMs may just be the future of coding. Session Code: KEY-1107

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

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

Joe Cheng

posit::conf(2023) Workshop:Enhancing Communication & Collaboration with Quarto and Jupyter Notebooks

Register now: http://pos.it/conf Instructor: Hamel Husain Workshop Duration: 1-Day Workshop This workshop is for you if you: • have some experience with Python and Jupyter and want to learn how Quarto can support and enhance your workflows • want to learn about turning your notebooks to websites and publications • want to learn how to write python packages with Jupyter notebooks and Quarto with the help of nbdev The workshop will assume some prior experience with Python and Jupyter Notebooks. Sharing knowledge through writing is a critical aspect of scientific activity, including data science. It allows researchers to communicate their findings and insights to a wider audience, build upon existing work, and collaborate with others in their field. However, until recently, there have been limited options for publishing long-form writing and expository analyses authored in Jupyter Notebooks, a popular medium for data scientists. Enter Quarto - an innovative, open-source scientific and technical publishing system compatible with Jupyter Notebooks and other popular mediums. Quarto provides data scientists with a seamless way to publish their work in a high-quality format that is easily accessible and shareable. With Quarto, researchers can turn their Jupyter Notebooks into professional-looking publications in a variety of formats, including web pages, books, and slides. In this workshop, we will demonstrate how Quarto enables data scientists to turn their work products into professional, high-quality publications, websites, blog posts, and other shareable artifacts. As a bonus, we will also discuss how you can create and document Python packages using Jupyter notebooks and Quarto with the help of nbdev. The learning outcomes for the workshop include: • examine case studies where sharing scientific knowledge has greatly improved the efficacy of data science teams • author documents in plain text markdown or Jupyter notebooks with equations, citations, crossrefs, figure panels, callouts, and advanced layouts • learn how to author content in IPython/Jupyter and the Quarto VS Code extension • leverage Quarto for creating different types of publications, including personal blogs, knowledge management for teams, notes, books, websites, and presentation slides • extend Quarto with notebook filters and extensions • host websites and publications on platforms like GitHub Pages, QuartoPub, and Netlify • test notebooks and documentation with Quarto’s execution options • create and document Python packages with nbdev and Quarto

posit::conf(2023) Workshop: Tidy time series and forecasting in R

Register now: http://pos.it/conf Instructor: Rob J Hyndman Workshop Duration: 2-Day Workshop This course is for you if you: • already use the tidyverse packages in R such as dplyr, tidyr, tibble and ggplot2 • need to analyze large collections of related time series • would like to learn how to use some tidy tools for time series analysis including visualization, decomposition and forecasting It is common for organizations to collect huge amounts of data over time, and existing time series analysis tools are not always suitable to handle the scale, frequency and structure of the data collected. In this workshop, we will look at some packages and methods that have been developed to handle the analysis of large collections of time series. On day 1, we will look at the tsibble data structure for flexibly managing collections of related time series. We will look at how to do data wrangling, data visualizations and exploratory data analysis. We will explore feature-based methods to explore time series data in high dimensions. A similar feature-based approach can be used to identify anomalous time series within a collection of time series, or to cluster or classify time series. Primary packages for day 1 will be tsibble, lubridate and feasts (along with the tidyverse of course). Day 2 will be about forecasting. We will look at some classical time series models and how they are automated in the fable package, and we will explore the creation of ensemble forecasts and hybrid forecasts. Best practices for evaluating forecast accuracy will also be covered. Finally, we will look at forecast reconciliation, allowing millions of time series to be forecast in a relatively short time while accounting for constraints on how the series are related

posit::conf(2023) Workshop: Teaching Data Science Masterclass

Register now: http://pos.it/conf Instructor: Dr. Mine Çetinkaya-Rundel Workshop Duration: 1-Day Workshop This course is for you if you: • you want to learn / discuss curriculum, pedagogy, and computing infrastructure design for teaching data science with R and RStudio using the tidyverse and Quarto • you are interested in setting up your class in Posit Cloud • you want to integrate version control with git into your teaching and learn about tools and best practices for running your course on GitHub This masterclass is aimed primarily at participants teaching data science in an academic setting in semester-long courses, however much of the information and tooling we introduce is applicable for shorter teaching experiences like workshops and bootcamps as well. Basic knowledge of R is assumed and familiarity with the tidyverse and Git is preferred. There has been significant innovation in introductory statistics and data science courses to equip students with the statistical, computing, and communication skills needed for modern data analysis. Success in data science and statistics is dependent on the development of both analytical and computational skills, and the demand for educators who are proficient at teaching both these skills is growing. The goal of this masterclass is to equip educators with concrete information on content, workflows, and infrastructure for painlessly introducing modern computation with R and RStudio within a data science curriculum. In a nutshell, the day you’ll spend in this workshop will save you endless hours of solo work designing and setting up your course. Topics will cover teaching the tidyverse in 2023, highlighting updates to R for Data Science (2nd ed) and Data Science in a Box as well as present tooling options and workflows for reproducible authoring, computing infrastructure, version control, and collaboration. The workshop will be comprised of four modules: • Teaching data science with the tidyverse and Quarto • Teaching data science with Git and GitHub • Organizing, publishing, and sharing of course materials • Computing infrastructure for teaching data science Throughout each module we’ll shift between the student perspective and the instructor perspective. The activities and demos will be hands-on; attendees will also have the opportunity to exchange ideas and ask questions throughout the session. In addition to gaining technical knowledge, participants will engage in discussion around the decisions that go into developing a data science curriculum and choosing workflows and infrastructure that best support the curriculum and allow for scalability. We will also discuss best practices for configuring and deploying classroom infrastructures to support these tools

Mine Çetinkaya-Rundel

posit::conf(2023) Workshop: Steal like an Rtist: Creative Coding in R

Register now: http://pos.it/conf Instructors: Ijeamaka Anyene Fumagalli & Sharla Gelfand Workshop Duration: 1-Day Workshop This workshop is for you if you: • are comfortable with R and RStudio, experience with tidyverse and ggplot2 • are interested in applying data visualization skills more creatively, but may not know where to start or how to develop style/inspiration • are an artist interested in exploring code as another medium for creating their work R is a tool for data analysis but also can be used for self-expression. This workshop will be an introduction to creative coding in R in order to make visual art. We will take an inspiration-first approach, using compelling pieces to discuss and learn the techniques that shape the work. This workshop takes guidance from its namesake, the book “Steal Like An Artist” by Austin Kleon - once we have identified and learned to recreate existing works, we will cover how to take this inspiration and transform, remix, or reinterpret it in the pursuit of developing our own work and artistic styles. This workshop is hands-on and will cover color theory and manipulation, a reintroduction of the data frame as the foundation for creating art (instead of just for analyzing data!), using ggplot2 as an artistic canvas, creating basic and specialized shapes, tiling and pattern making, developing your own functions and using iteration. We will also discuss how to use controlled randomness to convert a standalone piece into a generative art system that can produce many distinct outputs. Creative coding may seem a world apart from data analysis, but we see a large overlap and intersection of the skills used in both, not to mention the creative muscles that are already used in data visualization

posit::conf(2023) Workshop: Machine Learning and Deep Learning with Python

Register now: http://pos.it/conf Instructor: Sebastian Raschka Workshop Duration: 1-Day Workshop In this workshop, you will learn the machine and deep learning fundamentals using a modern open-source stack. We’ll start with a brief introduction to Python’s scientific computing libraries, including NumPy, Pandas, and Matplotlib, which provide the foundation for data analysis and visualization. From there, we will dive into the scikit-learn API, a user-friendly, open-source library for machine learning in Python. You will learn how to use it to create machine learning classifiers and apply tree-based models like random forests, gradient boosting, and XGBoost. In the second part of this workshop, we will also cover deep learning concepts and introduce PyTorch, the most widely used deep learning research library. You will also learn about training multi-layer neural networks efficiently using multi-GPU and mixed-precision techniques. Finally, we will explore how to use a pretrained large language transformer with scikit-learn and fine-tune it on a custom downstream task using PyTorch. By the end of this workshop, you will have a good understanding of the fundamental principles of machine learning and be able to construct advanced classification pipelines for tabular data using scikit-learn. Additionally, you will gain experience in image classification and natural language processing techniques using PyTorch and be able to implement them in your own predictive modeling projects effectively

posit::conf(2023) Workshop: Fundamentals of Package Development

Register now: http://pos.it/conf Instructor: Andy Teucher Workshop Duration: 1-Day Workshop This workshop is for you if: • You have written several R scripts and find yourself wondering how to reuse or share the code you’ve written • You know how to write functions in R • You are looking for a way to take the next step in your R programming journey We will be demonstrating some workflows using Git and GitHub. Knowledge of these tools is not required, and you will absolutely be able to complete the workshop without them, but some of the lessons will be more rewarding to you if you are prepared to try them out. If you are looking to get started with Git and GitHub, we recommend you register for the “What they forgot to teach you about R” workshop on Day 1, and join us for this workshop on Day 2. We are often faced with the need to share our code with others, or find ourselves writing similar code over and over again across different projects. In R, the fundamental unit of reusable code is a package, containing helpful functions, documentation, and sometimes sample data. This workshop will teach you the fundamentals of package development in R, using tools and principles developed and used extensively by the tidyverse team - specifically the ‘devtools’ family of packages including usethis, testthat, and roxygen2. These packages and workflows help you focus on the contents of your package rather than the minutiae of package structure. You will learn the structure of a package, how to organize your code, and workflows to help you develop your package iteratively. You will learn how to write good documentation so that users can learn how to use your package, and how to use automated testing to ensure it is functioning the way you expect it to, now and into the future. You will also learn how to check your package for common problems, and how to distribute your package for others to use. This will be an interactive 1-day workshop, and we will be using the RStudio IDE to work through the materials, as it has been designed to work well with the development practices we will be featuring

posit::conf(2023) Workshop: Engaging and Beautiful Data Visualizations with ggplot2

Register now: http://pos.it/conf Instructor: Cédric Scherer Workshop Duration: 1-Day Workshop This course will be appropriate for you if you: • already know how to create basic graphics with the ggplot2 package • aim to improve the design of your ggplot outputs • want to learn how to create more complex charts which feature multiple layers, annotations, text styling, custom themes, and more Creating effective and easily accessible data visualizations of high quality in an efficient and preferably reproducible way is an essential skill for everyone working in a data-related field. Luckily, by leveraging the functionality of ggplot2, the most famous package for data visualization with R, and related extension packages one can create highly customized data visualization without the need for post-processing. This workshop provides everything one needs to know to create and customize numerous chart types with ggplot2. Participants will learn the most important steps and helpful tips to create visually appealing and informative graphics with a code-only approach. The power of ggplot2 and related extension packages will be illustrated with advanced real–life examples that help to understand useful coding tricks and the process of creating engaging and effective visualizations. The workshop will particularly focus on more advanced tasks with ggplot2 such as styling labels and titles, customizing themes and visual aesthetics, and using less-common chart types

posit::conf(2023) Workshop: Designing Data Visualizations to Successfully Tell a Story

Register now: http://pos.it/conf Instructor: Cédric Scherer Workshop Duration: 1-Day Workshop This course is for you if you: • want to understand and learn the art of communicating data with impactful visualizations • aim to improve your data visualization design to create effective and informative graphics • are willing to spend a bit more time to choose the right chart, proper color palettes, and suitable fonts along with additional elements to guide the viewer Communicating data through meaningful and easily accessible visualization is a critical competence for most data-related roles including data scientists, analysts, scientific researchers, and managers. A well-designed graphic is able to inform, spark engagement, explain patterns, and drive decisions and actions. At the same time, poor choices in the design process can complicate interpretation or even, intentionally or unintentionally, mislead the audience. The aim of this course is to demystify the creative processes of data visualization design to turn data into a meaningful story. Participants will learn helpful tips and tricks to create appealing and informative data visualizations that are not “just showing the numbers” but successfully tell a story. We will cover principles of good data visualization design, explore different options to display data, and discuss ways to guide and engage viewers with the aim to create impactful graphics. The course also features sessions on picking suitable yet beautiful colors, what to consider when choosing and pairing typefaces, and the layout of graphics, also in the context of dashboard building

How to deploy a Dash application from VS Code to Posit Connect

Episode 1: Publishing a Dash application to Posit Connect Led by: Ryan Johnson, Data Science Advisor Follow-up links: * Posit Team: https://posit.co/products/enterprise/team/ * Talk to us directly: https://posit.co/schedule-a-call/?booking_calendar__c=RST_YT_Demo * Follow-along blog post: https://posit.co/blog/deploying-a-dash-application-to-posit-connect/ * Source code for example: https://github.com/sol-eng/python-examples * Posit Team demo resources: pos.it/demo-resources Timestamps: 00:53 - What is Posit Team? (Posit Workbench, Posit Connect, Posit Package Manager) 3:25 - JumpStart Examples in Posit Connect 4:00 - Opening up a VS Code Session in Posit Workbench 8:03 - Downloading the Dash JumpStart example in Posit Connect 9:40 - Open up the JumpStart example in VS Code in Posit Workbench 11:18 - Install the required Python packages using pip 12:55 - Python packages on Posit Package Manager 15:12 - Defining the packages you want to install (latest, specific date, etc.) 19:12 - Creating an API key in Posit Connect 20:29 - Deployment process from VS Code to Posit Connect 21:36 - Dash application hosted on Posit Connect 22:23 - Access controls in Posit Connect (sharing with the people who need to see your app) 24:10 - Adjusting the runtime of an application in Posit Connect (controlling compute resources) 26:35 - Tags in Posit Connect 26:48 - Vars (if your content requires privileged access) 27:15 - Recap of what was covered in the demo On the last Wednesday of every month, we host a Posit Team demo and Q&A session that is open to all. You can use this to add the event to your own calendar. Who are these monthly demos for? Everyone is welcome to join us - regardless of industry, background, or experience! We will discuss topics that will speak to: * Data scientists and administrators new to Posit Team or are looking to grow their understanding of our toolchain, * Teams searching for a new analytic platform built to support open-source data science, * And, those that are just curious about Posit Team! What you can expect from the monthly Posit Team demo: During the session, we will walk through an end-to-end data science workflow and demo the core functionality of Posit Team while highlighting some of our latest features! While each session's content will vary slightly, here are a few core topics we will address each month: * Open Source Analytics: The future of data science is open source. We'll discuss methods for leveraging open-source tools and packages in a secure and scalable way! * Deployment: How to share the amazing data science assets your Team has built, including web applications, machine learning models, APIs, and more! * Data Access: Data comes in various forms and is stored in various ways. We'll discuss best practices for accessing, reading, and writing data! * Job Scheduling: Do you have recurring data science jobs? We'll show you how to automate these processes using Posit Connect. What is Posit Team? Posit Team is a bundle of our popular professional software (Posit Workbench, Posit Connect, and Posit Package Manager) for developing data science projects, publishing data products, and managing packages. Registration is not required. The event will be streamed through YouTube Premiere

Quarto with the Quarto Team | An Open-Source Chat

Join Al Manning, Carlos SchIidegger, & Charles Teague, members of the Quarto Team, as they take our questions. Quarto is an open-source tool for scientific and technical publishing. Create dynamic content with Python, R, Julia, and Observable. Author documents as plain text markdown or Jupyter notebooks. Publish high-quality articles, reports, presentations, websites, blogs, and books in HTML, PDF, MS Word, ePub, and more. Author with scientific markdown, including equations, citations, crossrefs, figure panels, callouts, advanced layout, and more. Key Resources: ⬡ Learn more and get started with Quarto at quarto.org Contact ⬡ Bug reports and feature requests - https://github.com/quarto-dev/quarto-cli/issues ⬡ Need help? Github discussions - https://github.com/quarto-dev/quarto-cli/discussions Introduction Videos for Quarto ⬡ Mine and Julia talk, https://www.youtube.com/watch?v=p7Hxu4coDl8 ⬡ Quarto Series, 1️⃣ Welcome to Quarto Workshop led by Tom Mock: https://www.youtube.com/watch?v=yvi5uXQMvu4 2️⃣ Building a Blog with Quarto led by Isabella Velásquez: https://www.youtube.com/watch?v=CVcvXfRyfE0&feature=youtu.be 3️⃣ Beautiful reports and presentations with Quarto led by Tom Mock: https://www.youtube.com/watch?v=hbf7Ai3jnxY&feature=youtu.be Timestamps 00:00:00 Introductions 2:55 Why open source? 6:20 Can we expect to see Quarto available to R-users via CRAN any time soon? 9:10 Quarto and Google Docs? 9:49 Lua filters/shortcodes. Advice for a good development environment for prototyping and debugging? 14:59 Is there a single documentation page for ALL the quarto-specific YAML options? https://quarto.org/docs/reference 16:15 Navigating Quarto's documentation. 18:00 Is there something like Observable SQL cells on the roadmap? 20:10 Is there something closer to {bookdown} for Quarto? What is the best way to retain data and environment objects in a quarto book? Is there any path to enabling this? See Includes, https://quarto.org/docs/authoring/includes.html 24:20 Flexdashboard? Coming soon. 26:30 A big challenge in the adoption is that Quarto is competing with ipython notebooks for mindspace, what does the Quarto team think about that? Quarto and Jupyter Notebooks will hopefully be thought of as complementary to one another, with Quarto helping a lot with narrative, layout, and appearance for publication and sharing. 30:10 Where should I go to contact you about an issue? What if the issue isn't just Quarto, say, Quarto + Jupyter? 31:50: What is the Quarto team hoping to see the community produce? Feedback, reporting in github issues. Quarto Extensions. 34:05 Custom styling, configuring grid options. Any tips or anything in the roadmap that will help users finetune the look and feel of their output? 38:40 Terminology question; what do we call a published Quarto doc? (or webpage, blog, etc.?) 40:00 How do I stay up to date with Quarto? Getting the latest release and learning about what is new? See what's up on quarto.org. Look under get-started and under downloads for pre-releases

Open Source Chat - {gt} with Rich Iannone

Join Rich Iannone, maintainer of the {gt} package, as he takes questions from the community about the latest in {gt} v0.7.0, and building great looking data display tables with R. Key Resources: ⬡ Get started with {gt} - https://gt.rstudio.com Reach out: 38:48 - How do I ask Rich about {gt}, feature requests, bug reports, how to solve a problem via {gt}? Rich and the {gt} team would love to hear from you. ⬡ Feature requests & bug reports with GitHub Issues, https://github.com/rstudio/gt/issues ⬡ GitHub Discussions, https://github.com/rstudio/gt/discussions ⬡ Ask the community a question, https://community.rstudio.com/tag/gt ⬡ Follow {gt} on Twitter, feel free to reach out and ask questions, https://twitter.com/gt_package Timestamps Rich Iannone Introduction. 03:52 - Why {gt}? - What does {gt} bring to the table? Why so much effort into static, data display tables? 05:50 - Why open source? Why is {gt} open source and why have you dedicated your career to develop open source software? 08:30 - {gt} v0.7.0, Tell us about those new vector formatting functions in {gt}. Why did you include them? Could you show us some examples? {gt}'s vector formatting functions help you customize the styling, look and feel of your values. Converting the output values R gives you, and making them look exactly the way you want them to can be tricky. A lot of work was put into {gt} to give nice value formatting options. You can now access all these outside of a gt table; e.g. in text, in a plot, etc. 22:35 - Could you provide an example or two with the new styling function called `opt_stylize()`? What kinds of tables can you make with that? Can you extend that with your own tweaks? 28:15 - Can you make your own themes and share them? "How do I create my own custom theme for my table? A theme I can share with the rest of my organization?" 31:58 - What is the distinction between tab_options and the opt_* functions? Why would a function be in opt_* and not tab_options? 34:00 - sub_values() function, to find and replace certain values in your table. 36:50 - What is the current support for latex in {gt} at the moment? "Personally, I much prefer HTML, but for scientific publications, we are asked to provide a LaTeX file." 42:50 - "In my work, I often produce A4 output in PDF, mainly with ggplot2 content. It would be nice to be able to combine ggplot + gt tables in a similar way {patchwork} works. Having the plot and the table next to it is very useful sometimes." 44:30 - Interactive Tables with {gt}? 47:45 - "Any plans to make applying of same style to several columns easier? Unless I'm mistaken, the locations argument of tab_style requires one to specify an individual column. See here: https://gt.rstudio.com/reference/tab_style.html#examples." Yes, supply a vector of columns or use tidyselect functions. 49:15 - "Excel output with {gt}? Would be a huge improvement. I often have to produce tabular output that can be easily reused. Usually it means Excel tables. So far I have mainly done this with Python and openpyxl or PyWin32 (through COM). A simple solution in R would be great." 50:20 - Support for additional output formats with {gt}? Excel, PowerPoint, etc.? 50:25 - {pointplank}, a package to methodically validate your data whether in the form of data frames or as database tables., https://rich-iannone.github.io/pointblank/. Check out the workshop materials at https://github.com/rich-iannone/pointblank-workshop 55:50 - "Are there ways to have grouped rows? I mean when repeated rows have same characters can we merge them to one?" 58:00 - "Is there an ability to add 'battleship coordinates' (e.g. column letters & row numbers) to a gt object? This is a standard for table across my org and I’ve been trying to figure out how to implement it." 59:59 "Do you have suggestions or examples of building out & applying corporate formatting to gt tables (e.g. adding a company logo, company colors, etc.)?" 01:04:30 - "With PDF/LaTeX output for wide tables, it does not shrink the table."

Rich Iannone

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

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

Barret Schloerke

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

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

Barret Schloerke

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

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

Barret Schloerke

Rich Iannone || New features in {gt} 0.6.0! || RStudio

00:00 Introduction 00:18 sub_missing() 03:51 Markdown formatting in sub_missing() 04:51 sub_zero() 07:34 sub_small_vals() 13:08 sub_large_vals() 16:25 final thoughts A new version of the R package {gt} has been released! We are now at version `0.6.0` and there are now even more features that'll make your display/summary tables look and work much, much better. Let's run through some of the bigger changes and see the benefits they can bring! New functions for substituting cell data We now have four new functions that allow you to make precise substitutions of cell values with perhaps something more meaningful. They all begin with `sub_` and that's short for substitution! sub_missing() (formerly known as fmt_missing()) Here's something that's both old and new. The sub_missing() function (for replacing NAs with... something) is new, but it's essentially replacing a function that is old (fmt_missing()). The missing_text replacement of "---" is actually an em dash (the longest of the dash family). This can be downgraded to an en dash with "--" or we can go further with "-", giving us a hyphen replacement. Or, you can use another piece of text. If you're using and loving fmt_missing(), it's okay! You'll probably receive a warning about it when you upgrade to {gt} 0.6.0 though. Best to just substitute fmt_missing() with sub_missing() anyway! sub_zero() The sub_zero() function allows for substituting zero values in the table body. sub_small_vals() Next up is the sub_small_vals() function. Ever have really, really small values and really just want to say they are small? With sub_small_vals() we can reformat smaller numbers using the default threshold of 0.01. Small and negative values can also be handled but they are handled specially by the sign parameter. Setting that to "-" will format only the small, negative values. You don't have to settle with the default threshold value or the default replacement pattern (in small_pattern). This can be changed and the "x" in small_pattern (which uses the threshold value) can even be omitted. sub_large_vals() Okay, there's one more substitution function to cover, and this one's for all the large values in your table: sub_large_vals(). With this you can substitute what you might consider as too large values in the table body. Large negative values can also be handled but they are handled specially by the sign parameter. Setting that to "-" will format only the large values that are negative. You don't have to settle with the default threshold value or the default replacement pattern (in large_pattern). This can be changed and the "x" in large_pattern (which uses the threshold value) can even be omitted. Final thoughts We are always trying to improve the gt package with a mix of big features (some examples: improving rendering, adding new families of functions) and numerous tiny features (like improving existing functions, clarifying documentation, etc.). It's hoped that the things delivered in gt 0.6.0 lead to improvements in how you create and present summary tables in R. If there are features you *really* want, always feel free to: File an issue: https://github.com/rstudio/gt/issues) Talk about your ideas on the Discussions page: https://github.com/rstudio/gt/discussions Learn more about the gt package here: https://gt.rstudio.com/ Got questions? The RStudio Community site is a great place to get assistance: https://community.rstudio.com/ Content: Rich Iannone (@riannone) Motion Design & editing: Jesse Mostipak Music: Nu Fornacis by Blue Dot Sessions https://app.sessions.blue/browse/track/98983

Rich Iannone

Rich Iannone || {gt} Intendo Game Data Project Walkthrough || RStudio

00:00 Introduction 00:11 Setting up our environment 01:21 Importing data 01:56 Data preparation using the tidyverse 14:12 Basic gt table 16:25 Specifying row order with row_group_order() 17:20 Formatting currency with fmt_currency() 18:10 Formatting missing values with fmt_missing() 18:55 Creating row groups with tab_options() 19:50 Relabel column names with cols_label() 20:41 Creating tab spanners with tab_spanner() 23:00 Creating a table title and subtitle with tab_header() 24:40 Aligning table title and subtitle with opt_align_table_header() 25:16 Creating a stubhead label with tab_stubhead() 26:00 Format all table cell text using tab_style() 27:25 Automatically format data color based on value using data_color() 30:45 Creating Markdown-friendly source notes using tab_source_note() 32:45 Creating Markdown-friendly footnotes using tab_footnote() 39:28 Adjust table column width using cols_width() 40:55 Adjust cell padding using opt_horizontal_padding() and opt_vertical_padding() 42:22 Change row group headers using tab_style() 43:40 Convert all table text to small caps using opt_all_caps() 43:58 Change all table text font using opt_table_font() 44:28 Changing table, table heading, footnotes, and source notes background color using tab_options() 46:41 Add a table "cap" at the top and bottom using table.border.top.width() and table.border.bottom.width() 47:23 Use multiline formatting with footnotes using footnotes.multiline() 47:34 Change line style using table_body.hlines.style() 47:55 Change table title and subtitle font sizes using heading.title.font.size() and heading.subtitle.font.size() 48:11 Checking out our final table! Code to recreate the table from the video: https://github.com/kierisi/rstudio_videos/blob/main/gt/rich-intendo-project-walkthrough/intendo-30032022.R Learn more about the gt package here: https://gt.rstudio.com/ Got questions? The RStudio Community site is a great place to get assistance: https://community.rstudio.com/ Content: Rich Iannone (@riannone) Motion design and editing: Jesse Mostipak (@kierisi) Music: Nu Fornacis by Blue Dot Sessions https://app.sessions.blue/browse/track/98983

Rich Iannone

James Blair || Getting Started with {plumbertableau} || RStudio

00:00 Introduction 01:19 Setting up the problem - capitalizing text with a custom function 02:18 Using Plumber to create an API for our function 04:08 Using Run API + Swagger from the RStudio IDE 05:44 Giving Tableau access to the function with PlumberTableau 09:16 Reviewing what we've done so far 09:47 Comparing results between Plumber and PlumberTableau 10:12 Overview of what PlumberTableau does 14:27 Centralized hosting with RStudio Connect 15:17 Looking at our API in RStudio Connect 18:14 How to access the deployed API from Tableau 21:03 Overview of RStudio Connect, Tableau, and PlumberTableau process 21:52 More in-depth example using sample sales data 22:36 Example with the Python equivalent of PlumberTableau, FastAPITableau 25:15 Overview of how these Tableau extension packages work 27:21 Setting up a connection between Tableau and RStudio Connect Read more about the plumbertableau package here: https://rstudio.github.io/plumbertableau/ And learn about the fastapitableau package here: https://rstudio.github.io/fastapitableau/ If you’re unfamiliar with Plumber, this Quickstart guide gives a good overview of the package: https://www.rplumber.io/articles/quickstart.html And you can learn more about Shiny here: https://shiny.rstudio.com/ Got questions? The RStudio Community site is a great place to get assistance: https://community.rstudio.com/ Content: James Blair (@Blair09M) Design and editing: Jesse Mostipak (@kierisi) Music: Borough by Blue Dot Sessions https://app.sessions.blue/browse/track/89821

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

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

Carson Sievert

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

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

Carson Sievert

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

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

Barret Schloerke

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

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

Nick Strayer

Barret Schloerke || {reactlog} Rundown || RStudio

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

Barret Schloerke

Daniel Petzold || RStudio Team: Building and Sharing Jupyter Notebooks || RStudio

Learn more about RStudio Team here. https://www.rstudio.com/products/team/ Find the code for this example here. https://github.com/danielpetzold/space-tracker Read our blog post here. https://www.rstudio.com/blog/build-and-share-jupyter-notebooks-on-rstudio-team/ Timecodes 0:00 - Intro 0:07 - Build Jupyter Notebooks to analyze and visualize data 2:47 - Publish directly from RStudio Workbench to your content hub 5:13 - Share With Your Stakeholders on RStudio Connect Jupyter Notebooks are interactive documents for code, outputs, and text. However, they’re often stuck in data scientists’ local computing environments. Collaborating can be difficult and sharing can be tedious. To live up to their fullest potential, data science teams need a way to scale their development securely and efficiently — while providing stakeholders easy access to their output and visualizations. RStudio Team, made up of RStudio Workbench, RStudio Connect, and RStudio Package Manager, brings everything together to help data scientists create, reproduce, and share insights from their Jupyter Notebooks. Let’s dive into a real-life example by exploring data from NASA’s Center for Near-Earth Objects (NEOs). Daniel Petzold walks us through his data analysis and reporting. Want to explore the report yourself? Check out the published report on RStudio Connect here. https://colorado.rstudio.com/rsc/space-tracker/space_tracker.html On RStudio Workbench, you have a choice of editors: the RStudio IDE, JupyterLab, Jupyter Notebook, or VS Code. Choose your preference. From here, you can explore your dataset, embed HTML directly in your document, create visualizations, and more. Once you've run your analyses and created insightful visualizations, you want to be able to share them with your team. RStudio Workbench allows you to publish to RStudio Connect, the content platform from RStudio. You have multiple options: push-button deployment from Jupyter Notebook or using terminal commands from JupyterLab. It’s not enough to publish your work. Once on RStudio Connect, you can share with end-users. Make your analysis accessible to specific users or more generally with different authentication measures. In addition, you can schedule the document to run at a certain time and send out an email with refreshed data. Click the links below to learn more about these offerings. RStudio Workbench: https://www.rstudio.com/products/workbench/ RStudio Connect: https://www.rstudio.com/products/connect/

RStudio Team

Rich Iannone || Making Beautiful Tables with {gt} || RStudio

00:00 Introduction 00:37 Adding a title with tab_header() (using Markdown!) 01:47 Adding a subtitle 02:48 Aligning table headers with opt_align_table_header() 03:48 Using {dplyr} with {gt} 06:03 Create a table stub with rowname_col() 07:35 Customizing column labels with col_label() 09:45 Formatting table numbers with fmt_number() 12:10 Adjusting column width with cols_width() 15:39 Adding source notes with tab_source_note() 16:55 Adding footnotes with tab_footnote() 18:55 Customizing footnote marks with opt_footnote_marks() 19:10 Demo of how easy managing multiple footnotes is with {gt} 23:41 Customizing cell styles with tab_style() 27:07 Adding label text to the stubhead with tab_stubhead() 28:15 Changing table font with opt_table_font() 29:25 Automatically scaling cell color based on value using data_color() With the gt package, anyone can make wonderful-looking tables using the R programming language. The gt philosophy: we can construct a wide variety of useful tables with a cohesive set of table parts. These include the table header, the stub, the column labels and spanner column labels, the table body, and the table footer. It all begins with table data (be it a tibble or a data frame). You then decide how to compose your gt table with the elements and formatting you need for the task at hand. Finally, the table is rendered by printing it at the console, including it in an R Markdown document, or exporting to a file using gtsave(). Currently, gt supports the HTML, LaTeX, and RTF output formats. The gt package is designed to be both straightforward yet powerful. The emphasis is on simple functions for the everyday display table needs. You can read more about gt here: https://gt.rstudio.com/articles/intro-creating-gt-tables.html And you can learn more about Shiny here: https://shiny.rstudio.com/ Got questions? The RStudio Community site is a great place to get assistance: https://community.rstudio.com/ Content: Rich Iannone (@riannone) Design & editing: Jesse Mostipak (@kierisi)

Rich Iannone

An inclusive solution for teaching and learning R during the COVID pandemic

The COVID pandemic has shaken our teaching and learning approaches in many different ways all over the world. Nonetheless, it has also provided opportunities for bringing creativity into the classroom. In this talk, I will discuss how I have used RStudio Cloud in my teaching during the pandemic and how I capitalized on the opportunities that RStudio Cloud offers to deal with the crucial issues of software installation. Introducing RStudio Cloud in the units has allowed me to work effectively in an online environment to engage, motivate and empower students through their learning process while removing the troubles and hurdles of software installation which is generally particularly challenging in first-year cohorts without prior coding experience. I used RStudio Cloud in a data science introductory unit at Monash University and as a tool to present the usage of R and RStudio for reproducible reporting in another unit on Reproducible and Collaborative Practises. In the latter, I introduced RStudio Cloud during the first few weeks to get the students up to speed before transitioning to using R and RStudio Cloud in their own local machines while using the command line interface, Git, and GitHub as a version control tool for reproducible reporting. I will also discuss how I organized and managed the unit's RStudio Cloud account so that my research associates were also an integral part of the unit delivery to ensure the success of the units. Read Dr. Menéndez's guest post on the RStudio Blog: https://www.rstudio.com/blog/rstudio-cloud-an-inclusive-solution-for-learning-r/ Read more in the follow-up blog post: https://www.rstudio.com/blog/teaching-data-science-in-the-cloud/

To Our Community: Thank You | RStudio Open Source (2021)

This year, among many challenges, we have been so grateful for our community who have continued to show up in so many different ways. As the year comes to a close, we wanted to say thank you. We know folks have adjusted where they spend their time and energy, and we just want to say thank you for continuing to be here and learn together, wherever you are right now. Thank you to our maintainers. Our package maintainers not only contribute code, but also steward projects, welcome new contributors, and answer many questions. Thank you for continuing to set a positive tone and fostering a positive community for our contributors and users! Thank you to our contributors. Package contributors contribute code, ideas, conversation, documentation, and tests. You are the ones trying things out, figuring out what’s wrong, and sharing ideas and fixes. Thank you for pushing our code to grow and evolve and to help ever more people! Thank you to our educators. Educators work in classrooms, with friends and colleagues, and respond to email lists from someone around the world. Thank you for sharing your enthusiasm for data science with others and expanding the group of people who make sense of data with code! Thank you to everyone who’s used R to solve a problem, create aRt, write a blog post, share insights or any of the thousands of ways we can create with R. Thank you to all of you who have contributed in some way, no matter how big or small. Without you, there would be no point to writing open source code. Thank you for all the work you do in the world, using data to improve our lives and our knowledge of the world in such incredibly diverse ways. Music: Basketliner by Bitters, published on Blue Dot Sessions - https://app.sessions.blue/browse/track/81258 Editing & motion design: Jesse Mostipak

Leveraging the Cloud for Analytics Instruction at Scale: Challenges and Opportunities

Data science and programming languages like R and Python are some of the most in demand skills in the world. Students interested in analytics and professors facilitating curriculums deserve to use industry-leading tools to acquire these skills. However, it’s challenging to enable this experience in an educational setting, especially at scale. The traditional tools to facilitate learning analytics simply aren’t great. Students and professors often spend way too much time troubleshooting systems and software, things that are a complete waste of time and detract from the learning experience. Additionally, there are seemingly endless IT hurdles and requirements. That’s part of the reason we created RStudio Cloud, a brilliantly simple but powerful solution for teaching and learning analytics, especially at scale. RStudio Cloud solves many of the technical and financial challenges associated with teaching analytics. It’s also a joy to use for professors, students, and IT administrators. In this presentation, Dr. Brian Anderson will discuss the challenges and opportunities associated with leveraging the cloud to deliver analytics instructions at the undergraduate and graduate levels at scale. Our hope is that you walk away inspired to think about ways you can leverage RStudio and the Cloud to enhance your students' experiences with learning analytics. Read more in the follow-up blog post: https://www.rstudio.com/blog/teaching-data-science-in-the-cloud/

RStudio Team Demo | Build & Share Data Products Like The World’s Leading Companies

You probably know that RStudio makes a free, open-source development environment for data scientists. It’s made with love and used by millions of people around the world. What you might not know is that we also make a professional platform, called RStudio Team. Learn How RStudio Team Can... - Help you scale your data science work - Seamlessly manage open-source data science environments - Automate repetitive tasks - And, rapidly share key insights and data science products securely to your entire organization. Timecodes 0:00 - Intro 4:18 - Hard truth of data science 10:22 - Serious Data Science 16:46 - Model management with R and Python 18:48 - Live Demo / RStudio Workbench 23:09 - RStudio support for Jupyter Notebooks 24:40 - Live Demo / RStudio Connect 28:01 - RStudio support for VS Code 30:05 - R and Python within RStudio 32:33 - Scale and share data science results 36:55 - Sharing previous versions of presentations 38:16 - Data Science team knowledge sharing 40:36 - Scheduling snd emailing data science content 43:55 - Live demo / RStudio Package Manager 48:09 - Data Science stories 49:37 - RStudio Team 52:59 - What makes RStudio different? 55:12 - Q/A - Learn More Leading organizations like NASA, Janssen Pharmaceuticals, The World Health Organization, financial institutions, government agencies and insurance organizations around the globe use RStudio’s professional products to tackle world-changing problems and we’re inviting you to learn how. You’ll learn how RStudio Team gives professional data science teams superpowers, with all of the bells and whistles that enterprises need. You can try RStudio Team free here: https://www.rstudio.com/products/team/evaluation2/ If you'd like to access presentation slides, sign up for future events, provide feedback and/or ask additional questions we've bundled everything together for you here: https://docs.google.com/document/d/1HGt7LSohhyxpCvETvVEFHugrdaSnTcZaXbI0jV5g9ok/edit?usp=sharing

RStudio Team

Teaching and learning with RStudio Cloud | RStudio

Learn about RStudio Cloud and most recent developments, particularly with respect to teaching with it. Slides are posted at https://rstd.io/tl-rscloud. ABOUT RSTUDIO CLOUD: RStudio Cloud is a lightweight, cloud-based solution that allows anyone to do, share, teach and learn data science online. Analyze your data using the RStudio IDE, directly from your browser. Share projects with your team, class, workshop or the world. Teach data science with R to your students or colleagues. Learn data science in an instructor-led environment or with interactive tutorials. There is nothing to configure and no dedicated hardware, installation or annual purchase contract required. Individual users, instructors and students only need a browser to do, share, teach and learn data science. We will always offer a free plan for casual, individual use, and we now offer paid premium plans for professionals, instructors, researchers, and organizations. RSTUDIO CLOUD RESOURCES: RStudio Cloud https://rstudio.cloud RStudio Cloud Pricing plans https://rstudio.cloud/plans/instructor RStudio Cloud guide https://rstudio.cloud/learn/guide {rscloud} https://github.com/rstudio/rscloud ### ABOUT RSTUDIO: RStudio’s mission is to create free and open-source software for data science, scientific research, and technical communication to enhance the production and consumption of knowledge by everyone, regardless of economic means, and to facilitate collaboration and reproducible research, both of which are critical to the integrity and efficacy of work across industries. RStudio also produces RStudio Team, a modular platform of commercial software products that give organizations the confidence to adopt R, Python and other open-source data science software at scale, along with online services to make it easier to learn and use them over the web. Together, RStudio’s open-source software and commercial software form a virtuous cycle: the adoption of open-source data science software at scale in organizations creates demand for RStudio’s commercial software; and the revenue from commercial software, in turn, enables deeper investment in the open-source software that benefits everyone. Check out www.rstudio.com Follow us on Twitter: https://twitter.com/rstudio Facebook: https://www.facebook.com/rstudiopbc/ And LinkedIn: https://www.linkedin.com/company/rstudio-pbc/

RStudio Team

Data Science Hangout | Frank Corrigan, Target | Understanding the Impact of Data Science

We want to help data science leaders become better. The Data Science Hangout is a weekly, free-to-join open conversation for current and aspiring data science leaders. An accomplished leader in the space will join us each week and answer whatever questions the audience may have. We were recently joined by Frank Corrigan, Director of Decision Intelligence at Target. 6:38 - Problem formation - trying to find the unknown unknowns and bringing them to the business 8:20 - Integrating your data science team into your company's business objectives (ex. newsletter) 10:50 - What is the divide between a business analyst and a data scientist, in your eyes? How business analysts and data scientists differ 15:32 - What is the biggest mistake you’ve made in your role and what did you learn from this mistake? 19:15 - Onboarding new team members effectively 25:00 - The importance of motivating non-data scientists 26:42 - Resources for data scientists 32:30 - Challenges when using different tools across a data science team 49:28 - Analytical thinking vs critical thinking skills 57:30 - Embracing the 80/20 Rule & the importance of Focus Time 1:02:48 - Two frameworks to be more effective with stakeholders 1:06:47 - Rebranding to "decision intelligence" 1:08:35 - Quantitatively measuring impact from data science insights ► Subscribe to Our Channel Here: https://bit.ly/2TzgcOu ► Join the Data Science Hangout Live every Thursday from 12-1 ET: https://www.addevent.com/event/Qv9211919 Follow Us Here: Website: https://www.rstudio.com LinkedIn: https://www.linkedin.com/company/rstudio-pbc Twitter: https://twitter.com/rstudio

RStudio Cloud | Viewing Learning Work | Instructor View

As an Admin (or Moderator) of your course space, you and your fellow instructors have access to all projects in your space. You can open student projects from any projects listing, or to see all the projects of a given student, go to their profile page by clicking on their name from the Members page. Note that if you do open a student's project while they also have it open, they will be temporarily disconnected from the project. You can also view how much time your students have spent using Cloud. Simply visit the Usage area of your space, where you can see aggregate usage data for the entire class, or for an individual student and their projects. ABOUT RSTUDIO CLOUD: RStudio Cloud is a lightweight, cloud-based solution that allows anyone to do, share, teach and learn data science online. Analyze your data using the RStudio IDE, directly from your browser. Share projects with your team, class, workshop or the world. Teach data science with R to your students or colleagues. Learn data science in an instructor-led environment or with interactive tutorials. There is nothing to configure and no dedicated hardware, installation or annual purchase contract required. Individual users, instructors and students only need a browser to do, share, teach and learn data science. We will always offer a free plan for casual, individual use, and we now offer paid premium plans for professionals, instructors, researchers, and organizations. RSTUDIO CLOUD RESOURCES: RStudio Cloud https://rstudio.cloud RStudio Cloud Pricing plans https://rstudio.cloud/plans/instructor RStudio Cloud guide https://rstudio.cloud/learn/guide {rscloud} https://github.com/rstudio/rscloud VIDEO CREDITS: Monitor icon made by xnimrodx from flaticon.com Cloud icon made by Freepik from flaticon.com Tiny Putty Music from Blue Dot Sessions: https://app.sessions.blue/browse/track/52046 ### ABOUT RSTUDIO: RStudio’s mission is to create free and open-source software for data science, scientific research, and technical communication to enhance the production and consumption of knowledge by everyone, regardless of economic means, and to facilitate collaboration and reproducible research, both of which are critical to the integrity and efficacy of work across industries. RStudio also produces RStudio Team, a modular platform of commercial software products that give organizations the confidence to adopt R, Python and other open-source data science software at scale, along with online services to make it easier to learn and use them over the web. Together, RStudio’s open-source software and commercial software form a virtuous cycle: the adoption of open-source data science software at scale in organizations creates demand for RStudio’s commercial software; and the revenue from commercial software, in turn, enables deeper investment in the open-source software that benefits everyone. Check out www.rstudio.com Follow us on Twitter: https://twitter.com/rstudio Facebook: https://www.facebook.com/rstudiopbc/ And LinkedIn: https://www.linkedin.com/company/rstudio-pbc/

RStudio Team

RStudio Cloud | Tuning Resources | Instructor View

By default, each project is allocated 1 GB of RAM and 1 CPU, and can execute in the background for up to 1 hour. If your plan allows it, you can increase the memory, CPU or background execution time allocated to a project. To do so, open Project settings, go to the Resources panel and adjust the allocation. Note that copies of a project will inherit its resource settings. However, the effective allocation for the copy will be limited by the maxiumum allowed by the account that "owns" the new copy. The usage hours consumed by a project in a given amount of time depend on the resources allocated to the project, according to the following formula: (RAM + CPUs allocated) / 2 x hours. On disk, each project is allocated up to 20GB for its files, data, and packages. The maximum size of a file that can be uploaded to a project is 500MB. ABOUT RSTUDIO CLOUD: RStudio Cloud is a lightweight, cloud-based solution that allows anyone to do, share, teach and learn data science online. Analyze your data using the RStudio IDE, directly from your browser. Share projects with your team, class, workshop or the world. Teach data science with R to your students or colleagues. Learn data science in an instructor-led environment or with interactive tutorials. There is nothing to configure and no dedicated hardware, installation or annual purchase contract required. Individual users, instructors and students only need a browser to do, share, teach and learn data science. We will always offer a free plan for casual, individual use, and we now offer paid premium plans for professionals, instructors, researchers, and organizations. RSTUDIO CLOUD RESOURCES: RStudio Cloud https://rstudio.cloud RStudio Cloud Pricing plans https://rstudio.cloud/plans/instructor RStudio Cloud guide https://rstudio.cloud/learn/guide {rscloud} https://github.com/rstudio/rscloud VIDEO CREDITS: Monitor icon made by xnimrodx from flaticon.com Cloud icon made by Freepik from flaticon.com Tiny Putty Music from Blue Dot Sessions: https://app.sessions.blue/browse/track/52046 ### ABOUT RSTUDIO: RStudio’s mission is to create free and open-source software for data science, scientific research, and technical communication to enhance the production and consumption of knowledge by everyone, regardless of economic means, and to facilitate collaboration and reproducible research, both of which are critical to the integrity and efficacy of work across industries. RStudio also produces RStudio Team, a modular platform of commercial software products that give organizations the confidence to adopt R, Python and other open-source data science software at scale, along with online services to make it easier to learn and use them over the web. Together, RStudio’s open-source software and commercial software form a virtuous cycle: the adoption of open-source data science software at scale in organizations creates demand for RStudio’s commercial software; and the revenue from commercial software, in turn, enables deeper investment in the open-source software that benefits everyone. Check out www.rstudio.com Follow us on Twitter: https://twitter.com/rstudio Facebook: https://www.facebook.com/rstudiopbc/ And LinkedIn: https://www.linkedin.com/company/rstudio-pbc/

RStudio Team

RStudio Cloud | Troubleshooting | Instructor View

Relaunch Project If you are working on a project, and it fails to load or becomes completely unresponsive, you can relaunch the project. Depending on the underlying problem, relaunching the project may fix it and let you continue. Allocate Additional Memory memory-gaugeRunning out of memory while working on a project may be the cause of a variety of errors. The project memory gauge will give you an idea of what percentage of available memory your project is currently using. The gauge updates roughly every ten seconds, so it may not show the exact usage at the current moment. Note that reclaiming unused memory is controlled by R and the operating system - you may see uncanny fluctuations in the gauge as the system manages memory. ABOUT RSTUDIO CLOUD: RStudio Cloud is a lightweight, cloud-based solution that allows anyone to do, share, teach and learn data science online. Analyze your data using the RStudio IDE, directly from your browser. Share projects with your team, class, workshop or the world. Teach data science with R to your students or colleagues. Learn data science in an instructor-led environment or with interactive tutorials. There is nothing to configure and no dedicated hardware, installation or annual purchase contract required. Individual users, instructors and students only need a browser to do, share, teach and learn data science. We will always offer a free plan for casual, individual use, and we now offer paid premium plans for professionals, instructors, researchers, and organizations. RSTUDIO CLOUD RESOURCES: RStudio Cloud https://rstudio.cloud RStudio Cloud Pricing plans https://rstudio.cloud/plans/instructor RStudio Cloud guide https://rstudio.cloud/learn/guide {rscloud} https://github.com/rstudio/rscloud VIDEO CREDITS: Monitor icon made by xnimrodx from flaticon.com Cloud icon made by Freepik from flaticon.com Tiny Putty Music from Blue Dot Sessions: https://app.sessions.blue/browse/track/52046 ### ABOUT RSTUDIO: RStudio’s mission is to create free and open-source software for data science, scientific research, and technical communication to enhance the production and consumption of knowledge by everyone, regardless of economic means, and to facilitate collaboration and reproducible research, both of which are critical to the integrity and efficacy of work across industries. RStudio also produces RStudio Team, a modular platform of commercial software products that give organizations the confidence to adopt R, Python and other open-source data science software at scale, along with online services to make it easier to learn and use them over the web. Together, RStudio’s open-source software and commercial software form a virtuous cycle: the adoption of open-source data science software at scale in organizations creates demand for RStudio’s commercial software; and the revenue from commercial software, in turn, enables deeper investment in the open-source software that benefits everyone. Check out www.rstudio.com Follow us on Twitter: https://twitter.com/rstudio Facebook: https://www.facebook.com/rstudiopbc/ And LinkedIn: https://www.linkedin.com/company/rstudio-pbc/

RStudio Team

RStudio Cloud | Setting Up a Base Project | Instructor View

You can make all projects in a space begin with a default set of files and packages. You do this by defining a Base Project for the space. Create a new project and add any packages or files you want all projects created in the space to start with. Set the project's access so that everyone in the space can view the project. Go to the Space Settings page and select the project as the Base Project. Once you select a project as your Base Project, it will no longer be included in the projects listing for the space. To access it, choose the Edit command from the Space Settings page. Changes to the Base Project are not retroactive. Changes will not be applied to any projects already created - the changes will only apply to future projects created via the New Project action. ABOUT RSTUDIO CLOUD: RStudio Cloud is a lightweight, cloud-based solution that allows anyone to do, share, teach and learn data science online. Analyze your data using the RStudio IDE, directly from your browser. Share projects with your team, class, workshop or the world. Teach data science with R to your students or colleagues. Learn data science in an instructor-led environment or with interactive tutorials. There is nothing to configure and no dedicated hardware, installation or annual purchase contract required. Individual users, instructors and students only need a browser to do, share, teach and learn data science. We will always offer a free plan for casual, individual use, and we now offer paid premium plans for professionals, instructors, researchers, and organizations. RSTUDIO CLOUD RESOURCES: RStudio Cloud https://rstudio.cloud RStudio Cloud Pricing plans https://rstudio.cloud/plans/instructor RStudio Cloud guide https://rstudio.cloud/learn/guide {rscloud} https://github.com/rstudio/rscloud VIDEO CREDITS: Monitor icon made by xnimrodx from flaticon.com Cloud icon made by Freepik from flaticon.com Tiny Putty Music from Blue Dot Sessions: https://app.sessions.blue/browse/track/52046 ### ABOUT RSTUDIO: RStudio’s mission is to create free and open-source software for data science, scientific research, and technical communication to enhance the production and consumption of knowledge by everyone, regardless of economic means, and to facilitate collaboration and reproducible research, both of which are critical to the integrity and efficacy of work across industries. RStudio also produces RStudio Team, a modular platform of commercial software products that give organizations the confidence to adopt R, Python and other open-source data science software at scale, along with online services to make it easier to learn and use them over the web. Together, RStudio’s open-source software and commercial software form a virtuous cycle: the adoption of open-source data science software at scale in organizations creates demand for RStudio’s commercial software; and the revenue from commercial software, in turn, enables deeper investment in the open-source software that benefits everyone. Check out www.rstudio.com Follow us on Twitter: https://twitter.com/rstudio Facebook: https://www.facebook.com/rstudiopbc/ And LinkedIn: https://www.linkedin.com/company/rstudio-pbc/

RStudio Team

RStudio Cloud | Roles | Instructor View

Each member of a space is assigned a role to determine what they are able to do within the space. The available roles are: Admin: can manage users, view, edit and manage all projects and view space usage data. Moderator: can view, edit and manage all projects, and view space usage data. Contributor: can create, edit and manage their own projects. This is the default. Viewer: can view projects shared with everyone in the space. A viewer cannot create or save copies of projects. Members are assigned an initial role when they are invited to or join a space, but roles can be changed by an Admin at any time. When you invite an individual member to a Invitation Required space, you set the initial role in the Add Member dialog box. When someone joins via a sharing link, their initial role is set to the current Initial Role setting in the members options panel. Admins can update a user’s role via the role selector in the members list. Changing permissions lets you fine-tune the Contributor and Viewer roles. The permissions are: Contributors can see the members list: enables Contributors to see who can access the space. Contributors can make their projects visible to all members: enables Contributors to share their projects with everyone in the space. Contributors can change project resources: enables Contributors to change RAM and CPU settings on their projects. Viewers can see the members list: enables Viewers to see who can acess the space. ABOUT RSTUDIO CLOUD: RStudio Cloud is a lightweight, cloud-based solution that allows anyone to do, share, teach and learn data science online. Analyze your data using the RStudio IDE, directly from your browser. Share projects with your team, class, workshop or the world. Teach data science with R to your students or colleagues. Learn data science in an instructor-led environment or with interactive tutorials. There is nothing to configure and no dedicated hardware, installation or annual purchase contract required. Individual users, instructors and students only need a browser to do, share, teach and learn data science. We will always offer a free plan for casual, individual use, and we now offer paid premium plans for professionals, instructors, researchers, and organizations. RSTUDIO CLOUD RESOURCES: RStudio Cloud https://rstudio.cloud RStudio Cloud Pricing plans https://rstudio.cloud/plans/instructor RStudio Cloud guide https://rstudio.cloud/learn/guide {rscloud} https://github.com/rstudio/rscloud VIDEO CREDITS: Monitor icon made by xnimrodx from flaticon.com Cloud icon made by Freepik from flaticon.com Tiny Putty Music from Blue Dot Sessions: https://app.sessions.blue/browse/track/52046 ### ABOUT RSTUDIO: RStudio’s mission is to create free and open-source software for data science, scientific research, and technical communication to enhance the production and consumption of knowledge by everyone, regardless of economic means, and to facilitate collaboration and reproducible research, both of which are critical to the integrity and efficacy of work across industries. RStudio also produces RStudio Team, a modular platform of commercial software products that give organizations the confidence to adopt R, Python and other open-source data science software at scale, along with online services to make it easier to learn and use them over the web. Together, RStudio’s open-source software and commercial software form a virtuous cycle: the adoption of open-source data science software at scale in organizations creates demand for RStudio’s commercial software; and the revenue from commercial software, in turn, enables deeper investment in the open-source software that benefits everyone. Check out www.rstudio.com Follow us on Twitter: https://twitter.com/rstudio Facebook: https://www.facebook.com/rstudiopbc/ And LinkedIn: https://www.linkedin.com/company/rstudio-pbc/

RStudio Team

RStudio Cloud | Reusing a Workspace | Instructor View

One approach to reusing a space is to remove the current cohort of students from the space, and reuse the same space with the next cohort. If you are an Admin of a space, you can remove any member from that space. Go to the Members area of the space. For the member you would like to remove, press the Delete icon. You will be prompted to confirm that you would like to remove them from the space, and to choose whether to leave their projects behind in the space, or move them to their personal space. You can also remove members programatically via the Cloud API using the rscloud package. Another option is to create a new space from your current course space using the Copy Space action. If you'd like to re-use materials from a space, e.g. to teach a new cohort of students, use the Copy Space command. All projects shared with everyone in the original space will be copied over to the new space. Members of the original space are not copied over - you will be the only initial member of the new space. ABOUT RSTUDIO CLOUD: RStudio Cloud is a lightweight, cloud-based solution that allows anyone to do, share, teach and learn data science online. Analyze your data using the RStudio IDE, directly from your browser. Share projects with your team, class, workshop or the world. Teach data science with R to your students or colleagues. Learn data science in an instructor-led environment or with interactive tutorials. There is nothing to configure and no dedicated hardware, installation or annual purchase contract required. Individual users, instructors and students only need a browser to do, share, teach and learn data science. We will always offer a free plan for casual, individual use, and we now offer paid premium plans for professionals, instructors, researchers, and organizations. RSTUDIO CLOUD RESOURCES: RStudio Cloud https://rstudio.cloud RStudio Cloud Pricing plans https://rstudio.cloud/plans/instructor RStudio Cloud guide https://rstudio.cloud/learn/guide {rscloud} https://github.com/rstudio/rscloud VIDEO CREDITS: Monitor icon made by xnimrodx from flaticon.com Cloud icon made by Freepik from flaticon.com Tiny Putty Music from Blue Dot Sessions: https://app.sessions.blue/browse/track/52046 ### ABOUT RSTUDIO: RStudio’s mission is to create free and open-source software for data science, scientific research, and technical communication to enhance the production and consumption of knowledge by everyone, regardless of economic means, and to facilitate collaboration and reproducible research, both of which are critical to the integrity and efficacy of work across industries. RStudio also produces RStudio Team, a modular platform of commercial software products that give organizations the confidence to adopt R, Python and other open-source data science software at scale, along with online services to make it easier to learn and use them over the web. Together, RStudio’s open-source software and commercial software form a virtuous cycle: the adoption of open-source data science software at scale in organizations creates demand for RStudio’s commercial software; and the revenue from commercial software, in turn, enables deeper investment in the open-source software that benefits everyone. Check out www.rstudio.com Follow us on Twitter: https://twitter.com/rstudio Facebook: https://www.facebook.com/rstudiopbc/ And LinkedIn: https://www.linkedin.com/company/rstudio-pbc/

RStudio Team

RStudio Cloud | Project Types | Instructor View

A project is the fundamental unit of work on RStudio Cloud. It encapsulates your R code, packages and data files and provides isolation from other analyses. If you are familiar with projects in the desktop RStudio IDE, an RStudio Cloud project is the same thing, plus some additional metadata for access and sharing. To create a new project from scratch, simply press the New Project button from the Projects area. Your new project will open in the RStudio IDE. To create a new project from an existing git repository, press the down arrow on the right side of the New Project button, and choose ‘New Project from Git Repo’ from the menu that appears. Note that your git credentials need to be entered each time you create a new project and are only cached for 15 minutes by default. To create a Jupyter Project, press the down arrow on the right side of the New Project button, and choose ‘New Jupyter Project’ from the menu that appears. A new Jupyter project will be created and deployed. Once deployed, you will see the Jupyter hub tree view with a welcome.ipynb notebook that contains information about getting started with Jupyter. ABOUT RSTUDIO CLOUD: RStudio Cloud is a lightweight, cloud-based solution that allows anyone to do, share, teach and learn data science online. Analyze your data using the RStudio IDE, directly from your browser. Share projects with your team, class, workshop or the world. Teach data science with R to your students or colleagues. Learn data science in an instructor-led environment or with interactive tutorials. There is nothing to configure and no dedicated hardware, installation or annual purchase contract required. Individual users, instructors and students only need a browser to do, share, teach and learn data science. We will always offer a free plan for casual, individual use, and we now offer paid premium plans for professionals, instructors, researchers, and organizations. RSTUDIO CLOUD RESOURCES: RStudio Cloud https://rstudio.cloud RStudio Cloud Pricing plans https://rstudio.cloud/plans/instructor RStudio Cloud guide https://rstudio.cloud/learn/guide {rscloud} https://github.com/rstudio/rscloud VIDEO CREDITS: Monitor icon made by xnimrodx from flaticon.com Cloud icon made by Freepik from flaticon.com Tiny Putty Music from Blue Dot Sessions: https://app.sessions.blue/browse/track/52046 ### ABOUT RSTUDIO: RStudio’s mission is to create free and open-source software for data science, scientific research, and technical communication to enhance the production and consumption of knowledge by everyone, regardless of economic means, and to facilitate collaboration and reproducible research, both of which are critical to the integrity and efficacy of work across industries. RStudio also produces RStudio Team, a modular platform of commercial software products that give organizations the confidence to adopt R, Python and other open-source data science software at scale, along with online services to make it easier to learn and use them over the web. Together, RStudio’s open-source software and commercial software form a virtuous cycle: the adoption of open-source data science software at scale in organizations creates demand for RStudio’s commercial software; and the revenue from commercial software, in turn, enables deeper investment in the open-source software that benefits everyone. Check out www.rstudio.com Follow us on Twitter: https://twitter.com/rstudio Facebook: https://www.facebook.com/rstudiopbc/ And LinkedIn: https://www.linkedin.com/company/rstudio-pbc/

RStudio Team

RStudio Cloud | Overview | Instructor View

ABOUT RSTUDIO CLOUD: RStudio Cloud is a lightweight, cloud-based solution that allows anyone to do, share, teach and learn data science online. Analyze your data using the RStudio IDE, directly from your browser. Share projects with your team, class, workshop or the world. Teach data science with R to your students or colleagues. Learn data science in an instructor-led environment or with interactive tutorials. There is nothing to configure and no dedicated hardware, installation or annual purchase contract required. Individual users, instructors and students only need a browser to do, share, teach and learn data science. We will always offer a free plan for casual, individual use, and we now offer paid premium plans for professionals, instructors, researchers, and organizations. RSTUDIO CLOUD RESOURCES: RStudio Cloud https://rstudio.cloud RStudio Cloud Pricing plans https://rstudio.cloud/plans/instructor RStudio Cloud guide https://rstudio.cloud/learn/guide {rscloud} https://github.com/rstudio/rscloud VIDEO CREDITS: Monitor icon made by xnimrodx from flaticon.com Cloud icon made by Freepik from flaticon.com Tiny Putty Music from Blue Dot Sessions: https://app.sessions.blue/browse/track/52046 ### ABOUT RSTUDIO: RStudio’s mission is to create free and open-source software for data science, scientific research, and technical communication to enhance the production and consumption of knowledge by everyone, regardless of economic means, and to facilitate collaboration and reproducible research, both of which are critical to the integrity and efficacy of work across industries. RStudio also produces RStudio Team, a modular platform of commercial software products that give organizations the confidence to adopt R, Python and other open-source data science software at scale, along with online services to make it easier to learn and use them over the web. Together, RStudio’s open-source software and commercial software form a virtuous cycle: the adoption of open-source data science software at scale in organizations creates demand for RStudio’s commercial software; and the revenue from commercial software, in turn, enables deeper investment in the open-source software that benefits everyone. Check out www.rstudio.com Follow us on Twitter: https://twitter.com/rstudio Facebook: https://www.facebook.com/rstudiopbc/ And LinkedIn: https://www.linkedin.com/company/rstudio-pbc/

RStudio Team

RStudio Cloud | Inviting Co-instructors and Teaching Assistants | Instructor View

After creating a space, go to the Members area to manage its membership. You can add members to your space in three ways: To add members one by one, choose the Invitation Required option, and send invitations to each person you’d like to add to the space via the Add Member button. Note that for security reasons, the invitation is good for 7 days from the time that it is sent. To allow many people to join the space, choose the Sharing Link option, copy the sharing link and then share that link with all the people you’d like to join the space, either via an email or by posting the link on a web page. Keep in mind that anyone with that link will be able to join your space. If you would like to disable a link you previously shared, choose Reset Sharing Link; this will prevent any additional people from joining the space using that link. Space membership can also be managed programatically. See API Access from R in the Advanced Topics section below for details. Note that you can switch the access option at any time - a common approach is to initially set the access option to Sharing Link, post the sharing link, then after all the people you want to join the space initially have done so, switch access to Invitation Only. The original sharing link will no longer allow additional people to join the space, but you can add any new members individually. ABOUT RSTUDIO CLOUD: RStudio Cloud is a lightweight, cloud-based solution that allows anyone to do, share, teach and learn data science online. Analyze your data using the RStudio IDE, directly from your browser. Share projects with your team, class, workshop or the world. Teach data science with R to your students or colleagues. Learn data science in an instructor-led environment or with interactive tutorials. There is nothing to configure and no dedicated hardware, installation or annual purchase contract required. Individual users, instructors and students only need a browser to do, share, teach and learn data science. We will always offer a free plan for casual, individual use, and we now offer paid premium plans for professionals, instructors, researchers, and organizations. RSTUDIO CLOUD RESOURCES: RStudio Cloud https://rstudio.cloud RStudio Cloud Pricing plans https://rstudio.cloud/plans/instructor RStudio Cloud guide https://rstudio.cloud/learn/guide {rscloud} https://github.com/rstudio/rscloud VIDEO CREDITS: Monitor icon made by xnimrodx from flaticon.com Cloud icon made by Freepik from flaticon.com Tiny Putty Music from Blue Dot Sessions: https://app.sessions.blue/browse/track/52046 ### ABOUT RSTUDIO: RStudio’s mission is to create free and open-source software for data science, scientific research, and technical communication to enhance the production and consumption of knowledge by everyone, regardless of economic means, and to facilitate collaboration and reproducible research, both of which are critical to the integrity and efficacy of work across industries. RStudio also produces RStudio Team, a modular platform of commercial software products that give organizations the confidence to adopt R, Python and other open-source data science software at scale, along with online services to make it easier to learn and use them over the web. Together, RStudio’s open-source software and commercial software form a virtuous cycle: the adoption of open-source data science software at scale in organizations creates demand for RStudio’s commercial software; and the revenue from commercial software, in turn, enables deeper investment in the open-source software that benefits everyone. Check out www.rstudio.com Follow us on Twitter: https://twitter.com/rstudio Facebook: https://www.facebook.com/rstudiopbc/ And LinkedIn: https://www.linkedin.com/company/rstudio-pbc/

RStudio Team

RStudio Cloud | Invite Learners | Instructor View

As you did to invite your co-instructors, go to the space's Members area to invite your students to your course space. The easiest approach is to enable access via a sharing link. - Click on the Sharing link option in the Access section - Set the Initial Role to Contributor - Click on the Copy Sharing Link action You can then distribute the sharing link to all your students via a course web page or email. Once all your students have joined the space, you can either reset the sharing link (which will disable access via the previous sharing link), or set Access to "Invitation Required" to ensure that nobody joins the class later without your permission. See the Members section in Shared Spaces above for more details and alternate methods for adding students to your space. Note that each student must have their own RStudio Cloud account. When they attempt to access your course space for the first time, they will be prompted to log in, or to sign up for an account if they don't already have one. If your organization is using SSO, account creation will happen automatically when they log in the first time. At this point, you and your students should be all set. ABOUT RSTUDIO CLOUD: RStudio Cloud is a lightweight, cloud-based solution that allows anyone to do, share, teach and learn data science online. Analyze your data using the RStudio IDE, directly from your browser. Share projects with your team, class, workshop or the world. Teach data science with R to your students or colleagues. Learn data science in an instructor-led environment or with interactive tutorials. There is nothing to configure and no dedicated hardware, installation or annual purchase contract required. Individual users, instructors and students only need a browser to do, share, teach and learn data science. We will always offer a free plan for casual, individual use, and we now offer paid premium plans for professionals, instructors, researchers, and organizations. RSTUDIO CLOUD RESOURCES: RStudio Cloud https://rstudio.cloud RStudio Cloud Pricing plans https://rstudio.cloud/plans/instructor RStudio Cloud guide https://rstudio.cloud/learn/guide {rscloud} https://github.com/rstudio/rscloud VIDEO CREDITS: Monitor icon made by xnimrodx from flaticon.com Cloud icon made by Freepik from flaticon.com Tiny Putty Music from Blue Dot Sessions: https://app.sessions.blue/browse/track/52046 ### ABOUT RSTUDIO: RStudio’s mission is to create free and open-source software for data science, scientific research, and technical communication to enhance the production and consumption of knowledge by everyone, regardless of economic means, and to facilitate collaboration and reproducible research, both of which are critical to the integrity and efficacy of work across industries. RStudio also produces RStudio Team, a modular platform of commercial software products that give organizations the confidence to adopt R, Python and other open-source data science software at scale, along with online services to make it easier to learn and use them over the web. Together, RStudio’s open-source software and commercial software form a virtuous cycle: the adoption of open-source data science software at scale in organizations creates demand for RStudio’s commercial software; and the revenue from commercial software, in turn, enables deeper investment in the open-source software that benefits everyone. Check out www.rstudio.com Follow us on Twitter: https://twitter.com/rstudio Facebook: https://www.facebook.com/rstudiopbc/ And LinkedIn: https://www.linkedin.com/company/rstudio-pbc/

RStudio Team

RStudio Cloud | Exporting Projects | Instructor View

The contents of a project can be downloaded without opening the project. Press the Export action to the right of the project that you wish to download. A dialog box will appear showing the progress of your export. The process can take anywhere from a few seconds to a couple of minutes, depending on the size of the project, and how recently it was opened. Once the export is complete, press the Download button in the dialog box to download your project. ABOUT RSTUDIO CLOUD: RStudio Cloud is a lightweight, cloud-based solution that allows anyone to do, share, teach and learn data science online. Analyze your data using the RStudio IDE, directly from your browser. Share projects with your team, class, workshop or the world. Teach data science with R to your students or colleagues. Learn data science in an instructor-led environment or with interactive tutorials. There is nothing to configure and no dedicated hardware, installation or annual purchase contract required. Individual users, instructors and students only need a browser to do, share, teach and learn data science. We will always offer a free plan for casual, individual use, and we now offer paid premium plans for professionals, instructors, researchers, and organizations. RSTUDIO CLOUD RESOURCES: RStudio Cloud https://rstudio.cloud RStudio Cloud Pricing plans https://rstudio.cloud/plans/instructor RStudio Cloud guide https://rstudio.cloud/learn/guide {rscloud} https://github.com/rstudio/rscloud VIDEO CREDITS: Monitor icon made by xnimrodx from flaticon.com Cloud icon made by Freepik from flaticon.com Tiny Putty Music from Blue Dot Sessions: https://app.sessions.blue/browse/track/52046 ### ABOUT RSTUDIO: RStudio’s mission is to create free and open-source software for data science, scientific research, and technical communication to enhance the production and consumption of knowledge by everyone, regardless of economic means, and to facilitate collaboration and reproducible research, both of which are critical to the integrity and efficacy of work across industries. RStudio also produces RStudio Team, a modular platform of commercial software products that give organizations the confidence to adopt R, Python and other open-source data science software at scale, along with online services to make it easier to learn and use them over the web. Together, RStudio’s open-source software and commercial software form a virtuous cycle: the adoption of open-source data science software at scale in organizations creates demand for RStudio’s commercial software; and the revenue from commercial software, in turn, enables deeper investment in the open-source software that benefits everyone. Check out www.rstudio.com Follow us on Twitter: https://twitter.com/rstudio Facebook: https://www.facebook.com/rstudiopbc/ And LinkedIn: https://www.linkedin.com/company/rstudio-pbc/

RStudio Team

RStudio Cloud | Creating an Assignment | Instructor View

A good way to create assignments for your students is to make a project for each assignment, and populate it with the files and packages you would like each student to have when they begin the assignment. When you are ready to reveal an assignment to your students, open the project and do the following: - Click on the Project Settings button (the gear in the upper right) - Select the Access panel - Set the project access so it can be viewed by everyone in the space - Check "Make this project an assignment" When the student opens an assignment project (either via the projects listing, or via a direct link to the project), RStudio Cloud will automatically make a copy for them. To convey this special behavior, assignments are displayed a bit differently, both for you and for your students. You can see the students’ copies of the assignment by clicking on the "View n derived projects" link that will appear with your original project. Note that changes you make to the original assignment will not be applied to any student copies already created. The changes will only apply to future copies of the assignment. ABOUT RSTUDIO CLOUD: RStudio Cloud is a lightweight, cloud-based solution that allows anyone to do, share, teach and learn data science online. Analyze your data using the RStudio IDE, directly from your browser. Share projects with your team, class, workshop or the world. Teach data science with R to your students or colleagues. Learn data science in an instructor-led environment or with interactive tutorials. There is nothing to configure and no dedicated hardware, installation or annual purchase contract required. Individual users, instructors and students only need a browser to do, share, teach and learn data science. We will always offer a free plan for casual, individual use, and we now offer paid premium plans for professionals, instructors, researchers, and organizations. RSTUDIO CLOUD RESOURCES: RStudio Cloud https://rstudio.cloud RStudio Cloud Pricing plans https://rstudio.cloud/plans/instructor RStudio Cloud guide https://rstudio.cloud/learn/guide {rscloud} https://github.com/rstudio/rscloud VIDEO CREDITS: Monitor icon made by xnimrodx from flaticon.com Cloud icon made by Freepik from flaticon.com Tiny Putty Music from Blue Dot Sessions: https://app.sessions.blue/browse/track/52046 ### ABOUT RSTUDIO: RStudio’s mission is to create free and open-source software for data science, scientific research, and technical communication to enhance the production and consumption of knowledge by everyone, regardless of economic means, and to facilitate collaboration and reproducible research, both of which are critical to the integrity and efficacy of work across industries. RStudio also produces RStudio Team, a modular platform of commercial software products that give organizations the confidence to adopt R, Python and other open-source data science software at scale, along with online services to make it easier to learn and use them over the web. Together, RStudio’s open-source software and commercial software form a virtuous cycle: the adoption of open-source data science software at scale in organizations creates demand for RStudio’s commercial software; and the revenue from commercial software, in turn, enables deeper investment in the open-source software that benefits everyone. Check out www.rstudio.com Follow us on Twitter: https://twitter.com/rstudio Facebook: https://www.facebook.com/rstudiopbc/ And LinkedIn: https://www.linkedin.com/company/rstudio-pbc/

RStudio Team

RStudio Cloud | {rscloud} Package | Instructor View

You can access RStudio Cloud's API to manage space members programatically using the rscloud package. You will need to create client credentials to use the package. To do so, click on your icon/name in the header to reveal the User panel, then click on Credentials. This will take you to the Credentials page of RStudio User Settings, where you can create and manage your client credentials. {rscloud} package repo: https://github.com/rstudio/rscloud ABOUT RSTUDIO CLOUD: RStudio Cloud is a lightweight, cloud-based solution that allows anyone to do, share, teach and learn data science online. Analyze your data using the RStudio IDE, directly from your browser. Share projects with your team, class, workshop or the world. Teach data science with R to your students or colleagues. Learn data science in an instructor-led environment or with interactive tutorials. There is nothing to configure and no dedicated hardware, installation or annual purchase contract required. Individual users, instructors and students only need a browser to do, share, teach and learn data science. We will always offer a free plan for casual, individual use, and we now offer paid premium plans for professionals, instructors, researchers, and organizations. RSTUDIO CLOUD RESOURCES: RStudio Cloud https://rstudio.cloud RStudio Cloud Pricing plans https://rstudio.cloud/plans/instructor RStudio Cloud guide https://rstudio.cloud/learn/guide {rscloud} https://github.com/rstudio/rscloud VIDEO CREDITS: Monitor icon made by xnimrodx from flaticon.com Cloud icon made by Freepik from flaticon.com Tiny Putty Music from Blue Dot Sessions: https://app.sessions.blue/browse/track/52046 ### ABOUT RSTUDIO: RStudio’s mission is to create free and open-source software for data science, scientific research, and technical communication to enhance the production and consumption of knowledge by everyone, regardless of economic means, and to facilitate collaboration and reproducible research, both of which are critical to the integrity and efficacy of work across industries. RStudio also produces RStudio Team, a modular platform of commercial software products that give organizations the confidence to adopt R, Python and other open-source data science software at scale, along with online services to make it easier to learn and use them over the web. Together, RStudio’s open-source software and commercial software form a virtuous cycle: the adoption of open-source data science software at scale in organizations creates demand for RStudio’s commercial software; and the revenue from commercial software, in turn, enables deeper investment in the open-source software that benefits everyone. Check out www.rstudio.com Follow us on Twitter: https://twitter.com/rstudio Facebook: https://www.facebook.com/rstudiopbc/ And LinkedIn: https://www.linkedin.com/company/rstudio-pbc/

RStudio Team

Posit Cloud | Creating a Shared Space | Instructor View

A shared space is an area where a group of people can collaborate together - only the members of a shared space can access the space and its contents. To create a shared space, go to the navigation sidebar (click the menu icon at the upper left if needed) and choose New Space, then follow the on-screen instructions. ABOUT RSTUDIO CLOUD: RStudio Cloud is a lightweight, cloud-based solution that allows anyone to do, share, teach and learn data science online. Analyze your data using the RStudio IDE, directly from your browser. Share projects with your team, class, workshop or the world. Teach data science with R to your students or colleagues. Learn data science in an instructor-led environment or with interactive tutorials. There is nothing to configure and no dedicated hardware, installation or annual purchase contract required. Individual users, instructors and students only need a browser to do, share, teach and learn data science. We will always offer a free plan for casual, individual use, and we now offer paid premium plans for professionals, instructors, researchers, and organizations. RSTUDIO CLOUD RESOURCES: RStudio Cloud https://rstudio.cloud RStudio Cloud Pricing plans https://rstudio.cloud/plans/instructor RStudio Cloud guide https://rstudio.cloud/learn/guide {rscloud} https://github.com/rstudio/rscloud VIDEO CREDITS: Monitor icon made by xnimrodx from flaticon.com Cloud icon made by Freepik from flaticon.com Tiny Putty Music from Blue Dot Sessions: https://app.sessions.blue/browse/track/52046 ### ABOUT RSTUDIO: RStudio’s mission is to create free and open-source software for data science, scientific research, and technical communication to enhance the production and consumption of knowledge by everyone, regardless of economic means, and to facilitate collaboration and reproducible research, both of which are critical to the integrity and efficacy of work across industries. RStudio also produces RStudio Team, a modular platform of commercial software products that give organizations the confidence to adopt R, Python and other open-source data science software at scale, along with online services to make it easier to learn and use them over the web. Together, RStudio’s open-source software and commercial software form a virtuous cycle: the adoption of open-source data science software at scale in organizations creates demand for RStudio’s commercial software; and the revenue from commercial software, in turn, enables deeper investment in the open-source software that benefits everyone. Check out www.rstudio.com Follow us on Twitter: https://twitter.com/rstudio Facebook: https://www.facebook.com/rstudiopbc/ And LinkedIn: https://www.linkedin.com/company/rstudio-pbc/

RStudio Team

Data Science Hangout | Jonathan Regenstein, Truist | Relationships with IT and Non-Data Scientists

We want to help data science leaders become better. The Data Science Hangout is a weekly, free-to-join open conversation for current and aspiring data science leaders. An accomplished leader in the space will join us each week and answer whatever questions the audience may have. We were recently joined by Jonathan Regenstein, Head of Data and Quantamental Research at Truist Securities. Working with IT and building relationships was a focus in our conversation with Jonathan and he included a few tips for building relationships with non-data scientist colleagues. Find a partner within the IT organization and talk to that person at least once a week. IT can help you communicate value proposition along the way as well. "It sounds crazy to say this in the world of data science, but relationship building was critical to what we did, especially at a bank. Thousands of request for new technology. There's no way to avoid going through all the security scans and check marks that we have to go through. We want to make sure we have a good partner who is going to help us do that" 0:48 - Start of session 10:52 - How should data science leaders work with IT? 46:20 - How far out Data Science Leaders should be planning projects with IT 48:20 - How do you become a champion of data science within your organization? 1:02:11 - Your responsibility as a data science leader is to work cross functionally 1:04:17 - Data Science Leaders: Your business cares about the value, not how you got there. ► Subscribe to Our Channel Here: https://bit.ly/2TzgcOu Follow Us Here: Website: https://www.rstudio.com LinkedIn:https://www.linkedin.com/company/rstudio-pbc Twitter: https://twitter.com/rstudio

Managing COVID vaccine distribution in West Virginia | RStudio

With a little help from open source software Learn more: Data Driven West Virginia: https://business.wvu.edu/research-outreach/data-driven-wv DDWV PPE forecasting: https://wvutoday.wvu.edu/stories/2020/04/27/wvu-business-experts-partner-with-the-national-guard-to-forecast-ppe-needs DDWV inventory management system: https://wvutoday.wvu.edu/stories/2021/03/22/a-different-kind-of-science-wvu-chambers-college-data-scientists-propel-west-virginia-s-acclaimed-vaccine-strategy-with-digital-inventory-management-system West Virginia National Guard: https://www.wv.ng.mil/ Shiny: https://shiny.rstudio.com/ West Virginia leading nation at start of vaccine rollout: https://www.vox.com/first-person/2021/3/4/22313540/covid-19-vaccine-west-virginia *** In the United States, approximately 2.5 million doses of COVID vaccines are being delivered each day, and how these doses go from the manufacturer to a shot in someone’s arm varies by state, often with mixed results. But early on in the vaccine distribution process, one state led the pack in terms of using the majority of vaccine doses it had been allotted. That state? West Virginia. Part of what has made West Virginia successful is the creation of an inventory management system using Shiny, an open source framework for building interactive web applications. The system was built by Data Driven West Virginia, part of the John Chambers College of Business and Economics at West Virginia University, in collaboration with the West Virginia Army National Guard. Using Shiny has provided visibility into each component of the vaccine supply chain, leading to the creation of distribution plans that are able to quickly and efficiently match supply with demand, getting vaccines to the right people in the right location at the right time. *** RStudio’s mission is to create free and open-source software for data science, scientific research, and technical communication to enhance the production and consumption of knowledge by everyone, regardless of economic means, and to facilitate collaboration and reproducible research, both of which are critical to the integrity and efficacy of work across industries. RStudio also produces RStudio Team, a modular platform of commercial software products that give organizations the confidence to adopt R, Python and other open-source data science software at scale, along with online services to make it easier to learn and use them over the web. Together, RStudio’s open-source software and commercial software form a virtuous cycle: the adoption of open-source data science software at scale in organizations creates demand for RStudio’s commercial software; and the revenue from commercial software, in turn, enables deeper investment in the open-source software that benefits everyone. Check out www.rstudio.com Follow us on Twitter: https://twitter.com/rstudio Facebook: https://www.facebook.com/rstudiopbc/ And LinkedIn: https://www.linkedin.com/company/rstudio-pbc/

RStudio Team

Katherine Kopp | COVID vaccine distribution Shiny app walkthrough (mock data) | RStudio

Learn more: Data Driven West Virginia: https://business.wvu.edu/research-outreach/data-driven-wv DDWV PPE forecasting: https://wvutoday.wvu.edu/stories/2020/04/27/wvu-business-experts-partner-with-the-national-guard-to-forecast-ppe-needs DDWV inventory management system: https://wvutoday.wvu.edu/stories/2021/03/22/a-different-kind-of-science-wvu-chambers-college-data-scientists-propel-west-virginia-s-acclaimed-vaccine-strategy-with-digital-inventory-management-system West Virginia National Guard: https://www.wv.ng.mil/ Shiny: https://shiny.rstudio.com/ West Virginia leading nation at start of vaccine rollout: https://www.vox.com/first-person/2021/3/4/22313540/covid-19-vaccine-west-virginia *** To understand just how hard it is to get vaccines to the population, it helps to understand where it can go wrong. This starts with how vaccines are packed into containers. To fill up a container, Pfizer places 195 vials into a tray, and up to 5 trays into a single container. Moderna puts 10 vials into a small box, and then combines a minimum of 10 small boxes into a single container. In most states Pfizer and Moderna ship directly to the organization that will be administering the vaccine to the population. This could be a hospital, a pharmacy, or any place where trained professionals will be putting shots into arms. But what happens when a pharmacy receives a full container from Pfizer, 975 vials, but only needs 600? West Virginia has removed this complication by shipping directly to five hubs strategically located throughout the state. Within each of these hubs, containers of vaccine vials are broken down into smaller components and then either picked up or shipped directly to the hospital, pharmacy, or organization that will be administering the vaccine. These hubs are managed by the Joint Interagency Task Force (JIATF), a team of teams composed of public, private, and governmental organizations as well as the National Guard. The Joint Interagency Task Force is responsible for drawing up a weekly distribution plan for each hub, in alignment with CDC allocations, and matching vaccine supply with demand. By using a statewide system managed by a central organization, there’s a level of agility and fluidity that allows each hub to adjust to a variety of changes in order to maximize the number of vaccines that are being administered to the population each week. *** RStudio’s mission is to create free and open-source software for data science, scientific research, and technical communication to enhance the production and consumption of knowledge by everyone, regardless of economic means, and to facilitate collaboration and reproducible research, both of which are critical to the integrity and efficacy of work across industries. RStudio also produces RStudio Team, a modular platform of commercial software products that give organizations the confidence to adopt R, Python and other open-source data science software at scale, along with online services to make it easier to learn and use them over the web. Together, RStudio’s open-source software and commercial software form a virtuous cycle: the adoption of open-source data science software at scale in organizations creates demand for RStudio’s commercial software; and the revenue from commercial software, in turn, enables deeper investment in the open-source software that benefits everyone. Check out www.rstudio.com. *** Follow us on Twitter: https://twitter.com/rstudio Facebook: https://www.facebook.com/rstudiopbc/ And LinkedIn: https://www.linkedin.com/company/rstudio-pbc/

RStudio Team

Webinar Summary | Avoid Dashboard Fatigue | RStudio (2020)

0:00 Introduction 0:07 The Problem 1:05 The Solution 3:20 Real Life Success Stories 5:27 Demo (with code) Don't have an hour to watch a webinar? We've made a summary video that covers the main points of our "Avoid Dashboard Fatigue" webinar from Sean Lopp and Rich Iannone. The full webinar covered: Data science teams face a challenging task. Not only do they have to gain insight from data, they also have to persuade others to make decisions based on those insights. To close this gap, teams rely on tools like dashboards, apps, and APIs. But unfortunately data organizations can suffer from their own success - how many of those dashboards are viewed once and forgotten? Is a dashboard of dashboards really the right solution? And what about that pesky, precisely formatted Excel spreadsheet finance still wants every week? In this webinar, we’ll show you an easy way teams can solve these problems using proactive email notifications through the blastula and gt packages, and how RStudio pro products can be used to scale out those solutions for enterprise applications. Dynamic emails are a powerful way to meet decision makers where they live - their inbox - while displaying exactly the results needed to influence decision-making. Best of all, these notifications are crafted with code, ensuring your work is still reproducible, durable, and credible. We’ll demonstrate how this approach provides solutions for data quality monitoring, detecting and alerting on anomalies, and can even automate routine (but precisely formatted) KPI reporting. Webinar materials: https://rstudio.com/resources/webinars/avoid-dashboard-fatigue/ About Sean: Sean has a degree in mathematics and statistics and worked as an analyst at the National Renewable Energy Lab before making the switch to customer success at RStudio. In his spare time he skis and mountain bikes and is a proud Colorado native. About Rich: My background is in programming, data analysis, and data visualization. Much of my current work involves a combination of data acquisition, statistical programming, tools development, and visualizing the results. I love creating software that helps people accomplish things. I regularly update several R package projects (all available on GitHub). One such package is called DiagrammeR and it's great for creating network graphs and performing analyses on the graphs. One of the big draws for open-source development is the collaboration that comes with the process. I encourage anyone interested to ask questions, make recommendations, or even help out if so inclined!

Rich Iannone

Mike Garcia | R in Pharma: Intro to Shiny | Posit

Slides: https://garciamikep.github.io/rstudioglobal-2021-shiny-slides/slides.html#1 From rstudio::global(2021) Pharma X-Sessions, sponsored by ProCogia: in this introduction to Shiny app development, we begin with a quick review of visualization with {ggplot2} and then cover core concepts in app structure and reactive programming. After building several Shiny apps of increasing complexity, we wrap up with a demonstration of how to include your Shiny app in a dashboard using the {flexdashboard} package. About Mike Garcia: Mike is a Data Science Consultant with ProCogia, with a background in Biostatistics and experience in clinical trial design and public health research. If not geeking out on data with a cup of coffee and spreading his passion for R, he's probably out enjoying the outdoors. Learn more about the rstudio::global(2021) X-Sessions: https://blog.rstudio.com/2021/01/11/x-sessions-at-rstudio-global/ _______________________________________________________________________________________________ To hear more about how other major pharmaceutical companies are transitioning to open source data science you can watch talks from this year’s R in Pharma conference: https://www.youtube.com/@RinPharma/playlists At Posit, we have a dedicated Pharma team to help organizations migrate and utilize open source for drug development. To learn more about our support for life sciences, please see our dedicated Pharma page where you can book a call with our team. (https://posit.co/solutions/pharma)

Lou Bajuk & Kevin Bolger | Why Data Science in the Cloud? | RStudio (2020)

As business and organizational needs expand, a centralized ecosystem such as the cloud is needed to securely store and access data, conduct analyses, and share results. We’ll share some examples of what it means to do data science in the cloud and discuss some problems that users may face along the way, and the solutions that RStudio products can provide. We’ll also discuss best practices for migrating to a cloud environment. What you’ll learn: - What are the benefits of working in a cloud environment? - What are the different cloud environments available? - How do I learn which is the best fit for my organization? - What should I consider when migrating my data science infrastructure to the cloud? Webinar materials: https://rstudio.com/resources/webinars/why-data-science-in-the-cloud/ About Lou: Lou is a passionate advocate for data science software, and has had many years of experience in a variety of leadership roles in large and small software companies, including product marketing, product management, engineering and customer success. In his spare time, his interests includes books, cycling, science advocacy, great food and theater. About Kevin: After finishing his education in the University of Limerick, Ireland – Kevin’s passion for data science was cemented. Focusing primarily on data analytics and modelling, he went on to spend the first years of his career working at a biopharmaceutical company, where he led the data team on multiple products. Since moving to Seattle with his Washington native wife, Kevin has spent his spare time enjoying the beautiful PNW and playing ‘hurling’, an ancient gaelic field sport with the Seattle Gaels. He now leads the Data Science team at ProCogia as the Director of Data Solutions – where he works with clients from Biotech to Telecom

Andy Nicholls & Michael Rimler | Using R to Drive Agility in Clinical Reporting | RStudio (2020)

The R language is used extensively throughout the pharmaceutical industry. But its use within the tightly regulated clinical reporting workflows has remained limited. GSK Biostatistics has embarked upon a journey to embed R as a primary statistical analysis tool for clinical reporting. Enabling R within a global department of over 600 Statisticians, Programmers and Data Scientists is challenging! It requires planning, patience, and a strong foundation that enables consistency across the enterprise. We invite you to learn more about how we achieved this at GSK. You'll learn about our tidyverse-centric training program, a future-ready Working Area for R Programming (WARP) environment, and a leading-edge R for Clinical Reporting (R4CR) initiative. The goal: help embed R in every-day clinical reporting output. About Andy: Andy Nicholls has a long history with the R language and in Data Science, authoring the book ‘R in 24 Hours’. He is currently Head of Statistical Data Sciences within GSK’s Biostatistics department. One of his team’s main objectives is to embed the R language within Biostatistics; developing training materials, overseeing various adoption initiatives and provisioning a world-class environment for R . He is also the lead for the cross-industry R Validation Hub initiative that aims to support the use of R for regulatory work. About Michael: Michael Rimler is a clinical programmer in GSK Biostatistics and passionate about influencing the evolving role of open source technologies and data science capabilities on clinical data analytics. He is involved with numerous internal initiatives aimed at moving the organization in this direction, including leading the effort to fully integrate R into the clinical reporting process. Michael is a co-lead of the Open Source Technologies in Clinical Research PHUSE working group project, has chaired a PHUSE US Single Day Event on Data Visualization, and will serve as a co-chair for the 2021 PHUSE US Connect

Hadley Wickham | testthat 3.0.0 | RStudio (2020)

In this webinar, I'll introduce some of the major changes coming in testthat 3.0.0. The biggest new idea in testthat 3.0.0 is the idea of an edition. You must deliberately choose to use the 3rd edition, which allows us to make breaking changes without breaking old packages. testthat 3e deprecates a number of older functions that we no longer believe are a good idea, and tweaks the behaviour of expect_equal() and expect_identical() to give considerably more informative output (using the new waldo package). testthat 3e also introduces the idea of snapshot tests which record expected value in external files, rather than in code. This makes them particularly well suited to testing user output and complex objects. I'll show off the main advantages of snapshot testing, and why it's better than our previous approaches of verify_output() and expect_known_output(). Finally, I'll go over a bunch of smaller quality-of-life improvements, including tweaks to test reporting and improvements to expect_error(), expect_warning() and expect_message(). Webinar materials: https://rstudio.com/resources/webinars/testthat-3/ About Hadley: Hadley Wickham is the Chief Scientist at RStudio, a member of the R Foundation, and Adjunct Professor at Stanford University and the University of Auckland. He builds tools (both computational and cognitive) to make data science easier, faster, and more fun. You may be familiar with his packages for data science (the tidyverse: including ggplot2, dplyr, tidyr, purrr, and readr) and principled software development (roxygen2, testthat, devtools, pkgdown). Much of the material for the course is drawn from two of his existing books, Advanced R and R Packages, but the course also includes a lot of new material that will eventually become a book called "Tidy tools"

Hadley Wickham

Mine Çetinkaya-Rundel | Teaching R online with RStudio Cloud | RStudio (2020)

RStudio Cloud is a lightweight and easy to set up / use solution to teaching R online, in the browser. In this webinar we will walk you through the steps of setting up your course on RStudio Cloud, highlighting the various functionalities for teachers and students. We will also discuss best practices and provide an opportunity for the audience to experience the setup first hand. Additionally, we highlight a suite of ready to use resources for teaching an introduction to data science and statistical thinking course using R. Webinar materials: https://rstudio.com/resources/webinars/teaching-r-online-with-rstudio-cloud/ About Mine: Mine Çetinkaya-Rundel is Professional Educator and Data Scientist at RStudio as well as Senior Lecturer in the School of Mathematics at University of Edinburgh (on leave from Department of Statistical Science at Duke University). Mine’s work focuses on innovation in statistics and data science pedagogy, with an emphasis on computing, reproducible research, student-centered learning, and open-source education as well as pedagogical approaches for enhancing retention of women and under-represented minorities in STEM. Mine works on integrating computation into the undergraduate statistics curriculum, using reproducible research methodologies and analysis of real and complex datasets. She also organizes ASA DataFest and works on the OpenIntro project. She is also the creator and maintainer of datasciencebox.org and she teaches the popular Statistics with R MOOC on Coursera

Mine Çetinkaya-Rundel

A quick tour of RStudio 1.4 | RStudio

HD version here: https://youtu.be/oCR_LB3H73M 0:00 Introduction 0:20 R Markdown Visual Editor 0:46 Insert citations in R Markdown 1:09 Python support in Environment pane 2:05 Python environment selection 2:25 Rainbow parentheses 2:43 Monospace font support 2:54 Support for multiple source columns 3:10 Command palette 3:27 Customize data and configuration storage (users and servers) 3:55 RStudio Pro edition features 4:08 Authenticate RStudio Server Pro using SAML 4:25 Project sharing with Launcher 4:48 Request a GPU with SLURM 5:00 Run Visual Studio Code sessions (beta) What's new with RStudio 1.4: A visual markdown editor that provides improved productivity for composing longer-form articles and analyses with R Markdown. New Python capabilities, including display of Python objects in the Environment pane, viewing of Python data frames, and tools for configuring Python versions and conda/virtual environments. The ability to add source columns to the IDE workspace for side-by-side text editing. A new command palette (accessible via Ctrl+Shift+P) that provides easy keyboard access to all RStudio commands, add-ins, and options. Support for rainbow parentheses in the source editor (enabled via Options, then Code, then Display). New citation support that allows you to include document citations from your document bibliography, personal or group libraries, and several other sources. Integration with a host of new RStudio Server Pro features including project sharing when using Launcher, Microsoft Visual Studio Code support (currently in beta), SAML authentication, and local launcher load-balancing. Read more on our blog: https://blog.rstudio.com/2021/01/19/announcing-rstudio-1-4/

Alison Hill & Desirée De Leon | How to Get Your Materials Online With R Markdown | RStudio (2020)

Full title: Sharing on Short Notice: How to Get Your Teaching Materials Online With R Markdown Educators create a lot of files for teaching- slides, exercises, solutions, assignments, data, figures- that all ultimately need to be shared with other people. Having a link for sharing your teaching materials can save you time and pain, but it is hard to get started if you’ve never shared your resources online before. In this webinar, we’ll give a tour of the R Markdown ecosystem for educators that you can start to use right away. We’ll show how it can help you make your teaching more shareable, reproducible, and resilient. About Alison: I studied psychology and quantitative methods, receiving my Ph.D. from Vanderbilt University (2008). For eight years, I was a professor and scientist at Oregon Health & Science University, where my research was funded by the National Institutes of Health, the Oregon Clinical and Translational Research Institute, and Autism Speaks. I have written numerous scientific journal articles and book chapters on autism and neurodevelopmental disorders. I have developed and delivered workshops, graduate-level courses, and curricula based on teaching R, the tidyverse, and literate programming. You can follow my current work for RStudio Education on GitHub. About Desirée: I am neuroscience PhD student at Emory University and also a former summer intern at RStudio. This past summer, I worked with Alison Hill to develop a handbook filled with practical advice and resources for educators who teach with R and RStudio. I enjoy spending my time on collaborative projects that involve coding, teaching, and illustration

Roche & Novartis: Effective Visualizations for Data Driven Decisions || Posit (2020)

Effective visual communication is a core task for all data scientists including statisticians, epidemiologists, machine learning experts, bioinformaticians, etc. By using the right graphical principles, we can better understand data, highlight core insights and influence decisions toward appropriate actions. Without it, we can fool ourselves and others and pave the way to wrong conclusions and actions. While numerous solutions exist to analyze data, these often require many manual steps to convert them into visually convincing and meaningful reports. How do we put this in practice in an accurate, transparent and reproducible way? In this webinar we will introduce an open collaborative effort, currently undertaken by Roche and Novartis, to develop solutions for effective visual communication with a focus on reporting medical and clinical data. The aim of the collaboration is to develop a user-friendly, fit for purpose, open source package to simplify the use of good graphical principles for effective visual communication of typical analyses of interventional and observational data encountered in clinical drug development. We will introduce the initial visR package design which easily integrates into a typical tidyverse workflow. The package provides guidance and meaningful default parameters covering all aspects from the design, implementation and review of statistical graphics. Webinar materials: https://posit.co/resources/videos/effective-visualizations-for-data-driven-decisions/ About Charlotta: Charlotta is a computational biologist by training and works as a data scientist in the Personalized Healthcare department at Roche where she uses R to untap the wealth of information coming from healthcare data collected in real-world settings to support the development of new medicines. About Diego: Diego is a data scientist specializing in applied machine learning at Roche Personalized Healthcare since March 2019. He has developed models to perform various tasks and analyze diverse data sources. Currently, his main applications of interest are in onocology and clinico-genomics. About Mark: Mark is a methodologist supporting the clinical development and analytics department at Novartis. He has a focus on data visualization working on a number of internal and external initiatives to improve the reporting of clinical trials and observational studies. About Marc: Marc is a biostatistics group head at Novartis. He is interested in advancing the methods and practice of clinical development, for instance through effective use of graphics. https://graphicsprinciples.github.io/

Sean Lopp & Lou Bajuk | R & Python: A Data Science Love Story | RStudio (2020)

Many Data Science teams today leverage both R and Python in their work, but struggle to use them together. Data Science leaders and their business partners find it difficult to make key data science content easily discoverable and available for decision-making, while IT Admins and DevOps engineers grapple with how to efficiently support these teams without duplicating infrastructure. Even experienced data scientists familiar with both languages often struggle to combine them without painful context switching and manual translations. In this webinar, you will learn how RStudio helps organizations tackle these challenges, with a focus on some of the recent additions to our products that have helped deepen the happy relationship between R and Python: - Easily combine R and Python in a single Data Science project using a single IDE. - Leverage a single infrastructure to launch and manage Jupyter Notebooks, JupyterLab, VSCode and the RStudio IDE, while giving your team easy access to Kubernetes and other resources. - Share and manage access to R- and Python-based interactive applications, dashboards, and APIs, all in a single place. Webinar materials: https://rstudio.com/resources/webinars/r-python-a-data-science-love-story/ About Lou: Lou is a passionate advocate for data science software, and has had many years of experience in a variety of leadership roles in large and small software companies, including product marketing, product management, engineering and customer success. In his spare time, his interests includes books, cycling, science advocacy, great food and theater. About Sean: Sean has a degree in mathematics and statistics and worked as an analyst at the National Renewable Energy Lab before making the switch to customer success at RStudio. In his spare time he skis and mountain bikes and is a proud Colorado native

Sean Lopp & Rich Iannone | Avoid Dashboard Fatigue | RStudio (2020)

Data science teams face a challenging task. Not only do they have to gain insight from data, they also have to persuade others to make decisions based on those insights. To close this gap, teams rely on tools like dashboards, apps, and APIs. But unfortunately data organizations can suffer from their own success - how many of those dashboards are viewed once and forgotten? Is a dashboard of dashboards really the right solution? And what about that pesky, precisely formatted Excel spreadsheet finance still wants every week? In this webinar, we’ll show you an easy way teams can solve these problems using proactive email notifications through the blastula and gt packages, and how RStudio pro products can be used to scale out those solutions for enterprise applications. Dynamic emails are a powerful way to meet decision makers where they live - their inbox - while displaying exactly the results needed to influence decision-making. Best of all, these notifications are crafted with code, ensuring your work is still reproducible, durable, and credible. We’ll demonstrate how this approach provides solutions for data quality monitoring, detecting and alerting on anomalies, and can even automate routine (but precisely formatted) KPI reporting. Webinar materials: https://rstudio.com/resources/webinars/avoid-dashboard-fatigue/ About Sean: Sean has a degree in mathematics and statistics and worked as an analyst at the National Renewable Energy Lab before making the switch to customer success at RStudio. In his spare time he skis and mountain bikes and is a proud Colorado native. About Rich: My background is in programming, data analysis, and data visualization. Much of my current work involves a combination of data acquisition, statistical programming, tools development, and visualizing the results. I love creating software that helps people accomplish things. I regularly update several R package projects (all available on GitHub). One such package is called DiagrammeR and it's great for creating network graphs and performing analyses on the graphs. One of the big draws for open-source development is the collaboration that comes with the process. I encourage anyone interested to ask questions, make recommendations, or even help out if so inclined!

Rich Iannone

Lou Bajuk & Sean Lopp | RStudio: A Single Home for R & Python| RStudio

Many Data Science teams today are bilingual, leveraging both R and Python in their work. While both languages are tremendously powerful, teams frequently struggle to use them together. We’ve heard from our customers how even experienced data scientists familiar with both languages often struggle to combine them without painful context switching and manual translations. Data Science leaders and business stakeholders find it difficult to make key data science content easily discoverable and available for decision-making, and IT Admins and DevOps engineers grapple with how to efficiently support these teams. In this webinar, you will learn how RStudio helps Data Science teams tackle all these challenges, and make the Love Story between R and Python a happier one: - Easily combine R and Python in a single Data Science project - Leverage a single infrastructure to launch and manage Jupyter Notebooks and JupyterLab environment, as well as the RStudio IDE - Organize and share Jupyter Notebooks alongside your work in R and your mixed R and Python projects This webinar will show examples of all these capabilities, and discuss the benefits of leveraging R and Python. About Lou: Lou is a passionate advocate for data science software, and has had many years of experience in a variety of leadership roles in large and small software companies, including product marketing, product management, engineering and customer success. In his spare time, his interests includes books, cycling, science advocacy, great food and theater. About Sean: Sean has a degree in mathematics and statistics and worked as an analyst at the National Renewable Energy Lab before making the switch to customer success at RStudio. In his spare time he skis and mountain bikes and is a proud Colorado native

Podcast | Not So Standard Deviations Episode 100 | RStudio (2020)

Featuring: Hilary Parker & Roger Peng In episode 100 of Not So Standard Deviations, the first ever episode prepared in advance, Hilary and Roger discuss creativity, its role in data science, and how it can be fostered through conversation. Also, follow up on coffee and oat milk. About Hilary: Hilary Parker is a Data Scientist on the styling recommendations team at Stitch Fix, a personal styling service that uses a combinations of human stylists and algorithmic recommendations to help people find what they love. At Stitch Fix, she focuses on what sorts of data to collect from clients in order to optimize clothing recommendations, as well as building out prototypes of algorithms or entirely new products based on new data sources. She is also a co-founder of the Not So Standard Deviations podcast, a bi-weekly data science podcast with Roger Peng that has over half a million downloads. Their topics of discussion include the R ecosystem, recent developments in the data science and statistics field, reproducibility and the "how" of how data scientists and statisticians work. Hilary recently authored the paper Opinionated Analysis Development based on discussions from the podcast. Prior to her career in the tech field, Hilary received her PhD in Biostatistics from Johns Hopkins School of Public Health. She lives at the San Francisco Zen Center with her partner, a Soto Zen Priest. In her free time, she enjoys exploring her home of 2 years, San Francisco. About Roger: Roger D. Peng is a Professor of Biostatistics at the Johns Hopkins Bloomberg School of Public Health where his research focuses on the development of statistical methods for addressing environmental health problems. He is the author of the popular book R Programming for Data Science and nine other books on data science and statistics. He is also the co-creator of the Johns Hopkins Data Science Specialization, the Simply Statistics blog where he writes about statistics for the public, the Not So Standard Deviations podcast with Hilary Parker, and The Effort Report podcast with Elizabeth Matsui. Roger is a Fellow of the American Statistical Association and is the recipient of the Mortimer Spiegelman Award from the American Public Health Association, which honors a statistician who has made outstanding contributions to public health. He can be found on Twitter and GitHub at @rdpeng

Panel: Career Advice for Data Scientists | RStudio (2020)

Featuring: Gabriela de Queiroz, David Keyes, Sydeaka Watson, and Jen Hecht This panel will be focused on how you build a career around R! Our panelists are all passionate about R and have each taken a different path to build a career around that passion. We'll be touching on topics like the different stages of career growth and how you find a community you can go to for support. If you're just getting started in your career, looking to make a transition, or interested in learning some great career-building skills, be sure to join us! About Gabriela de Queiroz: Gabriela de Queiroz is a Sr. Engineering & Data Science Manager at IBM where she manages and leads a team of developers working on Data & AI Open Source projects. Her team contributes to projects such as TensorFlow, PyTorch, Apache Arrow, Apache Spark, and several other open source projects inside IBM. She works to democratize AI by building tools and launching new open source projects. She is passionate about making data science available to everybody and is actively involved with several organizations to foster an inclusive community. She is the founder of AI Inclusive, a global organization that is helping increase the representation and participation of gender minorities in Artificial Intelligence. She is also the founder of R-Ladies, a worldwide organization for promoting diversity in the R community with more than 180 chapters in 50+ countries. About David Keyes: David Keyes is the founder of R for the Rest of Us, which teaches people and individuals to use R through online courses, custom trainings, and public workshops. With stops as an elementary school teacher, PhD social scientist, and program evaluator, David brings his unconventional career trajectory to his current role, helping those with who don't think of themselves as typical R users embrace the power of R. About Sydeaka Watson: Dr. Sydeaka Watson is a native of New Orleans, Louisiana and currently lives in Dallas, Texas. She is Founder and Owner of Korelasi Data Insights, LLC and a Senior Data Scientist at Elicit Insights, LLC. In these roles, Sydeaka uses predictive analytics and visual tools to draw insights from diverse datasets. Sydeaka earned a Ph.D. in Statistics from Baylor University and has several years of teaching experience. In her 5 years as Research Assistant Professor in The University of Chicago Biostatistics Laboratory, she consulted with over 110 biomedical research teams in The University of Chicago Medical Center, specializing in statistical analysis and experimental design for clinical research studies. Her current research interests include applications of (1) image recognition for computer vision and (2) data science for social justice. Sydeaka currently serves as Organizer of the R-Ladies Dallas Chapter. She also volunteers in the Dallas chapters of Girls Who Code and Black Girls Code. About Jen Hecht: Jen Hecht is the VP of People Operations at RStudio. She was first introduced to R in 2013, as a non-programmer seeking better ways to manage analytical projects - a quest which was aided both by the RStudio toolchain and the welcoming support of R Ladies, R meetup groups, and other wonderful open resources. Ever since, she has been captivated by open data science tools and the communities that build them. Before joining RStudio in 2018, Jen held HR and People Analytics roles in a variety of industries, including financial services, biotech, and used record shops. Outside of work, Jen loves books and music of all kinds, and is a novice fly caster

Fernanda Viegas & Martin Wattenberg | Data, visualization, and designing AI | RStudio (2020)

Recent progress in machine learning has raised a series of urgent questions: How can we train and debug deep learning models? How can we understand what is going on inside a neural network? And, perhaps most important, how can we design systems that serve people best? We'll show a series of examples from the People+AI Research (PAIR) initiative at Google--ranging from data visualizations for researchers, to tools for medical practitioners, to guidelines for designers--that illustrate how thinking carefully about data can lead to better tools, more effective design, and help humans and AI work together. About Fernanda: Fernanda Viégas and Martin Wattenberg co-lead Google’s PAIR (People+AI Research) initiative, part of Google Brain. Their work in machine learning focuses on transparency and interpretability, as part of a broad agenda to improve human/AI interaction. They are well known for their contributions to social and collaborative visualization, and the systems they’ve created are used daily by millions of people. Viégas and Wattenberg are also known for visualization-based artwork, which has been exhibited in venues such as the Museum of Modern Art in New York, London Institute of Contemporary Arts and the Whitney Museum of American Art. Their artwork has influenced contemporary design practice: for instance, the techniques in their wind map are now used by many major media companies to display the weather. About Martin: Fernanda Viégas and Martin Wattenberg co-lead Google’s PAIR (People+AI Research) initiative, part of Google Brain. Their work in machine learning focuses on transparency and interpretability, as part of a broad agenda to improve human/AI interaction. They are well known for their contributions to social and collaborative visualization, and the systems they’ve created are used daily by millions of people. Viégas and Wattenberg are also known for visualization-based artwork, which has been exhibited in venues such as the Museum of Modern Art in New York, London Institute of Contemporary Arts and the Whitney Museum of American Art. Their artwork has influenced contemporary design practice: for instance, the techniques in their wind map are now used by many major media companies to display the weather

Marie Vendettuoli | Lessons learned developing a library of validated packages | RStudio

Full title: Towards an integrated {verse}: lessons learned developing a library of validated packages Developing R packages as a unified {verse} – a set of packages that work well together but with each focusing on individual tasks – is an efficient strategy to structure support for complex workflows. The ongoing challenge becomes managing the growth of related packages in a holistic manner. This is especially problematic in industries with a heavy emphasis on stability, for example if packages need to be validated prior to use in production. In this talk, I will discuss a paradigm for developing and maintaining validated R packages, emphasizing the following areas: 1. Strategies for organizing packages to prevent excessive re-work 2. Facilitating responsive, iterative development and 3. Empathy for developer and user experiences About Marie: Marie Vendettuoli is a Senior Statistical Programmer at Statistical Center for HIV/AIDS Research and Prevention (SCHARP - https://www.fredhutch.org/en/research/divisions/vaccine-infectious-disease-division/research/biostatistics-bioinformatics-and-epidemiology/statistical-center-for-hiv-aids-research-and-prevention.html) @ FredHutch. She holds a PhD from Iowa State University in Human Computer Interaction and started developing R packages for use within regulatory frameworks while working as a Data Scientist at USDA Center for Veterinary Biologics (https://www.aphis.usda.gov/aphis/ourfocus/animalhealth/veterinary-biologics/sa_about_vb/ct_vb_about). Before discovering R, Marie worked in a CBER (https://www.fda.gov/about-fda/fda-organization/center-biologics-evaluation-and-research-cber)-regulated laboratory. Her main interest is developing analytical infrastructure to facilitate scientific analysis for fellow data scientists working in a regulatory environment

John Helveston | Using formr to create R-powered surveys with individualized feedback | RStudio

This talk demonstrates how the formr study framework extends the power and flexibility of R to surveys. Using R and RMarkdown code, researchers and teachers can use the formr platform to generate both simple surveys and complex studies with individualized feedback. The platform is built on a web-based application programming interface for R via OpenCPU, enabling complex features such as automated email and text message reminders, adaptive testing, graphical and interactive feedback, and integration with external data sources. In this talk, I introduce some of the formr basics and showcase two examples of how I have used it, including making conjoint surveys with randomized images and timed, randomized quizzes for my students. About John: John Paul Helveston is an Assistant Professor in the Engineering Management and Systems Engineering Department at the George Washington University. He studies technological change, with a particular interest in accelerating the transition to environmentally sustainable and energy-saving technologies. His research centers around how consumer preferences, market dynamics, and policy affect the emergence of critical technologies, such as electric vehicles and solar energy. He is an expert on China's rapidly emerging electric vehicle industry as well as the critical relationship between the US and China in developing and mass producing low carbon energy technologies. He applies an interdisciplinary approach to research, with expertise in discrete choice modeling and conjoint analysis as well as interview-based case studies. He has conducted extensive fieldwork in China, collaborating with colleagues at Tsinghua university, Beijing Normal University, and China's State Information Center on past projects. He is a fluent speaker of Mandarin Chinese and also an award-winning swing dancer. John holds a Ph.D. and M.S. in Engineering and Public Policy from Carnegie Mellon University and a B.S. in Engineering Science and Mechanics from Virginia Tech

Dean Marchiori | A retrospective on a year of commercial data science projects in R | RStudio

Full title: How reproducible am I? A retrospective on a year of commercial data science projects in R Reproducibility is a critical aspect in science to enable trust & communication. In R, many tools exist to bring in the best practices of reproducibility into the hands of data scientists. However, outside of a research setting, how does reproducibility hold up in commercial data science projects? In this talk I take an honest retrospective of my own commercial R projects in the last year. I look at the various types of analyses completed, and which workflows were selected and why. Through this process we can learn how workflow choices may help in the short term but hinder in the long term. More importantly what can be done strike the balance between progress and perfection when doing data science in the wild? About Dean: Dean Marchiori is a Statistician based in Sydney, Australia. He currently works with Endeavour Energy as a Senior Data Scientist modelling bushfire and vegetation risk on the electricity network. Dean's career started in finance as an equities trader before moving into advanced analytics, where he has worked with some of Australia’s largest organisations. His professional interests are in geospatial analysis, time series modelling and the R programming language. In 2019, Dean was named one of the top 10 analytics leaders in Australia by IAPA. He is also recognised as an Accredited Statistician with the Statistical Society of Australia. He holds a Bachelor of Science in Mathematics (awarded with University Medal) and a Masters degree in Applied Finance. Outside of work Dean enjoys bodysurfing, running and spending time with his wife and two boys

Danielle Smalls-Perkins & Dorris Scott | Reflections on creating the Mi-R community | RStudio

Full title: Your R is My R too: Reflections on creating the Mi-R community While the R community has made strides in increasing the representation and participation for women and users from underrepresented regions, there are still members of the R community that have expressed desires for a more inclusive space in addition to these strides. In addition, there are unique challenges that underrepresented R users experience in their respective workspaces or academic environments. In late February of 2020, Danielle Smalls-Perkins and Dorris Scott created Mi-R (Minorities in R) as a result of their various experiences both in and outside the R community. The purpose of this talk is to reflect on the challenges, highlights, and future directions of the first six months since the creation of Mi-R. About Danielle: Danielle Smalls-Perkins co-founded MiR Community with the hope that the R community would continue to encourage the inclusion and recognition of contributions made from R users of diverse backgrounds. She loves to use R for understanding and storytelling. Danielle currently works as a Senior Strategist in Google's Trust and Safety Team. She advocates for model fairness, interpretability, and reducing harmful outcomes of algorithmic decision-making on vulnerable populations. About Dorris: Dorris Scott is the GIS Librarian and Social Science Data Curator at Washington University – St. Louis, where she provides consultation on projects that use geospatial data along with providing training in various GIS software, programming applications of geospatial data, and data management. She also serves as a liaison between Washington University Libraries and social science departments assisting faculty with their data needs such as data management and data curation. Dorris received her PhD in Geography from the University of Georgia, with a specialization in GIS applications for public health

Yanina Bellini Saibene | On programming, teaching, and building tutorials with learnr | RStudio

Full title: On programming, teaching, and building interactive tutorials with learnr Teaching R is part of my activities as a community organizer, an RStudio Certified Instructor, a conference chair, and a researcher. Since 2019, I use the learnr package to generate interactive tutorials to teach R synchronously and asynchronously. The addition of the Tutorials panel in RStudio IDE and the need for virtual classes made the use of this package even more interesting. In this talk, I will tell you how to generate interactive tutorials, how to add pedagogical tools to them, what other packages you can use with {learnr} and show multilingual examples. About Yanina: Yanina Bellini Saibene is a researcher at INTA (National Institute of Agricultural Technology) dedicated to applying data science to the agricultural sector and a professor in several regional specializations about Digital Agriculture and Data Analysis. Yanina is formally trained as a Licenciate in Information System with a Master degree in Data Mining and Knowledge Management. She is an active member of the R Community as an R-Ladies organizer and part of the R-Ladies Global Team. She also is a co-founder and co-chair of LatinR and part of the organizing team of useR!2020 and user!2021 (co-chair). She is also co-founder of MetaDocencia, a open, free, volunteer-lead, not-for-profit educational organization and part of the teams that translate educational and technical material to Spanish

Shelmith Kariuki | rKenyaCensus Package | RStudio

The rKenyaCensus package contains the results of the 2019 Kenya Population Census. The census exercise was carried out in August 2019, and the results were released in February 2020. Kenya leveraged on technology to capture data during cartographic mapping, enumeration and data transmission, making the 2019 Census the first paperless census to be conducted in Kenya. The data was published in four different pdf files (Volume 1 - Volume 4) which can be found in the Kenya National Bureau of statistics website. The data in its current form was open and accessible, but not usable and so there was need to convert it into a machine readable format. This data can be used by the government, non-governmental organizations and any other entities for data driven policy making and development. During the talk, I will explain the reasons behind development of the package, take you through the steps I took during the process and finally showcase analysis of certain aspects of the data. About Shelmith: Shelmith Kariuki is a Senior Data Analyst based in Nairobi, Kenya. She is an RStudio Certified Tidyverse trainer (https://education.rstudio.com/trainers/), currently working as a Data Analytics consultant with UN DESA. She previously worked as a Research Manager at Geopoll, and as a Data Analyst at Busara Center for Behavioral Economics. She also worked as an assistant lecturer in various Kenyan universities, teaching units in Statistics and Actuarial Science. She has extensive experience in data analysis using R. She co-organizes a community of R users in Nairobi (https://www.linkedin.com/feed/hashtag/nairobir/) and in Africa (https://twitter.com/AfricaRUsers). One of the missions of her community work is to make sure that there is an increased number of R adopters, in Africa. She is very passionate about training and using data analytics to drive development projects in Africa

Rika Gorn | From Zero to Hero: Best practices for setting up Rstudio Team in the Cloud | RStudio

Learn best practices for setting up the entire Rstudio team infrastructure - Server Pro, Connect, Package Manager from the perspective of a data scientist and for a data science audience - especially those who have never worked with servers, AWS, or bash. This talk will also be applicable to data scientists looking to start on an engineering project outside of Rstudio as well. I started out as a complete novice, & throughout my learning experience I noticed a distinct lack of resources for non-engineers. This talk will focus on best practices for AWS architecture and cloud formation, key security issues such as SSL and https, server configurations, deployment errors, and most importantly resources that are understandable for data scientists just getting into the data engineering or devops space. About Rika: Rika Gorn is the Manager of Business Intelligence at Spring Health - a mental healthcare tech start-up that provides comprehensive mental healthcare benefits. Previously, she worked on quality assurance for a mobile mental health team at Coordinated Behavioral Care, data analytics at Covenant House International, strategic management and evaluation at TCC Group, and program analysis at the Vera Institute of Justice. Rika received her Bachelors in Political Science from Hunter College and her Masters in Public Administration at the NYU Wagner School of Public Service. Rika is also a proud board member of R-Ladies NYC

RStudio Team

Mine Çetinkaya-Rundel | Feedback at scale | RStudio

As enrollments in statistics and data science courses grow and as these courses become more computational, educators are faced with an interesting challenge -- providing timely and meaningful feedback, particularly with online delivery of courses. The simplest solution is using assignments that are easier to auto-grade, e.g. multiple-choice questions, simplistic coding exercises, but it is impossible to assess mastery of the entire data science cycle using only these types of exercises. In this talk I will discuss writing effective learnr exercises, providing useful and motivating feedback with gradethis, distributing them at scale online and as an R package, and collecting student data for formative assessment with learnrhash. About Mine: Mine Çetinkaya-Rundel is Professional Educator and Data Scientist at RStudio as well as Senior Lecturer in the School of Mathematics at University of Edinburgh (on leave from Department of Statistical Science at Duke University). Mine’s work focuses on innovation in statistics and data science pedagogy, with an emphasis on computing, reproducible research, student-centered learning, and open-source education as well as pedagogical approaches for enhancing retention of women and under-represented minorities in STEM. Mine works on integrating computation into the undergraduate statistics curriculum, using reproducible research methodologies and analysis of real and complex datasets. She also organizes ASA DataFest and works on the OpenIntro project. She is also the creator and maintainer of datasciencebox.org and she teaches the popular Statistics with R MOOC on Coursera

Mine Çetinkaya-Rundel

Megan Beckett | Aesthetically automated figure production | RStudio

Automation, reproducibility, data driven. These are not normally concepts one would associate with the traditional publishing industry, where designers normally manually produce every artefact in proprietary software. And, when you have 1000s of figures to produce and update for a single textbook, this becomes an insurmountable task, meaning our textbooks quickly become outdated, especially in our rapidly advancing world. With R and the tidyverse in our back pocket, we rose to the challenge to revolutionize this workflow. I will explain how we collaborated with a publishing group to develop a system to aesthetically automate the production of figures for a textbook including translations into several languages. I think you’ll find this talk interesting as it shows how we applied tools that are familiar to us, but in an unconventional way to fundamentally transform a conventional process. About Megan: Megan Beckett is a Data Scientist at Exegetic Analytics, where she consults, develops and leads several analytical projects across a wide range of fields and industries. *"Scientifically creative; creatively scientific."* This aptly describes her philosophy and approach in her work and life. Megan helped co-found and organises the Cape Town R-Ladies chapter and is a co-organiser of the satRday events in South Africa. She loves to paint, with her most recent work exploring the [biodiversity of southern Africa](https://mappamundi.netlify.app/portfolio/), and running is her passion, whether on the road or the trail

Matt Thomas & Mike Page | How the Tidyverse helped the British Red Cross respond to COVID | RStudio

Full title: Cognitive speed: How the Tidyverse helped the British Red Cross respond quickly to COVID-19 We will discuss the importance of cognitive speed, defined here as the rate in which an idea can be translated into code, and why the Tidyverse excels in this domain. We will demonstrate this idea in relation to a suite of tools we were required to rapidly develop at the British Red Cross in order to respond effectively to the COVID-19 pandemic. To do this, we will exhibit how elements of the unifying design principles outlined in the ‘tidyverse design guide - Tidyverse team’ relate to the notion of cognitive speed, giving specific examples for various design considerations. We believe this talk will encourage reflection on better design practices for future R developers, using the design principles of the tidyverse as the guiding beacon. About Matt: Dr. Matt Thomas is Head of Strategic Insight and Foresight at the British Red Cross. Matt's team aims to help the Red Cross become more anticipatory and proactive by producing insights and tools including the Vulnerability Index (https://britishredcrosssociety.github.io/covid-19-vulnerability/) and Resilience Index (https://britishredcross.shinyapps.io/resilience-index/). He holds a PhD in Evolutionary Anthropology and, prior to joining the British Red Cross, was researching topics including reindeer herders in the Arctic, hunter-gatherers in the Philippines, and witches in China. Outside of work, Matt writes a column for an anthropology magazine (https://www.sapiens.org/column/machinations/) as well as fiction. About Mike: Mike Page is a data scientist on the Strategic Insight and Foresight team at the British Red Cross. Here, he helps to develop a suite of open source tools and dashboards including the Vulnerability Index (https://britishredcrosssociety.github.io/covid-19-vulnerability/) and Resilience Index (https://britishredcross.shinyapps.io/resilience-index/). Mike is also the author of several R packages including mortyr and newsrivr. In his spare time you can find him rock climbing around the Alps

Marcus Adams | Putting a GMP Shiny App into Production | RStudio

Full title: Not The App We Deserve. The App We Need: Putting a GMP Shiny App into Production In February 2020, the Digital Proactive Process Analytics (DPPA) group within Merck’s manufacturing division officially launched a Shiny app to automate the creation of Continuous Process Verification (CPV) reports into production. That’s right – the almighty, mysterious, coveted production. From a technical perspective, the app is nothing particularly special (except other than getting LaTeX successfully installed to support the use of R Markdown). Users enter a few parameters and out pops a PDF with a series statistical analyses of a product’s quality testing data. The R blogosphere is filled with examples of similar Shiny apps. What mattered was the app was in production, and furthermore it was approved for GMP use. This meant these reports could be submitted to the FDA and other regulatory agencies. This meant the data could be used to support product release decisions. This meant Merck’s engineers were about to save thousands of hours per year in compiling data, generating charts, and calculating summary statistics. This was the app manufacturing sites needed. Most of the work in getting this app into production was not implementing the top-level features. Sorry, no discussion of fancy statistical process control methods here. Instead this talk will discuss some of the many things the development team (none of which came from a software development background) needed to learn in order to create a robust, secure, and maintainable production application. About Marcus: Marcus Adams is an Associate Director, Engineering at the biopharmaceutical company Merck. He earned his BEng and MS in Chemical Engineering from the University of Delaware and Villanova University, respectively. His more than decade of experience at Merck spans the bio-pharmaceutical spectrum and includes experience in pre-clinical PK/PD modeling, product commercialization, in-line technology support, procurement, and vaccine distribution technology development. Currently, he works as a part of the Digital Proactive Process Analytics team, leveraging Merck’s Big Data Platform in the development of manufacturing information data models, report automation tools, and integrated-systems analysis applications. His professional interests include effective digital visualization, reproducible research/analysis, and convincing his coworkers of the diverse, flourishing world beyond Microsoft Excel

Kate Hertweck | R training and documentation for different levels of expertise | RStudio

Full title: Making the jump from learning to applying: R training and documentation for different levels of expertise How does someone make the leap from learning R to actively applying R in professional work? At what point (if ever!) do we get to call ourselves "experts in R? This talk explores what differentiates novice, practitioner, and expert R programmers, and how transitions between these stages occur. I'll discuss the type of support required for R users to move from one level of expertise to the next, and how different types of training and documentation can support R users at each level. Understanding variable levels of education among R practitioners supports our own professional work, from collaborative coding to package development, and helps build a bigger, more inclusive R community. About Kate: Kate Hertweck is the bioinformatics training manager at Fred Hutchinson Cancer Research Center, where they develop and teach courses on reproducible computational methods as a part of fredhutch.io. Kate's graduate training at University of Missouri in genomic evolution of plants was followed by a postdoctoral fellowship at the National Evolutionary Synthesis Center (NESCent) at Duke University, where they fell in love with R and began working exclusively in computational biology. Kate then spent four years as an assistant professor teaching bioinformatics, genomics, and plant taxonomy before transitioning to biomedical research training. Kate has been involved in The Carpentries, a non-profit organization that teaches reproducible computational methods, since 2014, serving as a leader in community governance since 2016. When not being an overenthusiastic instructor, Kate likes to spend their time doing fiber arts (knitting, crochet) and enjoying all things science fiction

JooYoung Seo | Accessible Data Science Beyond Visual Models | RStudio

Full title: Accessible Data Science Beyond Visual Models: Non-Visual Interactions with R and RStudio Packages Data science is full of vision-dominant practices, and most data scientists rely heavily on visual models. However, data science itself should require insight and computational thinking beyond what is just seen by eyes. JooYoung Seo, who is a blind data scientist and who was working for RStudio's accessibility projects over the summer 2020, will talk about his experience with some non-visual techniques to interact with data. If you would like to know more about various ways of making data science accessible via R, and new accessibility features introduced in RStudio IDE and Shiny, his demonstration without sight will be thought-provoking. About JooYoung: JooYoung Seo is a Ph.D candidate in the Learning, Design, and Technology program at the Pennsylvania State University, and internationally certified accessibility professional whose research and development focuses on accessible computing for all. As an RStudio's double-certified data science instructor (i.e., Tidyverse + Shiny), who is blind, he is committed to making data science ecosystem more accessible to people with and without dis/abilities using R. To this end, he has been actively contributing to R open-source projects including Shiny, RMarkdown, bookdown, and distill for accessibility, and interned on the RStudio IDE and Shiny team as an accessibility engineer in summer 2020

Shiny Team

Eric Cronstrom | How we made the switch: a case study on automating a complex report | RStudio

The Center for Charter Schools at Central Michigan University produces annual reports for about 60 schools. The reporting process used to be a cumbersome blend of many technologies. The Center used to use a blend of SQL, Excel, inDesign, and VBScript that would all culminate in a nice looking, branded report for each school. 2 years ago, staff turnover allowed the data team to rethink the process, having had experience in R from graduate work the team at the Center decided to go all in on R Studio and R Markdown for report production a mere 1 month before the reports were due to be published. This talk will be a case study of how we as an organization adopted RStudio tools to streamline a cumbersome process to fantastic results. About Eric: Eric is responsible for administering a wide range of day to day program functions associated with the performance and accountability of CMU partner schools. He ensures that the data the Center utilizes to evaluate school performance is accurate and stored within a sound data infrastructure. He also leverages his wide range of technical skills to lead the development and production of reports and respond to questions regarding school performance and demographic context. Prior to joining the Center, Eric was a database administrator for Central Michigan University Libraries. He has also served as a lecturer at Central Michigan University teaching courses in web design, database design and programming. He earned a master’s degree in information systems management and a bachelor’s degree in computer science from Central Michigan University. He is also pursuing an additional master’s degree in applied statistics at Central Michigan University

Ahmadou Dicko | Humanitarian Data Science with R | RStudio

Humanitarian actors are increasingly using data to drive their decisions. Since the Haiti 2010 earthquake, the volume of data collected and used by humanitarians has been growing exponentially and organizations are now relying on data specialists to turn all this data into life-saving data products. These data products are created by teams using proprietary point and click software. The process from the raw data to the final data product involves a lot of clicking, copying and pasting and is usually not reproducible. Another approach to humanitarian data science is possible using R. In this talk, I will show how to seamlessly develop reproducible, reusable humanitarian data products using the tidyverse, rmarkdown and some domain-focused R packages. About Ahmadou: Ahmadou Dicko is a statistics and data analysis officer at the United Nations High Commissioner for Refugees (UNHCR) where he uses statistics and data science to help safeguard the rights and well-being of refugees in West and Central Africa. He has an extensive experience in the use of statistics and data science in development and humanitarian projects. Ahmadou was the lead of the OCHA Center for Humanitarian Data team for West and Central Africa and has worked with several humanitarian and development organizations such as IFRC, FAO, IAEA, OCHA. Ahmadou is a RStudio trainer (https://education.rstudio.com/trainers/) and he is passionate about the R community. He is currently co-organizing the Dakar R User Group (https://www.meetup.com/DakaR-R-User-Group/) and co-leading the AfricaR initiative (https://africa-r.org/)

Mary Rudis | How R and Posit are revolutionizing Stats Education in Community Colleges | Posit

Talk from rstudio::conf(2019) There is no doubt that Posit has had an impact on how introductory statistics is taught in colleges today. When we consider the sheer dominance that giants like Texas Instruments, IBM, and Pearson Publishing have had in academic curriculum development, it’s no small wonder that tools like R and Python have been able to gain a foothold. Projects like DataCamp, ModernDive.com, “Introductory Statistics with Randomization and Simulation” courtesy of openintro.org, Wickham’s “R for Data Science” and Peng’s “R Programming for Data Science” are great resources for the student who has already some fundamental math or statistical background and has become comfortable around computing and applications-driven computational exercises. But many of us know that Data Science cannot simply be relegated to the privileged few that stumble into it by virtue of circumstance. My passion, and the purpose of my talk, is to provide educators with a digestible guidebook that would be appropriate for introduction to statistical concepts in high school, college, and under-resourced schools looking for ways to increase diversity in STEM. Organized in small, adaptable activities designed to be the amuse-esprit enticing both the timid and the skeptical to the proverbial banquet table that is Posit, this exploration into the world of statistics education should be of interest to a wide audience. My hope is to increase data literacy in real world context – with primary emphasis on descriptive statistics and distributions. About Mary Rudis: After graduating from Lehigh University in Bethlehem, PA with a degree in Mathematics, Mary began as a high school mathematics and computer science teacher, developing technology infrastructure for a small, private high school in Pennsylvania. Throughout her career, she brings innovative approaches and enjoys the role of trailblazer. Mary's most recent accomplishments as math department chair included developing mathematics curriculum and coordinating engineering, bioengineering and data science degrees at Great Bay Community College in Portsmouth, NH. Mary's primary interests are learning and instruction, developing data science curricula for two-year colleges and 4-year liberal arts colleges, and working with area high school students in STEM at the University of NH Tech Camp each summer

Heather & Jacqueline Nolis | Push straight to prod: API development with R and Tensorflow | RStudio

Talk from rstudio::conf(2019) When tasked with creating the first customer-facing machine learning model at T-Mobile, we were faced with a conundrum. We had been told time and time again to deploy machine learning models in production you had to use Python, but our very best data scientists were fluent in building neural networks in R with Keras and TensorFlow. Determined to avoid double work, we decided to use R in production for our machine learning models. After months of work, wrangling our containers to meet cloud security compliance, and conforming to DevOps standards, we succeeded in creating a containerized API solution using the keras and plumber R packages and Docker. Today R is actively powering tools that our customers directly interact with and we have open sourced our methods. In this talk, we'll walk through how to deploy R models as container-based APIs, the struggles and triumphs we've had using R in production, and how you can design your teams to optimize for this sort of innovation. About Heather Nolis: Heather Nolis is a founding member of the AI @ T-Mobile team, focusing the conversion of cutting-edge analyses to real-time, scalable data-driven products. She began her career in neuroscience but once realized how heavily that field relied on software built by other people, she pivoted - deciding to make software herself. You can find her @heatherklus on Twitter, where she speaks about diversity in technology, the ethical implications of data, and cats. About Jacqueline Nolis: Dr. Jacqueline Nolis is a co-founder of Nolis, LLC, a data science consulting firm. She has over a decade of experience using data to help companies including DSW, Union Bank, Microsoft, and Airbnb. She has a PhD from Arizona State University where her research focused on electric vehicle route optimization. For fun she likes to use machine learning for humor

Jake Thompson | Branding and Packaging Reports with R Markdown | RStudio (2020)

The creation of research reports and manuscripts is a critical aspect of the work conducted by organizations and individual researchers. Most often, this process involves copying and pasting output from many different analyses into a separate document. Especially in organizations that produce annual reports for repeated analyses, this process can also involve applying incremental updates to annual reports. It is important to ensure that all relevant tables, figures, and numbers within the text are updated appropriately. Done manually, these processes are often error prone and inefficient. R Markdown is ideally suited to support these tasks. With R Markdown, users are able to conduct analyses directly in the document or read in output from a separate analyses pipeline. Tables, figures, and in-line results can then be dynamically populated and automatically numbered to ensure that everything is correctly updated when new data is provided. Additionally, the appearance of documents rendered with R Markdown can be customized to meet specific branding and formatting requirements of organizations and journals. In this presentation, we will present one implementation of customized R Markdown reports used for Accessible Teaching, Learning, and Assessment Systems (ATLAS) at the University of Kansas. A publicly available R package, ratlas, provides both Microsoft Word and LaTeX templates for different types of projects at ATLAS with their own unique formatting requirements. We will discuss how to create brand-specific templates, as well as how to incorporate the templates into an R package that can be used to unify report creation across an organization. We will also describe other components of branding reports beyond R Markdown templates, including customized ggplot2 themes, which can also be wrapped into the R package. Finally, we will share lessons learned from incorporating the R package workflow into an existing reporting pipeline. https://rstudio.com/resources/rstudioconf-2020/branding-and-packaging-reports-with-r-markdown/

Alicia Schep | Auto-magic Package Development | RStudio (2020)

Vega-lite is a high-level grammar of interactive graphics implemented in Javascript; it renders interactive visualizations in the browser based on a JSON specification. In Python and Javascript, the Altair and vega-lite-api packages have demonstrated how the development of APIs to build Vega-Lite graphics can be partially automated based on the Vega-Lite JSON schema, which describes the required format for a Vega-Lite JSON specification. This talk will describe the development of the ‘vlbuildr’ package for building Vega-Lite specifications in R and the ‘vlmetabuildr’ package for building the ‘vlbuildr’ package. The ‘vlbuildr’ package seeks to provide a pipe-friendly, “R-like” functional interface for building up simple to complex specifications for Vega-Lite graphics, which can in turn be rendered as an HtmlWidget by the ‘vegawidget’ R package. Building such an API in a fully automated way from the Vega-Lite schema presents considerable challenges, so the approach taken here was to rely on partial automation. Human judgement dictates the basic contours of the API, such as what groups of functions to include and how various types of building blocks will go together. The part that is automated is filling in many details such as the different variants of a group of functions, the exact parameters needed for each function, and the documentation of those parameters -- the parts that would be extremely tedious to port over!

Ellis Hughes | Approaches to Assay Processing Package Validation | RStudio (2020)

In this talk I will discuss the steps that have been created for validating internally generated R packages at SCHARP (Statistical Center for HIV/AIDS Research and Prevention) and the lessons learned while creating packages as a team. Housed within Fred Hutch, SCHARP is an instrumental partner in the research and clinical trials surrounding HIV prevention and vaccine development. Part of SCHARP’s work involves analyzing experimental biomarkers and endpoints which change as the experimental question, analysis methods, antigens measured, and assays evolve. Maintaining a validated code base that is rigid in its output format, but flexible enough to cater a variety of inputs with minimal custom coding has proven to be important for reproducibility and scalability. SCHARP has developed several key steps in the creation, validation, and documentation of R packages that take advantage of R’s packaging functionality. First, the programming team works with leadership to define specifications and lay out a roadmap of the package at the functional level. Next, statistical programmers work together to develop the package, taking advantage of the rich R ecosystem of packages for development such as roxygen2, devtools, usethis, and testthat. Once the code has been developed, the package is validated to ensure it passes all specifications using a combination of testthat and rmarkdown. Finally, the package is made available for use across the team on live data. These procedures set up a framework for validating assay processing packages that furthers the ability of Fred Hutch to provide world-class support for our clinical trials

Dr. Travis Gerke | UnicoRns are real | RStudio (2020)

Common advice from experienced data scientists to job-seekers is to avoid job postings that describe a "data science unicorn": someone who has experience performing an unrealistically large array of technical and business-related job duties. Seeking a unicorn is viewed as a potential indicator that the company fails to understand their data science needs, and that new hires will not be poised for success due to lacking support and resources [Robinson & Nolis, 2019]. The R language, particularly when used with RStudio products, has evolved to enable production-level activities in the areas of data wrangling, reporting/dashboarding, database/software engineering, machine learning, and web application development. It is increasingly plausible that a data scientist will be able to efficiently perform a wide variety of job functions with experience only in a single language (R). Indeed, even entry level R users may tread into "unicorn" territory. Current standards for data scientist job descriptions and salaries do not accommodate this nuance, leaving both job-seekers and hiring managers unable to distinguish job requirements which should be read as warning signs from listings which are idyllic matches for the modern R unicorn. In this talk, we present data aggregated from several large compensation analytics companies which summarize current benchmarks for data science job descriptions and corresponding salary ranges. We then suggest job description language to target modern R users, considering both job duty compatibility and job post findability. These descriptions are presented with likely salary range pairings. Attention is given to deviations from traditional degree requirements, years of experience, and demands for multiple programming language literacy which may lack relevance for the R unicorn. Our overarching goal is to provide job description templates which encourage optimal matchmaking between R job seekers and organizations in need of their talents

Braulio Cuandon & Ana Alyeska Santos | Using R to Create Reproducible Engineering Test Reports

Talk from rstudio::conf(2020) Engineers at Biosense Webster, a Johnson and Johnson medical device company that specializes in diagnosing and treating cardiac arrhythmias, write multiple test reports to comply with FDA regulatory standards. These intricate reports require 36 hours of an engineer’s time on average, constraining the engineers from completing investigations and studies in a timely matter. Writing scripts in R that create reproducible reports can significantly reduce the time spent by an engineer creating these reports allowing them to do a much thorough investigation with a larger scope. Through Shiny, engineers could conveniently have their parameters and recorded data processed and stored in a database by accessing a web link and filling out the required information within a user-friendly interface. Upon the generation of the report, accurate and properly formatted test reports, compliant to both the company and FDA regulatory standards, are produced through Rmarkdown and knitr knitting all the outputs with complete data analysis tools such as normality plots and process capability measurements to a word document that follows company required headers, footers, and headings. The reproducible report creation shown in this report can be extended to other types of test reports and protocols. The pilot phase that has been conducted has shown that complete report production has been decreased from 36 hours to an hour

Aymen Waqar | Building an iPad dashboard using plumber & RStudio Connect in Pharma | RStudio (2020)

As companies are becoming aware of the need to embrace data-driven solutions, R has gained a huge momentum over recent years. Getting the insights to users has become a very important factor of Data Scientist work. While our world has advanced there is a need to build not only web applications, but also applications on mobile that are available offline. We would like to share with you how within months we have gone from nothing to a production-ready application that handles 500 concurrent users in healthcare. There are plenty of challenges to solve including restricted environments, internal processes and users availability. We will show you how to overcome them and iterate fast, navigating through complex infrastructure and integrating with proxy architecture to serve applications to end users in compliant manner. With RStudio Connect and Plumber you can deploy a scalable REST API that can feed insights to your users. This allows you to go one step further and implement native applications for tablets and smartphones. With the right tools, mindset and priorities you can achieve personal success by introducing a digital transformation within your organization, starting with something as small as converting a business critical Excel file that is slow, difficult to edit and maintain, to a robust application. Step by step your organization will evolve and become empowered by your insights uncovering even more untapped potential

Therese Anders | Peer review in data science courses | RStudio (2020)

Peer review enables instructors of large data science classes to provide substantive feedback to students beyond what is feasible with standard code review via automated grading and continuous integration. It facilitates peer learning, which is shown in literature to have positive learning outcomes, and can reduce the burden of grading by course staff. The ghclass package provides a suite of functions to manage courses via GitHub repositories. The package has recently been supplemented with the functionality to implement peer review. Developed during my 2019 summer internship with RStudio in collaboration with my mentor Mine Çetinkaya-Rundel, the peer review functions in ghclass interface with the GitHub API to create review repositories, move files between authors and reviewers, submit feedback, and collect grades. In this presentation, I will give a demonstration of the peer review functions in ghclass. A set of six functions allows instructors to 1) create a random review roster, 2) set up the review repository infrastructure within a GitHub organization, 3) move assignments from authors to reviewers, 4) collect grades, 5) return the feedback, and 6) obtain a rating of the review from the authors. I reflect on the pedagogy of implementing peer review in introductory data science classes and talk about lessons learned from a real-world test run of the package in the Fall semester 2019 at the University of Edinburgh, conducted by Mine Çetinkaya-Rundel. The presentation highlights ghclass as an R command-line based, open source, low profile, and powerful solution to enable peer review in classes ranging from a size of two to approximately 400 students. A 5 minute presentation in our Lightning Talks series

Mine Çetinkaya-Rundel

Colin Fay | Production-grade Shiny Apps with golem | RStudio (2020)

Shiny is an amazing tool when it comes to creating web applications with R. Almost anybody can get a small Shiny App in a matter of minutes, provided they have a basic knowledge of R. As of today, we can safely tell that it has become the de-facto tool for web application in the R world. Building a proof-of-concept application is easy, but things change when the application becomes larger and more complex, and especially when it comes to sending that app to production—until recently there hasn't been any real framework for building and deploying production-grade Shiny Apps. This is where 'golem' comes into play: offering Shiny developers an opinionated framework for creating production-ready Shiny Applications. With 'golem', Shiny developers now have a toolkit for making a stable, easy-to-maintain, and robust for production web application with R. 'golem' has been developed to abstract away the most common engineering tasks (for example, module creation, addition of external CSS or JavaScript file, ...), so you can focus on what matters: building the application. And once your application is ready to be deployed, 'golem' guides you through testing, and brings you tools for deploying to common platforms. In this talk, Colin and Vincent will present the 'golem' package, first talking about the "why 'golem'?", then presenting the general philosophy behind this framework, and help you get started building your first Shiny App with 'golem'

Katherine Simeon | Every voice matters: An analysis of @WeAreRLadies | RStudio (2020)

As a rotating curation, @WeAreRLadies is a twitter account that has a different curator (i.e., tweeter) each week with a mission to highlight female and minority genders and their work in R. So far, curators have tweeted from 18 different countries and represent a variety of domains and levels of R expertise, ranging from R novices to those developing their own packages. With 45 R-Ladies curators to date, the account has become a popular R-related twitter resource, gaining more than 13,000 followers in the past year and hundreds of interactions each week. This talk will present a text analysis and reflection on over a year of Twitter text data from @WeAreRLadies. As the founder and maintainer of this account, I witness firsthand the bidirectional relationship between one’s learning journey and their use of R. In this talk, I will attempt to quantify this through a text analysis that explores how one’s experiences learning and using R relates to how they talk (or tweet) about it. By analyzing tweet text as well as other metrics provided by twitter (e.g., number of likes, replies, and clicks), I will showcase different ways curators have engaged with the R Twitter community and explore how account engagement has changed as the number of curators and followers continue to grow. I will also discuss how curators’ different areas of expertise have resulted in tweets and discussions that both demonstrate the variety of tools available in R, and spotlight unifying ideas and best practices in R programming. Finally, I will reflect on lessons learned and future directions for @WeAreRLadies, as well as its contribution to the R-Ladies Global initiative. Overall, this talk will discuss how diverse perspectives of @WeAreRLadies curators have enriched the conversations in the R Twitter community by validating different learning journeys and by promoting and amplifying underrepresented voices. A 5-minute presentation in our Lightning Talks series

Davis Vaughn | Sliding Windows and Calendars | RStudio (2020)

A number of R packages exist to make computing moving averages on a single numeric series straightforward. But generally “real” life is much messier than that! Try computing a moving average over a twenty-day sliding window when you have a time series with missing data. Oh! By the way, you should also skip over weekends when looking back twenty days. And you know that random holiday that your company celebrates that no one else does? Skip over that too. These are hard but realistic problems, and until now there has been a lack of tools necessary to solve them. In this talk, I’ll present two packages designed to tackle these issues, slide and almanac. slide is a package designed to perform arbitrary sliding window calculations. The simplest example of this would be a moving average. What makes slide unique is its support for sliding relative to an index, such as a date vector, which allows you to correctly compute the boundaries of that twenty day window. almanac is package for creating custom business calendars, and then adjusting dates relative to them. Inspired by lubridate, almanac allows you to shift dates by a set number of “business” days while respecting the weekends and holidays defined by a user-specified calendar. For example, shifting a Friday forward by 1 business day would land on a Monday, unless that Monday happened to be a holiday, in which case the next business day would actually be Tuesday. Together, slide and almanac provide the tooling necessary to solve the problem mentioned earlier. Additionally, because slide works with any arbitrary function, we can use the same procedure to compute rolling regressions, cumulative sums, and any other sliding computation. A 5-minute presentation in our Lightning Talks series

Caroline Ledbetter | Rproject templates to automate and standardize your workflow | RStudio (2020)

Many teams and organizations have tasks and structures that are standard across projects. Lack of consistency and documentation can lead to lost productivity when team members join collaborations or previous work is consulted by your future self. Setting up folder structures can be particularly tedious. This talk will demonstrate using Rstudio project templates as part of an organizational package to automatically setup file structures, establish git repositories and add standardized readme files. It will also show how including report templates for Rmarkdown files can lead to more consistent and professional reports. Project info can be optionally stored so that project information can be easily added automatically to the top of reports and included in snippets for code file headers. Creating standard, easy to implement documentation and procedures can be particularly effective in encouraging skeptical collaborators to use git and Rmarkdown. Organizational packages can also be a great place to house functions that are specific and common to an organizations needs. The talk will showcase this functionality using the CIDAtools package that we developed. While the CIDAtools package was developed to address issues that sometimes arise from the less structured environment of academia, the tools presented can be equally useful in an industry setting. A 5-minute presentation in our Lightning Talks series

Amelia McNamara | Working with categorical data in R without losing your mind | RStudio (2019)

Categorical data, called “factor” data in R, presents unique challenges in data wrangling. R users often look down at tools like Excel for automatically coercing variables to incorrect datatypes, but factor data in R can produce very similar issues. The stringsAsFactors=HELLNO movement and standard tidyverse defaults have moved us away from the use of factors, but they are sometimes still necessary for analysis. This talk will outline common problems arising from categorical variable transformations in R, and show strategies to avoid them, using both base R and the tidyverse (particularly, dplyr and forcats functions). VIEW MATERIALS http://www.amelia.mn/WranglingCats.pdf (related paper from the DSS collection) http://bitly.com/WranglingCats https://peerj.com/collections/50-practicaldatascistats/ About the Author Amelia McNamara My work is focused on creating better tools for novices to use for data analysis. I have a theory about what the future of statistical programming should look like, and am working on next steps toward those tools. For more on that, see my dissertation. My research interests include statistics education, statistical computing, data visualization, and spatial statistics. At the moment, I am very interested in the effects of parameter choices on data analysis, particularly data visualizations. My collaborator Aran Lunzer and I have produced an interactive essay on histograms, and an initial foray into the effects of spatial aggregation. I talked more about spatial aggregation in my 2017 OpenVisConf talk, How Spatial Polygons Shape Our World

Emily Robinson | Building an AB testing analytics system with R and Shiny | RStudio (2019)

Online experimentation, or A/B Testing, is the gold standard for measuring the effectiveness of changes to a website. While A/B testing is used at tens of thousands of companies, it can seem difficult to parse without resorting to expensive end-to-end commercial options. Using DataCamp’s system as an example, I’ll illustrate how R is actually a great language for building powerful analytical and visualization A/B testing tools. We’ll first dive into our open-source funneljoin package, which allows you to quickly analyze sequential actions using different types of behavioral funnels. We'll then cover the importance of setting up health checks for every experiment. Finally, we'll see how Shiny dashboards can help people monitor and quickly analyze multiple A/B tests each week. VIEW MATERIALS http://bit.ly/rstudio19 About the Author Emily Robinson I work at DataCamp as a Data Scientist on the growth team. Previously, I was a Data Analyst at Etsy working with their search team to design, implement, and analyze experiments on the ranking algorithm, UI changes, and new features. In summer 2016, I completed Metis’s three-month, full-time Data Science Bootcamp, where I did several data science projects, ranging from using random forests to predict successful projects on DonorsChoose.org to building an application in R Shiny that helps data science freelancers find their best-fit jobs. Before Metis, I graduated from INSEAD with a Master’s degree in Management (specialization in Organizational Behavior). I also earned my bachelor’s degree from Rice University in Decision Sciences, an interdisciplinary major I designed that focused on understanding how people behave and make decisions

Hilary Parker | Cultivating creativity in data work | RStudio (2019)

Traditionally, statistical training has focused primarily on mathematical derivations, proofs of statistical tests, and the general correctness of what methods to use for certain applications. However, this is only one dimension of the practice of doing analysis. Other dimensions include the technical mastery of a language and tooling system, and most importantly the construction of a convincing narrative tailored to a specific audience, with the ultimate goal of them accepting the analysis. These "softer" aspects of analysis are difficult to teach, perhaps more so when the field is framed as mathematics and often housed in mathematics departments. In this talk, I discuss an alternative framework for viewing the field, borrowing upon the past work in other fields such as design. Looking forward, we as a field can borrow from these fields to cultivate and hone the creative lens so necessary to the success of applied work. VIEW MATERIALS https://www.slideshare.net/mobile/hilaryparker/rstudioconf2019l About the Author Hilary Parker I’m a Senior Data Analyst at Etsy, where I help product teams with data-driven development, via experimentation, opportunity sizing and impact analysis. I got my Ph.D. from the Department of Biostatistics at the Johns Hopkins Bloomberg School of Public Health, working with Jeff Leek. I studied genomics and built tools to help researchers use genomic technologies in personalized medicine applications. I graduated from Pomona College in 2008, where I double-majored in Mathematics and Molecular Biology. True to my liberal arts upbringing, I’m a passionate teacher. Most notably, I taught an introductory Biostatistics class at the American University of Armenia (and kept a pretty cool travel blog along the way)

Eric Nantz | Effective use of Shiny modules in application development | RStudio (2019)

As a Shiny application grows in scale, organizing code into reusable and streamlined components becomes vital to manage future enhancements and avoid unnecessary duplication. Shiny modules are customized R functions that are easily reused multiple times within an application by avoiding namespace collisions and assist with organizing the code base. Like R functions, modules can be simple utilities or elaborate pieces with multiple inputs and outputs. While the process of creating a module is uncomplicated, application developers can quickly encounter challenges including communication among modules, defining logical compositions, and avoiding hidden state modifications. In this talk, we will introduce practical principles and techniques developers can leverage to address these issues head-on such as documenting modules, passing parameters and return values effectively between modules, and how nesting modules enables dynamic user interfaces with minimal overhead. VIEW MATERIALS https://rpodcast.github.io/rsconf-2019 About the Author Eric Nantz I have a broad background in statistics, computer science, and system administration which gives me a unique set of skills for using state-of-the-art technology and techniques to accomplish important and innovative data analyses. In my professional role as a statistician, I support the design and analyses of clinical trials evaluating treatments for auto-immune disorders. I also perform statistical analyses of specialized biomarkers utilizing cutting-edge statistical software such as R and high-performance computing infrastructures. I am also the creator, producer, and host of the R-Podcast. The R-Podcast is dedicated to helping those who are new to statistical computing develop their skills and confidence in using the free and open-source statistical computing package called R to get their data analyses done

Hao Zhu | Empowering a data team with RStudio addins | RStudio (2019)

RStudio addins provide a mechanism to extend RStudio in various ways. Addins can interact with the RStudio IDE through RStudio API. It can also provide users a graphical interface with the power of Shiny. In practice, we found it very useful for enhancing or streamlining interaction with data and computing infrastructure. In this talk, we will demonstrate how our team develops and uses RStudio addins to empower our work. You will see some internal tools created to help us manage database connections, and an addin which helps us access external cloud computing resources. We will also show an example of using the addins in rcrossref and citr to download and manage citation and literature databases during rmarkdown document development. VIEW MATERIALS https://github.com/hebrewseniorlife/addin_demo About the Author Hao Zhu Hao is a data analyst and software developer working at the Hinda and Arthur Marcus Institute for Aging Research. He completed his training at Boston University School of Medicine in the program on Clinical Investigation. His interests include research reproducibility, data visualization and machine learning. At the Marcus Institute, he works with different teams on various topics, ranging from smartphone motion sensors to MRI images, and helps researchers understand their data by creating analytical reports and web applications. At the same time, Hao leads the development of R packages in the Biostatistics Core. He has contributed multiple R packages to the open source R community, such as kableExtra and memor. He also has a passion for teaching and has mentored several students at the Marcus Institute

Jesse Sadler | Learning and using the tidyverse for historical research | RStudio (2019)

My talk will discuss how R, the tidyverse, and the community around R helped me to learn to code and create my first R package. My positive experiences with the resources for learning R and the community itself led me to create a blog detailing my experiences with R as a way to pass along the knowledge that I gained. The next step was to develop my first package. The debkeepr package integrates non-decimal monetary systems of pounds, shillings, and pence into R, making it possible to accurately analyze and visualize historical account books. It is my hope that debkeepr can help bring to light crucial and interesting social interactions that are buried in economic manuscripts, making these stories accessible to a wider audience. VIEW MATERIALS https://github.com/jessesadler/rstudioconf-2019-slides About the Author Jesse Sadler I am an early modern historian interested in the social and familial basis of politics, religion, and trade. I received a Ph.D. in European History from UCLA in 2015 and have taught courses on cultural and intellectual history of early modern Europe and the Atlantic. My research investigates the familial basis of the early modern capitalism through archival research on two mercantile families from Antwerp at the end of the sixteenth and beginning of the seventeenth century. I am currently working on a manuscript that argues for the significance of sibling relationships and inheritance in the development of early modern trade. My manuscript places concepts such as patriarchy, emotion, exile, and friendship at the heart of the efficacy of long-distance trade networks and the growth of capitalism

Joe Rickert | R Consortium initiatives in medicine | Posit (2019)

R / Pharma and R / Medicine, two new R Consortium sponsored conferences that appeared in 2018, are both grass roots, community-level manifestations of fundamental trends driving the growth of R. R / Pharma organized as an R Consortium working group by R users at several prominent pharmaceutical companies demonstrated that R has reached sufficient critical mass in Pharma to be recognized as a technology important enough to explore inter-company cooperation, while the addition of Genetech/Roche to R Consortium shows the commitment of upper level management to migrate from SAS to R. - At the other, non-corporate end of the spectrum, the R / Medicine conference was well attended by practicing clinicians coming to R, and in some cases statistics and data analysis, for the first time in order to move forward with the practice of data driven medicine. - In this talk, I will present some highlights from these conferences, and other related R Consortium initiatives, describe some of the R-based projects that illustrate the kind of work being done, and indicate what to expect this year. About the Author Joseph Rickert Joseph is Posit's “Ambassador at Large” for all things R, editor of the R Views blog, and Posit's representative on the R Consortium’s board of directors. Joseph came to Posit via Revolution Analytics and Microsoft where he was a data scientist, blogger and community manager. Before joining Revolution Analytics Joseph worked as a statistician for a small healthcare economics consulting firm, and before that he held a variety of technical, marketing and sales positions while working for startups that spanned multiple industries including government contracting, local area networks, disk drives and test equipment. Joseph studied Classics and Mathematics as an undergraduate at Franklin & Marshall College and earned an M.A. in Humanities and an M.S. in Statistics from the California State University

Karl Broman | R qtl2 Rewrite of a very old R package | RStudio (2019)

For nearly 20 years, I've been developing, maintaining, and supporting an R package, R/qtl, for mapping quantitative trait loci (genetic loci that contribute to variation in quantitative traits, such as blood pressure) in experimental crosses (such as in mice). It's a rather large package, with 39k lines of R code, 24k lines of C code, and nearly 300 user-accessible functions. In the past several years, I've been working on rewriting the package, to better handle high-dimensional data and more complex experimental crosses. This has been a good opportunity to take advantage of many new tools, including Rcpp, Roxygen2, and testthat. I'll describe my efforts to avoid repeating the mistakes I made the first time around. VIEW MATERIALS https://bit.ly/rstudio2019 About the Author Karl Broman Karl Broman is Professor in the Department of Biostatistics & Medical Informatics at the University of Wisconsin–Madison; research in statistical genetics; developer of R/qtl (for R). Karl received a BS in mathematics in 1991, from the University of Wisconsin–Milwaukee, and a PhD in statistics in 1997, from the University of California, Berkeley; his PhD advisor was Terry Speed. He was a postdoctoral fellow with James Weber at the Marshfield Clinic Research Foundation, 1997–1999. He was a faculty member in the Department of Biostatistics at Johns Hopkins University, 1999–2007. In 2007, he moved to the University of Wisconsin–Madison, where he is now Professor. Karl is a Senior Editor for Genetics, Academic Editor for PeerJ, and a member of the BMC Biology Editorial Board. Karl is an applied statistician focusing on problems in genetics and genomics – particularly the analysis of meiotic recombination and the genetic dissection of complex traits in experimental organisms. The latter is often called “QTL mapping.” A QTL is a quantitative trait locus – a genetic locus that influences a quantitative trait. Recently he has been focusing on the development of interactive data visualizations for high-dimensional genetic data; see his R/qtlcharts package and his D3 examples

Edzer Pebesma | Spatial data science in the Tidyverse | RStudio (2019)

Package sf (simple feature) and ggplot2::geom_sf have caused a fast uptake of tidy spatial data analysis by data scientists. Important spatial data science challenges are not handled by them, including raster and vector data cubes (e.g. socio-economic time series, satellite imagery, weather forecast or climate predictions data), and out-of-memory datasets. Powerful methods to analyse such datasets have been developed in packages stars (spatiotemporal tidy arrays) and tidync (tidy analysis of NetCDF files). This talk discusses how the simple feature and tidy data frameworks are extended to handle these challenging data types, and shows how R can be used for out-of-memory spatial and spatiotemporal datasets using tidy concepts. VIEW MATERIALS https://edzer.github.io/rstudio_conf/2019/index.html About the Author Edzer Pebesma I lead the spatio-temporal modelling laboratory at the institute for geoinformatics. I hold a PhD in geosciences, and am interested in spatial statistics, environmental modelling, geoinformatics and GI Science, semantic technology for spatial analysis, optimizing environmental monitoring, but also in e-Science and reproducible research. I am an ordinary member of the R foundation. I am one of the authors of Applied Spatial Data Analysis with R (second edition), am Co-Editor-in-Chief for the Journal of Statistical Software, and associate editor for Spatial Statistics. I believe that research is useful in particular when it helps solving real-world problems

Nic Crane | The future's Shiny: Pioneering genomic medicine in R | Posit (2019)

Shiny’s expanding capabilities are rapidly transforming how it is used in an enterprise. This talk details the creation of a large-scale application, supporting hundreds of concurrent users, making use of the future and promises packages. The 100,000 genomes project is an ambitious exercise that follows on from the Human Genome Project - aiming to put the UK at the forefront of genomic medicine, with the NHS as the first health service in the world to offer precision medicine to patients with rare diseases and cancer. Data is at the heart of this project; not only the outputs of the genomic sequencing, but vast amounts of metadata used to track progress against the 100,000 genome target and the status and path of each case through the sample tracking pipeline. In order to make this data readily available to stakeholders, Shiny was used to create an application containing multiple interactive dashboards. A scaled-up version of the app is being rolled out in early 2019 to a much larger audience to support the National Genomics Informatics Service, with the challenge of creating a complex app capable of supporting so many users without grinding to a halt. In this talk, I will explain why Shiny was the obvious technology choice for this task, and discuss the design decisions which enabled this project's success. VIEW MATERIALS https://github.com/thisisnic/rstudio-conf-2019 About the Author Nic Crane Nic Crane is a Data Scientist at Elucidata, and has formerly worked for Mango Solutions and IBM. She is passionate about learning and teaching all things data science

David Robinson | The unreasonable effectiveness of public work | RStudio (2019)

In this talk, I'll lay out the reasons that blogging, open source contribution, and other forms of public work are a critical part of a data science career. For beginners, a blog is a great accompaniment to data science coursework and tutorials, since it gives you experience applying practical data science skills to real problems. For data scientists at any stage of their careers, open source development offers practice in collaboration, documentation, and interface design that complement other kinds of software development. And for data scientists more advanced in their careers, writing a book is a great way to crystallize your expertise and ensure others can build on it. All of these practices build skills in communication and collaboration that form an essential component of data science work. Each also lets you build a public portfolio of your skills, get feedback from your peers, and network with the larger data science community. VIEW MATERIALS https://bit.ly/drob-rstudio-2019 About the Author David Robinson David is the Chief Data Scientist at DataCamp, an education company for teaching data science through interactive online courses. His interests include statistics, data analysis, education, and programming in R. David is co-author with Julia Silge of the tidytext package and the O’Reilly book Text Mining with R. He also the author of the broom, gganimate, and fuzzyjoin packages, and of the e-book Introduction to Empirical Bayes. David previously worked as a data scientist at Stack Overflow, and received a PhD in Quantitative and Computational Biology from Princeton University

Julia Silge

Claus Wilke | Visualizing uncertainty with hypothetical outcomes plots | RStudio (2019)

Uncertainty is a key component of statistical inference. However, uncertainty is not easy to convey effectively in data visualizations. For example, viewers have a tendency to interpret visualizations of the most likely outcome as the only possible one. Viewers may also misjudge the likelihood of different possible outcomes or the extent to which moderately rare outcomes may deviate from the expectation. One way in which we can help the viewer grasp the amount of uncertainty present in a dataset is by showing a variety of different possible modeling outcomes at once. For example, in a linear regression, we could plot a number of different regression lines with slopes and intercepts drawn from the range of likely values, as determined by the variation in the data. Such visualizations are called Hypothetical Outcomes Plots (HOPs). HOPs can be made in static form, showing the various hypothetical outcomes all at once, or preferably in an animated form, where the display cycles between the different hypothetical outcomes. With recent progress in ggplot2-based animation, via gganimate, as well as packages such as tidybayes that make it easy to generate hypothetical outcomes, we can easily produce animated HOPs in a few lines of R code. This presentation will cover the key concepts, packages, and techniques to generate such visualizations. VIEW MATERIALS: https://docs.google.com/presentation/d/1zMuBSADaxdFnosOPWJNA10DaxGEheW6gDxqEPYAuado/edit?usp=sharing

Reproducible Examples with the reprex package

Reproducible Examples and the `reprex` package. https://speakerdeck.com/jennybc/reprex-reproducible-examples-with-r Jump to: 0:08 Intro 0:40 Basic usage of reprex 3:35 Motivation, why use reprex? "Help me help you" 4:08 Define `reprex`? Three commons ways to use the term. 1. noun, a reproducible example 2. the reprex package. a tool to build R `reprex`s 3. reprex::reprex(), a function in `reprex` to make a reprex. 5:26 When should you use a reprex? 6:14 reprex installation and setup. How do you actually get repex on your machine? 7:59 Advanced setup and discussion. 9:45 Please use advanced features responsibly. 11:02 Why does the reprex package exist? Anyone who has helped teach R or dealt with github issues, twitter, stack overflow & RStudio community questions knows that helping people diagnose their coding problems can be hard. This tool comes from hard-won experience. It’s aim to is help people ask well formed questions and increase the chances of getting well formed answers quickly. 12:52 philosophy behind reprex 1. code that I can run 2. code that I don't need to run 3. code that I can easily run 13:52 code that I can run. 17:25 Tips on writing good `reprex`s. Dos and don'ts. 18:52 How do I get my data into my reprex? Getting small data and CSV type data into your reprex is easy. “I have a big hairy data object and I can only show their problem by using it”, but that's not always the case. 21:02 code that I don't need to run reprex gives your reader the code and reveals the output being produced by that code. For experienced coders, that might be enough to help you. 22:44 code that I can easily run Don't copy and paste from the R console. This is usually annoying for your reader. Worse than console copy-pasta is the screenshot. (Many people think screenshots of code are downright offensive.) 25:03 reprex_clean If you copy someone else's reprex into your consolve, it may include their output, making your new reprex a untidy. Here are tips for taking someone else's reprex code and output, and create a clean reprex reply. 25:54 shock and awe More interesting features of the reprex package. - 26:29 What about figures and plots in your reprex? So happy you asked about that. reprex will automatically upload your images to imgur.com. - 28:23 Create a reprex by explicitly providing your code in the reprex call. - 29:00 when you need your reprex to work in the current working directory. - 30:45 Differently flavored markdown. Optimize your reprex markdown output for github, stack overflow, or the RStudio community. - 30:31 Make your reprex create an R script, with your reprex outputs as comments. This is handy for pasting into an email or slack-type-app. - 32:25 Rich text format, rtf output. (currently experimental feature as of this video) - 33:06 supress the reprex add at the bottom of your reprex - 33:19 Include session info. - 33:54 Auto styling of your code. Good if you're dealing with poorly formatting code. - 34:25 Change your comments string. - 34:32 Silence Tidyverse startup messages. - 35:00 Capture a reprex that sends messages to standard output and standard input (e.g. package installation compilation messages). 36:13 Set up personal defaults for your reprex usage. 36:54 reprex RStudio addins; render reprex and reprex selection. These accelerate your use of reprex. 39:01 The human side of reproducible examples. How to ask questions in ways that are most likely to get answered. Sorry for the tough love, but this is important. Why are you always asked to give a reprex? - Experts try to use reproducible examples to ensure their advice works. - Making a good reprex is hard. But, you are asking them to solve a problem for you, so meet them halfway. - Creating reprexes is good coding practice. - Making a good reprex is often a good way to debug your issue in the embarrassment-free privacy of your own home. - reprexes lead to discussions more likely to help people in the future. 44:34 Behind the scenes of reprex 44:44 Thanks for those that helped make reprex possible. Questions and Answers - 46:05 can reprex capture variables and objects in the current environment? (not yet, maybe in development) - 47:25 does reprex actually check that the code is self contained? (self contained) - 48:08 does readr::read_csv support the text argument? (yep, just read the help manual for readr)

Coding

Resources tagged Coding#

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

AI-Powered Data Engineering Workflows: Positron for Databricks Users

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

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

Keynote Speaker-IIsabel Zimmerman-PyData Global 2025

Jeroen Janssens - Python Polars: The Definitive Crash Course - PyData Global 2025

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

Rodrigo Silva Ferreira-When Rivers Speak Analyzing Massive Water Quality Datasets-PyData Boston 2025

Keynote Speaker-Isabel Zimmerman-PyData Boston 2025

Take Positron to Work with Positron Pro

AI-Powered Data Science in Positron

Accelerating Study Insights with Shiny and Posit | Regeneron x Atorus

Top AI Powered Coding Assistants

What can you do with Positron Assistant?

Deploy a Streamlit web app with me

10 tips for data science beginners

Let's try Positron Assistant for the first time together

Data Exploration 101

Positron 101: Make your DS life easier

Set up your first coding project in less than 10 minutes

Get starting with data - load data into your IDE

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

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

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

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

Jeroen Janssens - Package Your Python Code as a CLI | PyData London 25

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

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

Let's install your first Python library in 2 minutes

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

Wes McKinney - Retooling for a Smaller Data Era | PyData Global 2024

KEYNOTE: Dr. Jeroen Janssens - Embrace the Unix Command Line and Supercharge Your PyData Workflow

Great Tables 3: Data Color and Polishing

Great Tables 2: Introducing Units Notation

Great Tables 1: Structure, Format, and Style

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

Build a Python table in under 1 minute using Great Tables

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

TidyTuesday + Posit | PydyTuesday | Weekly Community Python Data Project

Create Quarto dashboards with Python

How to Build a Data Science Portfolio Website with Python & Quarto!

Free AI packages for R and Python #pythoncontent

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

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

Shiny Forms with Accordions 🎉

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

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

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

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

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

Fastest way to Convert Jupyter Notebooks into Analytics Reports! (using Quarto)

Janssens, Chow & Nieuwdorp - Turning DataFrames into Pretty Pictures with Plotnine | PyData NYC 2024

Christophe Dervieux - Exploring Quarto Dashboard for impactful and visual communication

Isabel Zimmerman - End-to-end data science with the Positron IDE | PyData NYC 2024

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

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

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

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

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

pandas vs Polars DataFrames? 👨🏻‍🍳 #python

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

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

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

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

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

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

Jeroen Janssens - How I hacked UMAP and won at a plotting contest | PyData Amsterdam 2024

Build Shiny apps with AI ✨

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

What AI skill should we learn? 🌱

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

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

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

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

Parallelize R code using user-defined functions in sparklyr

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

Quarto: Elevating R Markdown for Advanced Publishing | Christophe Dervieux

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