image: thumbnail.jpg
Introducing Positron, a new data science IDE - posit conf 2024
Talk by Julia Silge, Isabel Zimmerman, Tom Mock, Jonathan McPherson, Lionel Henry, Davis Vaughan, and Jenny Bryan
Slide deck 1: https://speakerdeck.com/juliasilge/introducing-positron
Slide deck 6: https://speakerdeck.com/jennybc/positron-for-r-and-rstudio-users
Transcript#
This transcript was generated automatically and may contain errors.
Welcome everyone! I am so excited to welcome you here to this session where we get to introduce you to Positron. This is a very early stage project that was just made public about six weeks ago and I am the first of seven speakers in this session. We're each going to speak for roughly ten minutes and at the end we will have time for questions. So as we're going through these talks feel free to add questions to Slido. You should be able to find the Slido code either in the schedule or on Discord and you can direct any question to a specific one of us or just we as a team can answer them there at the end together.
So my name is Julia Silge. I'm an engineering manager here at Posit and I've been working on the Positron team for about the last year. So Positron is a new next-generation data science IDE. IDE stands for Integrated Development Environment and it is a piece of software that allows you as a user to yourself develop software. So here in this example screenshot somebody is writing a report using Quarto and R and there are there are a ton of IDEs out there in the world and what we're going to do during this session is tell you a little bit about what's new and or different and or special about Positron so that you can know why we're building this and also maybe more importantly whether it might be a good fit for you.
Positron as a data science IDE
The first thing I want to tell you is that Positron is an IDE for data science. We at Posit have just extensive domain knowledge when it comes to data science tooling and we know that someone who is writing code to analyze data is different in some pretty fundamental ways from someone who is writing code for general software engineering purposes like if they're building a website or building a mobile app. So we are huge proponents of code first data science as opposed to a GUI tool or like a no code or a low code solution but it is a fact that tools that are built for a typical software engineer who is writing code they're often not a good fit for someone who is just right he was writing code to analyze data so all across our org pretty much every single thing we build or make or do is informed by how deeply we know this and we believe in this that we can make you as a data practitioner more productive by building tools that are specific for the kinds of tasks that you need to do. So this is exactly why we're building a new IDE. There isn't anything quite like Positron out there and we hope that it's going to become one platform where you can do all of your data science.
There isn't anything quite like Positron out there and we hope that it's going to become one platform where you can do all of your data science.
A multilingual IDE
The second thing I want to tell you is that Positron is a multilingual or polyglot IDE. Currently as of today it has support for both R and for Python. A lot of environments that are built for you to do data analysis are specifically built just to use one language for scientific computing. So tools that you may have heard of or you know you yourself have used that fall into this category include RStudio, things like MATLAB, IDEs like Spyder. There's a lot of these and there are real limits to these kinds of tools and IDEs especially for the high and growing proportion of you who use more than one language for your data science. You can use more than one language literally on the same project, maybe R and Rust. You can use more than one language over the course of a week where you switch between projects. Maybe some projects you use with Python, some you use with R. Almost certainly this is going to happen to all of us over the span of years or our career.
And so by contrast with the IDEs that are built just for one language, Positron is built with front-end user-facing features that are about the tasks you need to do. So here in this screenshot you see that interacting with your plot, seeing the variables that you have defined. But then there are back-end language packs that are the engines for providing these kinds of features and tasks. So here the engine in this screenshot is Python where you're using writing Python code in the source editor, executing it interactively in the console, and then seeing the results that you have in different kinds of pings. So it's a tool for writing code and exploring data that's going to work well for you no matter what language you use for data science. As of today in its early stages it ships with support for Python and R. But it is built in such a way that it can be extensible. Other data science languages can be added into them whether they exist now or don't even exist yet today.
This is really exciting and I know a lot of you in here are wondering should I switch right now? And you're already probably starting to get an idea of what might push you to a yes answer. Like you are one of those people who uses more than one language for data science. I do want to emphasize that Positron is a very early stage project and there is no need to switch today if you are happy with your code writing editing kind of experience. But in the talks and the rest of this session we specifically chose them and designed them to help you who are sitting here or who are listening to understand if it's a good fit for you today and if you should switch.
Extensible and familiar
The third thing I want to highlight about Positron is that it is both extensible and familiar. It's familiar to many of you who are sitting in this room with us right now because it is the design of it is inspired by and informed by our organization's experience building RStudio. Here you see a very RStudio like interface. There's a console, a source editor, help pane, but it is being used with Python instead of with R. For some of you we know this is great news. This is what you have been wanting. This is what you have been looking for. But for some of you this may make you nervous because you may be wondering what is happening to RStudio. So RStudio is incredibly stable and solid software. It has over a decade plus of real-world use on it and for many of you it is probably the best choice today for your work and that may be true for quite a while yet. So we expect people to use RStudio for their real-world use for for many many years to come and we're committed to maintenance for RStudio for the long haul.
Positron also is going to feel familiar to those of you who are in this room who have used Visual Studio Code and that's because it is built on the open source components that make up VS Code. You're going to hear more about this a bit later but I just want to highlight one thing about this is that this makes Positron very extensible. Building on top of Code OSS opens up the wide world of Visual Studio Code compatible extensions for users who do want that data science specific IDE kind of experience.
A new R kernel: ARK
One of the big investments that we needed to make in order to build Positron was a new modern language tooling for R. This already existed for Python and we only had to incorporate it and integrate with it. When it comes to R we had to start from scratch. Positron has a brand new Jupyter kernel for R called ARC which stands for an R kernel and you'll hear more about ARC later but it is software that allows R to talk back and forth with a front-end such as Positron. It gets you completions, diagnostics, debugging which is what this screenshot shows. Someone is running their R code in a debugger. Just a ton of different features that improve the experience of writing R code in some exciting ways. With that I'm run through our introduction. I want to thank you so much for walking through me through this introduction.
The Python data science experience
Hello everyone I am Isabel and I first learned about RStudio and perhaps data science in a course called Intro to Data Science where my professor Dr. Sanchez had us all download RStudio and that first day in that class was kind of magical. You know I got to explore data like in this like data explorer. I could see my variables in a viewer pane. If I was confused I just put a question mark next to what I was confused about and I made my first plot that was not in Excel. I can explore data pretty quickly and this RStudio IDE made this data science experience feel so magical and so accessible and so joyful.
I went on to do more schooling, more learning, more classes and RStudio was a tool that grew with me. I finished my degrees. I took a job doing data sciencey things in Python and I realized that like hey this data science life cycle doesn't change even if the tools I use or even if the language that I use changes. Something that did change was the tools I used and it felt like there wasn't quite an IDE that supported code first data science the way that RStudio did. Some tasks sort of felt like I was stubbing my toe on the corner of a table and okay like stubbing your toe is painful but it doesn't really impact your day until your day involves you stubbing your toe over and over again for about eight hours. I wasn't able to find this IDE experience that not only minimized my pain but maximized my data science productivity. A few years later I've now hobbled my bruised feet over to helping out with building the Python experience on the Positron IDE. I hope we can convince you that we've built a tool that saves you a bit of pain and maybe brings you a bit of joy.
Four-pane data science
So how does Positron support data scientists? As a whole Positron is segmented into kind of these different panes. Up top you have where you are running code and kind of how you're running code. There's a file that shows you the code that you are running, a sandbox for development, and over on the right hand side there's a bunch of different panes to help you explore the code that you're writing. It sets you up for success when you open up Positron to look something like this. You can see my Python script surrounded in pink, you can see a console that's in blue, and you can see these two green squares that have panes that help you understand the variables and the plots that you're creating. We'll call this four-pane data science. These panes are not intended to replace your code first data science experience but rather give you this UI plus code to make you a little bit more productive and feel a little bit like we're doing some interior direct decorating in your IDE.
As you've written Python code before perhaps the first way you have stubbed your toe is trying to figure out how to run the Python you want. Specifically what virtual environment are you using? How are you selecting it? How are you activating it? How do you make sure you're running it in the right place? And you can see in Positron there's something called an interpreter selector. You might recognize here a few different ways to run your favorite Python, whether using Conda, pyenv, venv, poetry, virtualenv, or something else. When you click that power button Positron will activate and turn on this Python interpreter for you all across the IDE. If you want to swap between you can just turn it off, select a different one, and it just kind of works. Positron it discovers all of your virtual environments you have on your computer, you're able to browse between them, and it will also remember per project which virtual environment you have been using and automatically start it up for you each time. And don't fear for the R folks in the crowd, I'm talking about Positron with Python here today, but everything I'm talking about applies to R as well if you have multiple versions installed. The drop-down only is going to populate with the languages you use, so if you only have R installed on your computer you're not going to see Python at all, we're only going to show you what you want.
And a pretty common workflow for data scientists is, you know, creating a Jupyter Notebook, doing all your exploration, and maybe copying this out into a Python script as some sort of artifact for a pipeline. Or perhaps you're running IPython in a terminal and again copying and pasting things over. It's all to say that data science is very experimental, iterative work, and it's convenient to have a tool that understands this is the data science development lifecycle. Positron does support running Jupyter Notebooks, but if you're someone who works for in Python scripts, we have an interactive built-in console. You can use command enter to interact to iterate through a script, you can move back between this console and your script, it kind of gives you a sandbox to play in. You're able to explore your data more deeply and bring the final results back into some sort of reproducible script, perhaps part of a pipeline. And the console has all the affordances you would expect, you're able to use things like autocomplete.
And with the right Python running, we're already off to a good success story. But the first thing you're going to want to do in your data science lifecycle is import some data. And one thing you might be wondering as you're building this database connection is like, what tables do I have on hand? And in this four-pane data science, one of the panes we have, P-A-N-E-S, not like subbing your toe pane, is when you connect to a database, there's a connections pane. So when you create this connections object in something like SQLite, you're able to see all of the tables, all of the rows, all the columns, and their types at a really high-level glance very quickly. It makes databases just a little bit easier to navigate. With some data in hand, you're probably going to want to tidy it up. And the first question you're probably asking yourself is, what does this data even look like? There's a few different ways that Positron allows you to explore your data. If you're viewing data from a database, there's this little eye that pops up if you hover, or there's a table that shows up in this variables,
and you can even just type view data in your console. All three of those locations will bring you to the Data Explorer. When you open up your data, whether it's from a Polar's or a Panda's data frame or a database, you can see the percentage missing per column. The name you can see in this data is never missing, where our Ferris wheels that we're looking at almost are never closed.
If you want to do some really quick looking at your data, you're able to filter. You can sort by ascending or descending, or maybe you just want to look at the Ferris wheels that are between 150 and 200 feet tall.
If you know what data you've collected, you're going to want to understand it a little bit better. And sometimes tidying is messy business. It involves creating lots and lots of variables, and while for a while you can keep them all in your brain, at some point it just is too much information to keep up here. There's something called a variables pane. As you're creating each variable, it shows up and it gives you a little bit of information about it. You can see kind of on this most left-hand side, it says the name of the variable. In the middle, it'll give you either a preview of the data, the actual value of the variable itself, or some sort of other helpful information. And furthest to the right, you either get an icon that you can click on and interact with, like opening this up in the data viewer, or it'll give you the type of variable it is.
We also allow you to expand variables. So let's say we have this dictionary and we want to see maybe what all of the names are, and we can quickly look at this without having to type out in the console, and allows you to just, you know, search through your information a little bit more fluently. We're also able to see functions with a function signature, and if it's something that's custom, like perhaps a new Ferris wheel class, there's reasonable defaults that allow you to understand what you have in your environment.
And so countless times, as you're making all of these variables, I've run into a time where I like there's a function or method that I'm not quite sure what to do with, and I'm a little confused, like what does this parameter mean, and what method should I use? And normally my workflow involves going to the web, finding the documentation, finding the function I want inside the documentation, scrolling through documentation, perhaps getting distracted partway through, ending up watching cat videos, you know, who knows? And that was something I loved in RStudio and I couldn't quite find in the Python world. So Positron allows you to get help for functions, classes, or modules in Python just by adding a question mark next to it. It'll send you directly to the documentation in the help pane, and it gives you kind of that quick and easy information on hand directly for what you want.
It might feel familiar for people coming from RStudio, you guys already had a fantastic help pane, but this isn't something that Python users are used to, so when I tell you this was mind-blowing to me, this is cool stuff here. Especially when you can scroll down and things are interlinked, so you can click through different examples, you can see what, you know, you're helped, you're stuck on, gives you a great place to start.
It might feel familiar for people coming from RStudio, you guys already had a fantastic help pane, but this isn't something that Python users are used to, so when I tell you this was mind-blowing to me, this is cool stuff here.
And after, you know, you've built all your variables, it's time to do some plotting, and nobody makes beautiful plots on their first try. If you do, maybe you've transcended IDEs, I'm not quite sure, it looks something like this in Positron. There's a plots pane that, as you iterate, as you generate these codes in the console, they show up in the plots pane, and you get this filmstrip across the bottom. Between each plot, you can see, you know, where you've come from, what works, what doesn't, as you're trying to build the beautiful plot to explain your data to others.
Or, if you're someone who wants to continue on the same plot object, you can see it automatically update in the plots pane. You can see here, like we're adding different colors, we're adding different labels, and you can also resize and export your plot from the plots pane into a variety of formats. So, you can see we can make it a square, and we can export it as a PNG, JPEG, SVG, or PDF.
Viewer pane and sharing data artifacts
And finally, it's time to communicate this with others. So, how can we share the beautiful data science artifacts that we're creating to others? We have something called a viewer pane. This is also something that might be familiar if you're coming from RStudio, and this plays nicely with the VS Code extensions that you might have already seen and loved, like the Quarto extension. This is interactive HTML that automatically gets populated in the viewer pane. This is a Quarto extension, but there's also Shiny extensions. So, when you run your Shiny app, it'll pop up. You can interact with this directly in the viewer pane. You can also see other things like APIs, like great tables tables, and a variety of other HTML documents.
So, Positron is doing a little bit of interior decorating in your IDE space. It's adding in new furniture and taking out that table that you keep stubbing your toe on. Hopefully, this allows you to walk through your data a little bit more fluently and avoid a little bit of pain. We make these tools to help you because we know data science can be messy business. It comes with its own pain.
The Data Explorer deep dive
My name is Tom Mock. I'm a product manager for Positron, and I'm excited to talk a little bit more deeply about one little area of Positron and how much focus we put on the little design principles within it. So, when you first start opening your data, you might want something like a data viewer, right? In RStudio, there's a data viewer. You can see your grid, or you might be opening things in tools like Excel because you want to kind of walk through your data or feel the data or explore individual cells as opposed to doing group by operations or summarization.
So, of course, we built this into Positron and made it available for both Python and R. But we didn't want to stop with just a data viewer. So, we've actually built what we call a next-generation data explorer. Of course, it still has that data viewer grid that people are looking for in terms of individual cells and the interaction of an indice, a column, and details about them. But we also have things like a summary panel showing you summary statistics that are appropriate for that data, you know, measures of central tendency for numeric data or unique values for strings or categorical data. There's also missing data and column names there as well as their type. And lastly, we also have a persistent filter bar that allows you to create, delete, and see the filters you've applied to your data as you're exploring it.
Now, of course, this is not intended to replace your code-first data science, but be used with your in-memory R or Python data frames. So, let's talk a little bit about that. For the grid design, it's, again, intended to be this polyglot tool. So, it's just as good in R as it is for Python. You can expose these data frames into the data explorer by calling view in R or Python, and that will then populate it into the data explorer or using the workflow that Isabel showed with clicking the table button. What this means is that the code that you write in R or Python also updates the view in the data explorer. So, here, I overwrite a column and change the year from 2013 to 2014, which affects the variable column as well as the summary statistics. So, this is reactive to the changes you make in code as you move back and forth between them.
Beyond that, though, we've tried to make it something that's highly scalable. So, again, in this example, I have 31 million rows, 24 columns, and in real time, I can scroll horizontally or vertically across anything in the data frame, and it will kind of instantly load that data. We do a lot of clever things with caching, fetching different windows of data to try and make it efficient in this way. But we've also sweated a little bit of the small stuff. So, things like sorting. It's not just one column. It's multi-sorting. So, you can sort multiple columns at a time and show which order you've sorted them in and remove different sorting as needed so you can modify your data ephemerally in this way. We've used model space fonts in the grid to show you things like nice decimal alignment, problematic things like white space, or differentiating simply between one, I, and L of various capitalization. And then, lastly, for the grid, we've worked really hard on automatic column width so you can fit as much data horizontally and vertically as possible as opposed to these really, really wide columns when you've got a short variable name and short values.
So, the grid's great, but what about this filter bar? We've intentionally decided to add a filter bar that's outside of the data viewer because it allows you to see the filters you've created no matter where you are in your data. You can imagine I might have 100 columns or 1,000 columns, and I might forget I made a filter on column 1. So, we want you to be able to see them and delete them as needed. But you can always quick add a filter, you know, at one specific column and have it pre-populate that column name. This also gives us the ability to have more rich filtering. So, not just I'm filtering on a single value, but for something like strings it contains or starts with, or even a regex that says, like, okay, this match. And for numbers, we have typical Boolean numeric operations, less than, greater than, or even between two values. So, a lot of power here in how we built the filters.
And lastly, more closing out, we have the summary panel, which again has a lot of different component parts. We have the type. So, as a symbol, we can show you the type and the column name. If you double click on the column name, it'll instantly move you to that column within the Data Explorer. We show you missing data. So, even without having to do an operation, you can see, oh, this column is 100% missing, or it's got a few missing values that I can work on. And then there's summary statistics here that show you appropriate things for strings or numbers or the various different data types. So, this has been a quick run through, again, trying to sweat some of the small stuff in terms of what the Data Explorer can offer you. We're also working on Sparkline histograms and things within the summary panel, and in the future, more direct connections with remote databases. And thank you so much for the time.
Why Positron was built on a new foundation
Hello. My name is Jonathan. I'm a software architect here at Posit. And over the last few talks, we have looked into a lot of Positron's features. Today, I'm going to be talking to you a little bit about how Positron works under the covers. So, by the end of this talk, you will understand the following. You'll understand why we chose to build something new. You'll understand what the big pieces of Positron are. And finally, you will understand how they work together.
So, let me start out with the elephant in the room, which is, why didn't you just build something on top of RStudio? So, to answer that question, we need to kind of go back to our goal from Positron, which Julia talked about a bit. We wanted to make an IDE that was truly multilingual, polyglot IDE, that's focused on data science. And I want to focus in a little bit on that phrase, polyglot IDE.
So, to understand why it's very difficult to build a truly polyglot IDE on the foundation of RStudio, you need to understand a little bit about how RStudio itself works. So, in RStudio, it's basically a two-process system. Everything that is inside the RStudio window comes from one process that runs R, all the computations that you do. It also takes care of saving files, serving up the HTML UI, and doing everything else. This, by the way, is why a lot of RStudio features are slow or don't work well while R is busy. The only other piece of RStudio is Electron, which runs as the Chrome outside the window. It draws the window frame as well as the UI.
Here's another view of the same architecture in boxes this time. And this can kind of give you an intuition for why it's very difficult to add another language subsystem here. There's no place to put it. You can run Python in RStudio, but when you do, it has to run inside of R. So, you can see why this is a really challenging environment on which to build a truly polyglot data science tool.
Let's look at the other part of that phrase. We want a polyglot IDE that is focused on data science. You know, people love RStudio, but we get a lot of comments from people saying things like, you know, I love RStudio. RStudio is really great, but. It's really great, but can I please, please pop out individual panes? RStudio is really great, but can I please have special level control over my themes? You know, could I please, please find files, hidden directories? Could I please save and load custom pane layouts? Could I please have shortcuts? Could I please have gate stash? Could I please have custom BIM key bindings? Could I please have a tree view?
My goodness, we love all these suggestions, but there's a lot of them, right? And these things all have something in common, which is that these are not data science features. These are IDE features, right? And so, with every release of RStudio, we've had to make tough choices about whether we invest in those IDE features or whether we bring data science specific features.
And that's why we made the difficult decision not to build on the RStudio platform when we started the Positron project.
Positron is a fork of another project called Code OSS. And you can be forgiven for not knowing what Code OSS is, but I promise you, you do know what it is, because Code OSS is the foundation for a proprietary IDE that almost all of you have used, which is called Visual Studio Code.
We are not the only people to fork Code OSS. Many other companies have forked Code OSS to make IDEs that are specific for other purposes. For example, there's a company called Cursor that makes an IDE called the Cursor IDE with a lot of AI features. So, we are doing something very similar with Positron. We are taking the Code OSS foundation and adding data science tools to it.
And we've already covered this a little bit in the session, but what that looks
like is taking that powerful IDE foundation and adding tools like environment selections, plots and visualization pane, a really first-class console, an amazing data explorer, and so forth.
So, this brings me to the second elephant in the room, which is, why isn't Positron a VS Code extension?
So, to answer that question, I've got my good friend Twilight Sparkle here.
So, Microsoft learned a lot from their experience with other IDEs. IDEs like Atom, for example, and Emacs, they allow you to load extensions and they become kind of part of the IDE.
This can lead to a lot of clutter and slowness and instability. And so, when Microsoft built Code OSS, they learned to put the extensions in a sandbox and run them separately from the IDE.
The other thing Microsoft learned is that when you give people the ability to do anything you want with extensions, they just can't help themselves. It is a mess, right? And so, Microsoft learned their lesson and Visual Studio Code extensions are fairly limited. They can't contribute custom UI to the Workbench service. They run on that separate sandbox process. They're ephemeral. They can be restarted at any time.
They stop running when the browser is closed. And finally, probably most importantly for us, they don't make sense as a foundation for other extensions, right? R and Python and these other language packs are extensions to Positron. And it's very difficult to build a horizontal layer that provides that extensibility when you are yourself running in the sandbox.
How R and Python talk to Positron
So, finally, let's talk a little bit about how R and Python talk to these Positron features. So, R and Python are extensions. We call them language packs for Positron. And they talk to the code OSS features in the same way that most other extensions do. So, VS Code has an API, which is what allows extensions to contribute things like auto-completion and diagnostics.
So, you've seen a lot of Positron's specific features and we've added a separate parallel API that allows the extensions to not only contribute code completion and diagnostics, but also plug into our console, our plots pane, and the rest of our tools.
It's important to note, then, that those R and Python sessions live in extensions. And this is important not only for extensibility, but also for this reason. How many of you have seen this screen before? Yeah. So, this is what happens when R crashes in RStudio. And the reason that it crashes the whole window is because, as we just established, that window is itself R. Everything is coming from R. So, this is what an R crash looks like in RStudio.
Here is what an R crash looks like in Positron. It's nothing. It is horribly obliterated. You will lose anything you've got in memory because your R process crashed, but the rest of the IDE will continue to run very smoothly.
You will lose anything you've got in memory because your R process crashed, but the rest of the IDE will continue to run very smoothly.
Now, the final reason that it's really important to have all these things in extensions is that this allows Positron to be extended to other languages in the future. And this is something Julia alluded to really well, which is that we want Positron to be a foundation upon which more data science tooling can be built. And all of the R and Python code that we have written plugs into a public API that anybody can write for. So, it's not tightly integrated into the core. Everything in the Positron core can be added to by anybody via a public API.
So, we have Positron and we have these language packs. I want to talk for just a minute about how those two things talk to each other. So, when we built Positron, we wanted to use standard protocols for standard functionality. And what that means is that when those R and language subsystems talk to Positron, they use protocols that have already been established in the data science community. When we run an execute code, we are using the Jupyter protocol. When we do completion and diagnostics, we're using the language server protocol. We've only added our own protocols when we have Positron specific features that we need to power.
So, quick recap. It is a polyglot IDE. It's focused on data science. It's a code OSS fork like VS Code is. Those extensions live with language features. We use existing protocols wherever we can to make it easy for other people to plug in. And we have a public API that lets anyone add new languages or features.
Introducing Arc
Hello, my name is Lionel, and I'm here with my colleague Davis to talk to you about ARC, which is a component in Positron.
So, Davis and I are from the Tide Divers group, and we've been working for a number of years on packages like dplyr. And for the last year, a bit more than that, we've been working on Positron with the mission to make it easier for other people to use Positron. To help making R support the best it can be in Positron.
So, we've seen with Jonathan that Positron is a multilingual IDE. And we've seen with Isabel that we've broadened our scope to include Python. And so, the question that we want to answer in this talk is, where does that leave us with R?
And the answer is that we wanted to make the R support the most modern it could be, and the result is ARC. So, when you use R in Positron, ARC is behind most of what's happening. So, if you type R code and get some completions, ARC is providing the completions. If you need to execute a piece of R code and get some output from R, that goes through ARC as well.
So, what does it take to make a great development experience for R? There are three main things that ARC is concerned with. First, code execution, so sourcing of script or executing a piece of code. Code assistance, so that ranges anything from completions to diagnostics to let you know that there might be a problem in your code even before you execute it. Or contextual help. And the final piece is the debugger. We want to make the debugging experience in Positron the least frustrating it can be.
And each of these areas is backed by a standard protocol, and we'll see in this talk why this is important and why it matters. And we'll start with execution.
Code execution and the Jupyter protocol
So, here you have a classic Positron setup. You have an open R file with a bunch of code. You have a console and a plot pane. And the user here has created a data frame, got some output in a console, and created a plot. So, where does ARC fit in this picture?
So, you can think of code that you execute in Positron as a question that Positron asks to ARC. ARC does a bit of magic and then provides an answer back to Positron, which is able to display the output in the console. The same thing when you create a plot. ARC does a bit of magic after getting the question from Positron and provides the answer back to Positron.
So, the question is, how does this work? What is the language that ARC and Positron use to communicate with each other?
And to answer this, we'll take a step back and look at what's going on in the Jupyter world. So, here we have a Jupyter notebook. If you're not familiar with this way of doing data science, you have a document made up of cells. You can write code in the cells and you execute these cells and you get the output included in the document. So, this is very popular in the Python community.
But the thing about Jupyter is that it works with multiple languages. It's multilingual, just like Positron. And it's even in the name. So, if you did not know, Jupyter stands for Julia, Python, and R. And so, the way they pull this off is not by implementing support for all these languages. They have independent backends called kernels. And so, when a Jupyter notebook needs to execute a piece of code, it's like a question. The kernel gets the question, provides an answer back to the notebook.
And Jupyter came up with a standard set of questions and answers. And in this case, it's an execute request that is asked to the Jupyter kernel and the kernel provides an execute response back. And that's exactly what we needed to communicate between Positron and Arc. And so, Arc is a Jupyter kernel.
And actually, in this notebook, this is Arc running in the background, running the R code for the notebook. And so, in Positron, it's the same thing. You run a piece of R code. This is an execute request from the Jupyter protocol. And Arc provides back an execute response.
And the nice thing about this is that it doesn't have to be a Jupyter notebook. It doesn't have to be Positron. It can be any project that implements the Jupyter protocol. So, a few weeks ago, we were super excited when we've seen that the Z people saw this new idea written in Rust that implements many interesting ideas. And a few weeks ago, they've implemented support for Jupyter notebooks and they made sure that Arc would work great in Z. And so, here you have R code running in Z. Using Arc. And we hope that many more projects will be able to do the same in the future.
Code assistance and the language server protocol
While code execution is certainly a very important part of this, it's not the only piece of the puzzle, or not all pieces of the puzzle. We also think that it's really important to have fantastic code assistance inside of Positron. Now, code assistance just means anything that makes it easier for you to write R code. That could look like diagnostics, where we analyze all the files in your project and can pop up a little tooltip that says, hey, we think something's wrong here. You might want to take a look.
Code assistance could also look like a function signature, where you're working with SliceMax. You don't necessarily need to remember all of the arguments. We can pop up a signature and say, here, hey, here's what they are. Assistance could also look like jump to definition. Jump to definition looks like this, where you can click on SliceMax, and that takes you straight through to the definition of the function inside of your project.
Now, these are features that you might have been familiar with in RStudio, but Positron has a number of code assistance features that are unique to it as well. One of those is help on hover, which I really like. It looks like this, where you hover over SliceMax, and you get this really great inline documentation immediately. This is great whenever you're actually just kind of in the flow state of writing R code. You don't necessarily need a whole help pane. You just kind of need to quickly remember how something works. You hover over it, get what you need to know, and you go back to work.
Now, these features in Positron work in a very similar way as executing code. Code execution worked through the Jupyter protocol. It allowed us to ask questions and send back answers, and code assistance works in the same way. With the Jupyter protocol, that really allowed us to standardize these questions and answers. With code assistance, we used the language server protocol, which standardizes the questions and answers in a very similar way. We ask a hover request of Arc, and Arc can send back a hover response in return.
The reason that, again, that is so cool is because Arc doesn't care who's on the other side. It doesn't care who's asking the question. It could be Positron, it could be a Jupyter notebook, it could be some other IDE. As long as it implements the other half of the language server protocol, you're in business.
TreeSitter and the R grammar
Over on the right-hand side here, our magic 8-ball, Arc, is doing quite a bit of work to actually send back these responses. Part of the smarts of Arc is wrapped up in a technology called TreeSitter. The only thing you need to know about TreeSitter in this talk is that it takes in all of the R code in your project. We run it through TreeSitter, and it spits out a structured representation of that code, which honestly doesn't even look like R at this point. However, we can use that and power all of the assistance features that we've been talking about today.
Now, we think TreeSitter is really cool as a project because it works with any language. As long as you have a grammar that teaches TreeSitter how to work with that language, then you're good to go. The problem was we didn't have an R grammar for TreeSitter, so we had to build one. Now, we've built it to work with Arc and Positron, but as it turns out, there's actually a lot of community benefits to having an R grammar for TreeSitter. For example, if you were to bring that R grammar over into Zed or NeoVim or other editors that support TreeSitter, it can power things like syntax highlighting or indentation immediately over there as well.
And there's also one other big player that uses TreeSitter. It's GitHub. If you've been on GitHub in the past couple weeks, and you've done a search, say, for case when on dplyr, you may have noticed that the search results for R have gotten really, really good. In this case, we found a function called case when. If you click on that function, it will jump you straight to the definition in the project.
This is just like jump to definition in Positron itself. It's a great way to actually explore a new project without having to pull it down completely.
The reason this works is because behind the scenes, GitHub code search uses TreeSitter. Now, up until a few weeks ago, this did not work for R because there was no R grammar for TreeSitter. We built one. So we were able to work with the team at GitHub on their code search engine and get them to incorporate our R grammar into their code search engine. And as of a couple weeks ago, it doesn't just work for dplyr. It works for all R projects, cost GitHub.
The debugger
I have one more thing about Arc that I want to talk about today. That's the debugger. Now, if you've never used a debugger before, you probably have done something like credit debugging. That's the idea of sticking in a whole bunch of print statements inside of your functions, rerunning it again. Hopefully, you get some more information out of it and can figure out where the problem is.
A debugger is one more step beyond that. You actually get to step through that code one line at a time, stop at any point like we've done here inside of mutate, and then kind of investigate the world around you. In this case, you could use the debug variables pane and see what variables exist at this point in time and what their values are.
It probably won't surprise you to hear at this point that we've implemented the debugger through just another set of standard questions and answers. For example, Positron might ask Arc, hey, what variables exist at this point in time? Arc sends back a standard answer and that populates this variables pane you see here.
Now, with code execution, we use the Jupyter protocol. With code assistance, we use the language server protocol. With the debugger, we use a third called the debug adapter. Now, I have one demo of the debugger that I'd like to show because I think it's super cool. This is the most mind-blowing feature.
So, I'm a tidyverse developer, so I work on dplyr quite a bit, and that means I debug mutate quite a bit. So, for better or worse.
So, I have gone ahead and set a breakpoint deep inside of mutate here. We can trigger that breakpoint by running the code. That drops us directly inside of mutate. We can do a couple of steps here to step through the code. You'll see the debug variables pane populates and you get your very important variables here and their values.
But I actually want to talk about where we've stopped. We've stopped on a very important place. It's the boundary between the R code of dplyr and the C++ code of dplyr. As tidyverse developers, we write a lot of C and C++ because we want the tidyverse to feel as fast as possible for you all. We know we're not alone. We know that you write a lot of packages with rcvp, cpp11, because you want your packages to feel fast too.
But that typically comes with trade-offs. While you get performance, you end up losing a lot in terms of debuggability. You can't step through the code near as easily like in RStudio like you can with R, and you kind of end up resorting back to print debugging like we talked about before.
However, in Positron, you can do this. One more step, and we've stepped directly from the R code of dplyr into the C++ code of dplyr. This is absolutely insane. It's something you've never had before, and you have all the same tools available. The debug variable is paying. You can step through the code. You can look at the call stack. You have a debug console. Everything is just there.
This is absolutely insane. It's something you've never had before, and you have all the same tools available.
The way that this works is because on the R side, we implemented the debug adapter protocol. Someone else has implemented the C side of the debug adapter protocol. As they use the same set of standard questions and answers, they just work together. You can step from R to C and even back, and everything just works. It's pretty magic. That is the power of using the modern and standard tooling inside of R.
Arc and the R community
So Arc knows a lot about R, and it does a lot to support the workflow of R users in Positron. It does this with standard protocols and technologies. We've seen three ways in which using standards like this allowed us to contribute to the development of the R code. Allowed us to contribute to the community and reach a larger audience.
So we've seen how R can be used not only in Positron, not only in Jupyter Notebooks, but in any front-end that implement these protocols like the ZID. We've seen how by providing an R grammar for TreeSitter, we were able to implement tons of useful features for Arc and Positron, but also contribute to other projects like GitHub and all of the users. And finally, we've seen how as Thai-diverse developers working with Positron, we were able to benefit from a C and C++ debugger implemented by another group in the same way that our R debugger will benefit other projects.
And so that's the great thing about using these standards is that the functionality is not locked in. So you can be a Jupyter Notebook user and use Arc and benefit from all this functionality in the same way that Positron users are.
And so on a personal note, when I learned that Positron would implement R support in this way, I was super excited. Because despite having worked for RStudio for a long time now, now Posit, I've never actually been an RStudio user. So when I was a student, I learned to use Emacs. And when I joined RStudio, this was a tool I was familiar with. So I kept using it to develop Thai-diverse packages.
But I was a bit jealous of my colleagues that were using RStudio because obviously the R support is very good in RStudio. And completions, for instance, were much better than what I had in Emacs. So with Arc, I immediately saw that I could write a bit of glue and having Emacs talk to Arc and finally enjoy the same level of functionality as my colleagues.
So that's not what happened in the end. I switched from Emacs to Positron. And with the ecosystem of VS Code extensions, I don't miss much from my previous setup. So I have everything that I need to do my R work and work with other languages in Positron. But the point is that I didn't have to switch. Like it was a free choice.
And so while there's still a lot of work to make this a reality, that's the promise that we want to deliver with Arc. That no matter what tools and environments you're using to do your R work, Arc will be there to help with that.
Tips for RStudio users trying Positron
Thanks for attending the exciting Positron session. So you've heard that Davis and Lionel were lent out from the Tidyverse team to the Positron team. And if you just scooch that little logo away, you see that I too am on this very exciting adventure. And I have perhaps found it even more exciting than they have.
And there's at least two sources of excitement, I'll call it, or a lot of personal growth. So one is having to write in programming languages that are quite new to me, and that's pretty stressful. So there's been a lot of personal growth, but also working in a new IDE feels super uncomfortable. And so you're seeing Positron here. But so all my work over the past year or so has happened either in VS Code or in Positron, and that's required a lot of adjustments.
And as we're all saying, no one needs to make this switch. But if you're a longtime RStudio user and you want to take Positron out for a test drive, I want you to have a good experience. So these are going to close with a few tips for how to make that test drive as successful as possible.
So my first tip, which will surprise no one, is that I encourage you to work inside a workspace or a folder or a project. It's a really important concept in Positron. The good news is that really is just a folder. You can make it more complicated, but you do not have to. Analogous to a project in RStudio.
And there are many areas of the Positron user interface that are warmly encouraging you to open a folder. And that allows all sorts of IDEs to turn on cool features for you. So once you're in a folder, for example, your file explorer will come to life. In Positron, because this comes from VS Code, you can't even browse your files until you open a folder. And that'll allow you to see the files and folders inside your workspace. And it will also set the working directory for your interpreter, whether it's R or Python correctly.
Another super exciting feature that you saw earlier that is truly new for R users is it's actually quite easy to have multiple versions of R living in harmony on your computer and to switch between them with quite a lot of fluidity. So you'll be able to access that in this interpreter dropdown that we've shown you. And if you have Python installed, it will be up there as well. But really important for the R users is you will have multiple versions of R there if you've installed multiple versions. And the console will always be reminding you which one is currently active. So I think in this case, I have R Devel, the current release of R and the old release of R.
And so I want to give a quick shout out to a tool called Rig. This is not part of Positron, but it's a separate little tool that is newly important, because it helps R users manage multiple R installations. So it'll help you install multiple versions of R and switch between which one you want to have as your current default. And little known fact, this is actually easier to do on Windows than on Mac, which is like a first for anything. So this is actually especially important for Mac users to have multiple versions of R that are actually fully functional.
And the new IDE gives us a chance to pick new defaults. So Positron will default into a blank slate lifestyle, meaning when you fire it up, your workspace is going to be empty by default. And when you leave, we also aren't going to write that to file. You can live differently, but we're going to try to help people do this because we think it's good for the long-term reproducibility of your work. Because if you have really important objects, you really want to save the code that made them. And if you have a really, really important object, you want to explicitly write it somewhere instead of having it sort of live in your global environment.
for the long-term reproducibility of your work. Because if you have really important objects, you really want to save the code that made them. And if you have a really, really important object, you want to explicitly write it somewhere instead of having it sort of live in your global environment.
Another really important concept in Positron is the command palette. RStudio has a command palette, but at least as a longtime user, it came late enough in the game that I personally never started using it, as Tom well knows. And you really need to use the command palette in Positron, I would say. So control or command shift P will bring up this beautiful, wonderful, long menu of commands that you could run as a very great fuzzy finder. So you just start typing something related to what you think you want to do. And here I've brought up a whole bunch of commands that are super relevant to R.
And in particular, you'll see lots of R package development commands here. So a lot of things that you might be used to doing in RStudio with a button or some highly specialized pane, like the build pane, are available in the command palette, Positron. But they're there, but they're not sort of smacking you between the eyes as much. So you will go look for them here.
Positron is very customizable. So you're probably going to want to work on your user settings. And if you search in your settings for RStudio, there is an optional RStudio key map that I think most RStudio users will want to enable. So check this box. And your usual keyboard shortcuts from RStudio will start working and doing the same thing inside Positron.
And another thing you might want to do is customize your layout. So that's another thing you can access from the command palette or from the upper right. And you'll be presented with a menu of kind of inspiring looking layouts. And the top three are all Positron specific. And they're layouts we think you might like for doing data science work. And the very top one, stacked layout, is the most reminiscent of the four panes you're used to seeing in RStudio.
So the last thing I want to talk about is this activity bar on the left. And I want to demystify a few of the icons there. So the one with a lot of little boxes is how you get insight into your extensions. So you might go there at first and you either don't see anything or you're being invited to search for extensions you might like. And it allows you to install extensions from the open VSX registry. And this gets at the thing that Jonathan was talking about. There's lots of capabilities you might want to add to Positron that don't have anything to do with data science.
So I love rainbow indentation. And so I have this rainbow indent extension. And this is a sampling of the kind of extensions I tend to have enabled in Positron.
Right below that is this little flask. So if your current workspace is an R package that uses TestFat, this will open a test explorer. I don't think many people have discovered this. So this is like a little Easter egg. It will give you insight. It'll show all of your test files, all the individual test cases within them. Helps you to navigate. You can execute them one at a time by clicking on them. And you have a little icon that's green or red showing you the current passing versus failing status.
Acknowledging the team
So seven of us got the pleasure of giving these talks to you today. But I want to make sure that you know this is a product of a much larger team. So these are all the people past and current who have contributed to get us to the point where Positron is today. So I want you to see their names. I want you to see their faces. And we would all like to acknowledge everything they have done.
Installing Positron and Q&A
And that's the end of both my talk and this whole session. So we will have a chance for questions. If you want to install Positron with this sort of beta mood we have here, you still need to go to a GitHub repository, which is this one up here. I would go straight to the wiki, which will give you actual installation instructions. And then we really look forward to having you take it out for a test drive and give us feedback on what's missing, what's working great. And we can't wait to hear from you. Thanks.
Testing. There we go. Thank you so much for that. I am so excited for Positron personally. I have a few questions for you. And I'm going to try and batch some of the questions together. So if I don't get your exact questions, sorry.
What is Positron still missing today that currently is supported in RStudio? Why would someone want to wait to adopt Positron? I'll give one answer. One thing that is not yet implemented is inline output in Quarto files and some of the complete affordances around R Markdown. So the Positron leans on the Quarto extension for this kind of work, whether you're writing Quarto files or R Markdown files. So a lot of functionality is there and will really get you off to a good start. But if you have really advanced use cases or very specific preferences in terms of how your code is executed, that might be something to stick with RStudio for. So there's something else we should add to that list, R Quarto. That'd be a big one. That'd be a big one right now. Thank you.
Are all VS Code extensions compatible with Positron? What is OpenVSX? And especially, can I use GitHub Copilot? Perfect. Yeah. So Positron uses a extension marketplace called OpenVSX. OpenVSX is a vendor neutral repository of VS Code compatible extensions. So Cursor uses that, Positron, VS Codium, a bunch of different forks that are maintained of Quarto SS. There are some notable kind of, I guess, extensions that people ask about. I think someone actually just said Copilot. So GitHub Copilot is one that's not available on there, although there are, I think, 10 or 11 other providers of generative AI LLMs. And Jenny was actually using Continue if I saw. Okay. Continue is actually a local model use. So you could use like Ollama to run a generative AI tool locally on your laptop or your machine, pay nobody, and never kind of like send your data out. So there's some good options there.
Thank you. What is the timeline for Positron on Workbench or PositCloud? Soon on Workbench. So I'm also the product manager for Posit Workbench. We're actively working on Positron sessions there. Jonathan is actually going to be doing a lot of work along with a few other devs on the Positron team for integrating that along with the Workbench team. So stay tuned. It will still be in preview on Workbench planned for this year, but we'd love to hear feedback about when it's there.
Thank you. Will there be push button deployment to Posit Connect for Shiny apps documents like there is for RStudio? And actually, I'm going to take this one because a team that I am on is working on that. So yes, there will be. It's actually available in beta. You can go to the OpenVSX marketplace. You can use it in both VS Code and Positron. Try it out. We'd love to hear your feedback. Yeah, so it's in an extension, which really highlights like the value, like why some of these choices we made are just paying off in some great ways, like the Quarto extension, the Shiny extension, the Publisher extension. Like by making some of these choices, we're really happy with the user experience that is starting to grow up around this.
Awesome. Let's get to some later ones. Is there a dark theme? Yes. Well, OK, yes, but also you can, like there's one zillion extensions for themes so you can. There are, I think, three built-in themes to Positron, but you can make, you can bling out your IDE like Isabelle's is always like Barbie Pink and what some of our co-workers add little extensions where like pets are running around on the bottom, like little animals are animated. Like because we, these extensions are available, your ability to customize what it looks like is very new. For as you are coming from RStudio, the extensibility and customizability is extremely high.
Data, debugging, and larger-than-memory
How does Positron handle larger than memory data? For example, does it still try and compute potentially expensive summary statistics like the number of unique values? If you're asking about the Data Explorer specifically, there are some built-in guardrails, but again, it's kind of the idea of the Data Explorer works with in-memory data already. There's some long-term stuff we'd love to do with DuckDB on predicate pushdown, basically doing some of the Data Explorer things with on disk out of memory data, but that doesn't exist today. For R and Python, it would be the same story of there are tools like Arrow, DuckDB, databases in general, where you can make queries in R or Python that communicate with an external resource or on disk data.
If you are debugging a reticulate package, does the arc debugger step through the Python code? Will it step into Cython parts as well? No. We thought a little bit about that, but we are also not sure there will be a lot of use cases, but that's certainly something that we could look into if there were. We do have some issues open about like increased reticulate support. So if that's a particular interest of yours, you know, search through, find those issues, add info about your use case, thumbs up, so that we can prioritize increased support for particular reticulate use cases versus other stuff that's on our plate.
RStudio vs Positron going forward
Is it correct that RStudio will be maintained going forward and there will not be focus on new features or both? Well, I mean, RStudio has some got some great new features lately. Tom, you'll be a great one to speak to this in detail. Yeah, luckily, Kevin was the person kind of keeping us all on time. So Kevin and Gary, Ron and a few others are still working on the RStudio IDE team. So you can imagine that this is, again, an expansion of our focus where we have a brand new team working on the new IDE and then another team working on RStudio. So committed to maintaining and improving RStudio. Some of the feature requests that Jonathan highlighted that are like theoretically impossible to do in RStudio. Some of those might come to Positron, but this is not kind of the end of RStudio as much as like there's a new project that's working in parallel.
Thank you. How is the Git pane compared to RStudio? That's a great question. It's been, I'll be, I'll be totally honest with you. It's been a little divisive. I prefer the Git experience in Positron because it's, it is, it inherits from VS Code. But for some folks who have come from RStudio for a long time, it has taken a little bit of an adjustment. Do you want to speak to it at all, Jenny? Like the adjustment or? People just want me to, you know, threaten to burn a computer down. I do use the Git functionality a little bit in Positron, but I did love the Git functionality in RStudio more. So I just find that I usually have another client running. So, no. Okay. See, the license man, I'm on the other side of this. Like RStudio is good, but like Positron is amazing. I completely changed the way I used like the Git stuff over there. And to be fair, you do use an external, like a third party, like a Git thing most of the time I would say. So I was like only RStudio. That was my little bit of Git experience. So to go from that to Positron for me was just like, it opened like floodgates. I think it's really good. I'm with Jenny on this one. I love the simplicity of RStudio's Git. And if I need anything more than that, I go to the command line. But again, divisive.
Extensions, APIs, and project files
For R package developers who created integrations with RStudio, will they need to learn how to build VS Code extensions or does Posit intend to offer tooling around this? We don't. Anybody? TBD. We can do that. I could talk. I could talk about that for just just a second. So Positron does implement a fairly large subset of something called the RStudio API, which is the way that R packages talk to RStudio and control it and automate it. Packages like use this and so forth. Use the RStudio API a lot. And a lot of those API calls work today in Positron. But not all of them. So there is some support. The other thing we don't currently support is RStudio add-ins. So if your package includes an RStudio add-in, that doesn't currently integrate with Positron, you know, other than the existing kind of RStudio API calls that are in the package. So those are both areas that we are working to improve. And that's support for. But as of today, what we have is a support for a limited subset of the RStudio API.
Do our project files load normally in Positron? It is not used by Positron. Positron's sense of what is the space in which you are working is more about folders. So there's not an explicit file that it's looking for to say, this is my project. You can open a folder as a workspace and then you get those benefits of workspace project-based workflows. But there isn't an explicit file. We know things like here work great in Positron, depending on the specifics. I have not run into anything that had a problem with something like here. So in many ways, it's like lowered the bar for having a encapsulated, this is what I'm working on right now. So think about a workspace equaling approximately a folder, equaling approximately RStudio projects. Like they're basically all the same. And I'd say it's actually, there's less to worry about than there was before.
What does the Positron logo mean? It is a P for Positron and it's a particle. And yeah, that's what we've got so far. Yeah, nothing more deep than that right now.
SSH, environments, and collaboration
Can we connect to existing servers via SSH from Positron? As of yesterday, yes. It is a very experimental feature. But if you, since you're all here, I can tell you there's a secret setting that we added, which is no longer going to be a secret ad for today. But there's a setting called experimental remote host. So if you go in your settings in Positron and search for that, it will allow you to connect over SSH and run R or Python on a backend Linux system. Perfect.
Is there support for using Rn environments, like you can use Python virtual environments and select them from the drop down? Or is that just the interpreter? Just the interpreter for now, but there is an open issue about an enhanced kind of environments pane that gives you more UI around choosing like Rn kind of environments. Rn does work as of today but it works in much the same it works like in RStudio that you'll pop in, you'll get that, use that library of packages. If you're particularly interested in, I'd like, you know, I want to have more UI gestures around dealing with my Rn environments. There's an open issue that we'd encourage you to add any details or to thumbs up.
Will it be possible to share a Positron workspace for collaboration, like with LiveShare? So LiveShare is another one of the proprietary extensions that works only with VS Code, for example. So in the future, there might be more collaborative experiences. That's, you know, a goal of what we can do with Positron. You can kind of think of in RStudio, both in Positic Cloud and Workbench, there was an idea of project sharing, which had real-time collaboration as well as directory sharing. I'd love for us to go in that direction, but that's more on like the roadmap as opposed to today.
Can we run Positron in AWS EC2? Positron is a desktop IDE. You have a remote kind of SSH, the work that Jonathan was alluding to, where you can say, my ID is local, but my compute is connected to a remote server, or you can have it on Posit Workbench, which could run either on on-premise servers, AWS, Azure, Google, wherever you want. Will Positron be integrated for use with Databricks like RStudio is, and when? So, double-parted question.
There is a Databricks extension that already works with Positron. So that you could use from, again, like your desktop and connect to Databricks for data access or Spark compute.
Posit Workbench would add on managed credentials, which is an IDE, and then you can run Posit Workbench on your own, and then you can run Posit Workbench which is an idea of like, rather than using personal access token, it knows who you are and, you know, understands the data governance and applies that to your user space. So you don't have to worry about any credentialing there.
Why not call it Python Studio?
Okay, we've got about two minutes left. So I'm going to ask a possibly trolling question, but why not simply call it Python Studio?
Well, I mean, the real answer there is that this is our vision for this, is that it is for multiple languages, for data science. Like today, you know, many of us are using R and Python, but it is, that may not be true moving forward. There's really exciting stuff happening in the data science space, and we want to build something that allows us to have the flexibility to add new language packs as they become important.
So it truly is like, and, you know, those of us who have worked on it, in some ways it's kind of a headache because there's a lot of layers, a lot of like, oh, this part can't know about R, but this is the part that knows about R, but it is on purpose so that we can build a tool that will support you for quite a long time, be an excellent tool for your data analysis, depending on, you know, what happens 10 years from now, 20 years from now, as you move on in your career.
So it is, you know, it is not PyStudio the way like an RStudio for a Python would be. It is something that is built to be truly, truly polyglot.
So it is, you know, it is not PyStudio the way like an RStudio for a Python would be. It is something that is built to be truly, truly polyglot.
I'll give an equal kind of trolling answer, which is one of my good friends at Posit, by the way, Posit, Positron, there's some connection there, but my good friend, Ron Bloom, Posit Ron, and he's a QA engineer that does some testing. So that's the real secret is it's named after him.
Let me say one final thing. So us as a team and anybody else who's here at PositConf who is working on Positron is going to be in the lounge tomorrow morning. We're going to have an open Q&A, a more casual Q&A. So if you want to come up and ask us questions, we invite you before the keynote tomorrow to join us in the lounge.





