Every plot and every table you have ever seen is doing the same thing: mapping data to visual properties. A scatter plot maps two columns to x and y positions. A colour-coded table maps values to a colour scale. A bar chart and a pie chart are the same mapping in different coordinate systems.

Once you see this, you stop memorising chart types and start reasoning about visualisation. You can look at any graphic — a plot, a table, a dashboard — and ask one question: “what maps to what?”

This workshop teaches that single idea and gives you two modern Python tools to put it into practice: plotnine for plots (the grammar of graphics in Python) and Great Tables for publication-quality tables.

Along the way, we will use a case study of a table error in the Uganda 2024 Census that triggered a national crisis — to show why visualisation is not decoration: it is how you think clearly about data.

What we build. We will explore the open source packages that Posit maintains to develop tools and applications to interact with LLMs.

How we build. Effective AI assistance requires rich local context. We will show how embedded AI tools in Positron and RStudio tap directly into live session state (loaded data, active plots, and console history) giving developers agentic editing, planning modes, and session memory that general-purpose chatbots cannot match. Behind the scenes, enterprise infrastructure safely brokers model credentials and distributes vetted, version-pinned AI agent skills across teams just like standard software packages.

How we share. Moving from laptop to production requires secure delivery. We’ll cover how Posit Connect hosts the final application while managing user permissions and server-side Model Context Protocol (MCP) integrations.

You will leave this session with a clear snapshot of the current terrain, an understanding of how open-source and enterprise components fit together, and the practical knowledge to navigate what comes next.

Simulation studies, bootstrapping, cross-validation, MCMC - statistical computing is full of work that could run in parallel, yet parallel R too often means a blocked session, a copy of your data on every worker, and code rewritten for each new environment. Over several years I’ve built the layers needed to fix this: a messaging substrate for reliable async I/O, a framework for async and parallel computing on top of it, and a way to share R objects across processes without copying. This talk is a practical tour of that stack from laptop to HPC cluster, with patterns you can apply to your own analyses straight away, plus a closing look at where the zero-copy model is headed next.

SQL is one of the oldest languages still in daily use for data work, and it is now one of the first things any new AI data product promises to write for you. The promise is often natural language to SQL, and it rests on the appealing assumption that the model is what will make the query correct. In practice, what comes back depends far less on the model itself than on the harness around it, meaning what the model can see, verify, and run.

Over the past year, my team has been working on SQL tools for entirely human reasons, so that a person can browse a schema, get appropriate completions, run a query in an interactive console, and inspect what comes back in a data explorer. Pointing an AI assistant at that same environment turned up something we didn’t plan; what we built was already the harness.

In this talk, hear about what a good harness for SQL authoring actually requires, why the investments that make SQL comfortable for people turn out to be the same ones that make it tractable for an assistant, and which questions have turned out to be genuinely hard. How much capability can an assistant be handed before one more tool makes it worse at the ones it already has? We’ll explore these points through the SQL and data connections work in Positron, a next generation IDE for data science in Python, R, and SQL from the team behind RStudio, and consider why adding an AI mode is so often the wrong shape for this kind of work.

This workshop is all about making great slides in Quarto! You don’t need to be a Quarto expert in order to participate, but having some basic knowledge of Quarto would be helpful. We will start with the basics of making a slide deck in Quarto using the revealjs output format and progress through lots of tips and tricks to help you get the most out of your slidecrafting experience. We will cover everything from styling and theming to how to best position elements on your slides for the best outcome.

Este taller está dedicado a la creación de grandes diapositivas en Quarto. No es necesario ser experto o experta en Quarto para participar, aunque contar con conocimientos básicos resultará de ayuda. Comenzaremos por los fundamentos de la creación de una presentación en Quarto utilizando el formato de salida revealjs y avanzaremos a través de numerosos consejos y trucos para ayudarte a aprovechar al máximo tu experiencia de creación de diapositivas. Cubriremos desde el estilo y la tematización hasta la mejor forma de posicionar los elementos en tus diapositivas para lograr el mejor resultado.

Este workshop é totalmente dedicado a criar ótimos slides no Quarto! Não é necessário ser especialista em Quarto para participar, mas ter algum conhecimento básico ajudará. Começaremos pelo básico da criação de uma apresentação de slides no Quarto usando o formato de saída revealjs e avançaremos por diversas dicas e truques para ajudar você a aprovechar ao máximo sua experiência de criação de slides. Abordaremos desde estilo e temas até a melhor forma de posicionar elementos nos seus slides para obter o melhor resultado.

I argue yes — and that the case for teaching programming and reproducible workflows is stronger than ever. When AI produces code freely, mastery becomes the differentiator: the ability to read a generated script and assess whether it is doing what you think it is doing, to recognize when a pipeline quietly produces the wrong answer, and to structure an analysis so that every step can be followed and verified. Beyond code correctness, learning modern data science workflows teaches students to think with data — to ask sharper questions, notice what a dataset can and cannot answer, and build the habits of mind that underpin rigorous reasoning about uncertainty and statistical modeling. These are the foundations of statistical thinking; the code is how we practice them. Reproducibility, in this framing, is not a technical nicety but a cornerstone of scientific integrity — and tools like version control that enforce it turn out to be essential for working productively with AI as well.

Drawing on experience designing introductory data science courses and curricula, this talk presents a case for reframing programming instruction in the AI era — not as syntax acquisition, but as a pathway to statistical thinking. It features concrete code and workflow examples alongside ideas for assignments and assessments designed for a moment when a plausible-looking answer is only a prompt away, and where the real pedagogical challenge is crafting tasks that reward genuine understanding over fluent generation. The goal is not to keep AI out of the classroom, but to produce graduates who can do more than write a good prompt and hope for the best.

Collaborative data analysis presents a fundamental concurrency problem: when multiple users modify the same data simultaneously, how should conflicts be resolved? Traditional approaches rely on locking or central arbitration, but conflict-free replicated data types (CRDTs) offer a principled alternative. A CRDT is a data structure whose concurrent operations are guaranteed to converge to the same state, regardless of the order in which they are applied. This mathematical property — strong eventual consistency — eliminates the need for conflict resolution logic entirely.

We introduce CRDTs to the R ecosystem through automerge, an open-source package developed at Posit that natively bridges R’s data model with the Automerge Rust CRDT engine. Collaborative documents — maps, lists, and text — appear as familiar R objects, but every edit is tracked as an individual operation under the hood. When documents are modified concurrently, changes merge automatically.

Beyond real-time document editing, CRDTs open up new possibilities for the R ecosystem: shared annotation of datasets across a research team, collaborative model specification, or any workflow where multiple analysts need to work on the same objects without coordination overhead. We make this concrete with a live demonstration: audience members will open a Shiny application on their own devices and edit shared state together, watching changes from every participant merge seamlessly in real time.

R is an interactive environment. Working effectively with R means being able to interact with a live session to inspect objects, view and iterate on plots, access help, and step through running code in the debugger. Making LLMs effective in R therefore means more than giving them a way to execute code: it means exposing R’s interactive affordances in a form the model can use.

This talk introduces mcp-repl, an open-source front end to R that plugs into existing agents such as Claude and Codex. It provides a long-lived REPL with persistent state, in-band help, plot capture, support for debugger- and readline-based workflows, guardrails for large outputs, responsive handling of both interactive and long-running computations, and OS-level sandboxing. In practice, mcp-repl makes general-purpose coding agents much more capable at package development, Shiny debugging, and iterative analysis, especially in long-running autonomous tasks without a human in the loop.

Because mcp-repl plugs into existing agents, it also reflects the constraints of a plug-in architecture. To make that contrast concrete, this talk also looks at Posit Assistant as an example of what becomes possible when the interface is integrated into an IDE for data analysis and designed to keep the human in the loop.

Together, Posit Assistant and mcp-repl illustrate two ways to bring R’s interactive affordances to an LLM: one through an integrated experience designed for close human collaboration, the other through a plug-in front end designed for autonomous work in a private runtime.

Ce tutoriel présente comment produire des PDF de qualité avec Quarto en tirant parti du format Typst. Après un bref rappel des bases de Quarto, un focus sera consacré à Typst : avantages, cas d’usage et différences avec les chaînes PDF classiques. L’usage de _brand.yml sera présenté pour centraliser les logos, les palettes de couleurs et les choix typographiques afin d’obtenir des rapports cohérents avec l’identité d’une organisation. Le rôle des templates sera expliqué : adapter et réutiliser des mises en page pour répondre aux besoins d’un laboratoire, d’une équipe ou d’un projet.

Une partie pratique permettra de mettre en place un petit projet Quarto + Typst, d’appliquer un _brand.yml, et de créer ou modifier un template. Enfin, une introduction aux extensions et aux bonnes pratiques montrera comment pérenniser et partager les personnalisations.

This tutorial demonstrates how to produce high-quality PDFs with Quarto by taking advantage of the Typst format. After a brief refresher on Quarto basics, we will focus on Typst: its benefits, use cases, and how it differs from traditional PDF rendering pipelines. We will introduce the use of _brand.yml to centralize logos, color palettes, and typographic choices, ensuring your reports remain consistent with an organization’s identity. The role of templates will also be explained, showing how to adapt and reuse layouts to meet the needs of a lab, team, or project.

A hands-on practical session will guide you through setting up a small Quarto + Typst project, applying a _brand.yml file, and creating or modifying a template. Finally, an introduction to extensions and best practices will show you how to maintain and share your customizations for the long term.