In this episode, I'm joined by JJ Allaire, founder and executive chairman at Posit,
and Carlos Scheidegger, a software engineer at Posit, to explore Quarto, an open source tool
revolutionizing technical publishing. We discuss how Quarto empowers users to seamlessly transform
Jupyter notebooks into polished reports, dashboards, ebooks, websites, and more.
JJ shares his journey from creating RStudio to developing Quarto as a versatile multi-language
tool while Carlos delves into its roots in reproducibility and the challenges of academic
publishing. Don't miss this deep dive into the tool that's shaping the future of data-driven
storytelling. This is Talk Python to Me, episode 494, recorded December 20th, 2024.
Are you ready for your host? There he is.
You're listening to Michael Kennedy on Talk Python to Me. Live from Portland, Oregon,
and this segment was made with Python.
Welcome to Talk Python to Me, a weekly podcast on Python. This is your host, Michael Kennedy.
Follow me on Mastodon, where I'm @mkennedy, and follow the podcast using @talkpython,
both accounts over at fosstodon.org, and keep up with the show and listen to over nine years
of episodes at talkpython.fm. If you want to be part of our live episodes, you can find the live
streams over on YouTube. Subscribe to our YouTube channel over at talkpython.fm/youtube and
get notified about upcoming shows.
JJ, Carlos, welcome to Talk Python to Me. Great to have you two here.
Thanks. Great to be here.
Thank you. It's great.
It's really fun to have you both here. It's the week of Posit for me here at Talk Python,
just coincidentally having two groups from Posit on at basically almost the same time, right?
Last recording, last episode was Great Tables, which made me have a much deeper understanding
appreciation for what you can do at Tables. I thought, well, what is there more than kind
of an Excel look to it, you know? Formatting, maybe?
Yeah. That's what most people think, and then they see like four examples and like, oh,
yeah, that's right. I see.
Yeah, exactly. But Note Tables, well, there might be a table in the presentation today,
but that's not the topic. It's more about leveling up your notebook game, right?
Yeah, I think that's the most sort of straightforward win for Python users is sort of the ability to go
from a Jupyter notebook to a website, to an academic article, to a report with parametrization,
to an e-book, sort of growing from a notebook to the many different ways in which you want to share
it with people.
I mean, put maybe just a little bit more broadly, you know, we data scientists create all kinds of
very, very valuable things with their code. And this can be, as we said, you know, tables,
it can be visualizations, it can be the results of models. And then how do I project that out into the
world? How do I make it valuable for other people? And a lot of times that means turning it into some kind
of production output, you know, a PDF, a report, a dashboard, you know, a website. And so I'd say
that's, you know, in the large, what Quarto is about.
Yeah, I think it's a super cool tech. I've been hearing a lot of people recommend it lately, which
is always a good sign, always encouraging. Before we dive into that whole side of things, though,
let's hear a little bit about yourself. You know, who are you, quick introduction, and how'd you get to
working on Quarto and data science and all that? Sure. My name is JJ Allaire, and I have been a kind
of software tool builder for, I guess it's almost 30 years now, which dates me quite a bit. But I've
worked on lots of different... That catches up on you. It's really like, what? Yeah. And I've worked on,
you know, web servers and development tools and authoring tools and programming languages and lots
of different things. But about, I guess, coming up on 14, almost 15 years ago, 14, 15 years ago,
I decided that I wanted to focus on open source software. And I had early in my career, prior to
becoming a software engineer, I was very into quantitative analysis for economics and political
science. And I used a bunch of the tools that were available at the time. And so I, when I found out
about, this is actually even before, like, PyData was a thing, before Pandas was a thing, I was like,
oh, there's open source statistical computing. R, amazing. I can just work on that. So that's kind
of what I did. I set out to improve the, I'd say, the computing tools around R, and I worked on RStudio.
And then that has, I won't go into all the gory details of that. But really, that led into a lot of
these use cases, because a lot of the people using R were trying to figure out how to share and publish
their work, whether they be writing scientific articles or inside a company presenting things.
And so I worked on a thing called R Markdown, which was like, you know, merging R and Markdown
for publishing things. And then that more recently led to, wow, like, it's great that we did this thing
for R, but that's like 10% of the universe. So can we generalize this? And that was like the
Genesis of Quarto, like, let's generalize this idea and make it truly multi-engine. And it really is.
It works with R, it works with Jupyter, it works with, you know, the Julia, is it the Plato? No,
no, the Julia. There's a Julia engine. There's two Julia engines, actually, that it works with
observable. So the idea was like, let's take this core idea and make it work everywhere where there's
interesting computations happening. So anyway, that's a little money.
Yeah, amazing. And if you capture or have tools for the Python space and for the JavaScript space
and the R space, that's a good coverage of the data science world.
It seems to be, yeah. Yeah. That was our idea. Yeah. Awesome. Carlos, how about you?
Thanks. My name is Carlos Scheidegger. I'm an engineer here at Posit. I've been working in
on Quarto since I joined about two and a half years ago. My background is in computer science. I'm a
recovering academic, like I tell folks. I came to the US in 2005 for grad school. And I was working on a
completely different area. I was working in sort of like geometry processing, computer graphics.
But as part of my work in research, I started realizing that a lot of the experiments we were
publishing in papers had sort of a depth of like parameter settings and sort of choices and things
that like really dominated the output result. And it was really hard to go on a paper and see what was
happening there and sort of be able to figure out like what were the choices that someone made when
they published the work? How do I compare my work to theirs? And so I switched and I, as part of my
graduate work, I built a system in Python for sort of reproducible computational analyses and sort of,
how do you share these work and sort of, you know, as you're sharing like a PDF, you'd get like all of
the parameters and all of the things that came with them. So this was back in, you know, 2008, sort of
ancient history at this point. I then sort of joined AT&T research at that point and they have a really
strong R team there and sort of started doing some related work there. And that's sort of how I crossed
paths with JJ as they were founding our studio back a long time ago. And we more or less kept in touch.
Yeah.
So I eventually joined academia and kept interested in sort of this work on how do we make sure that the
experiments that we have are as easily shareable as the artifacts that we end up all reading, like the PDFs,
websites, but if you need to go back to figure out that what did actually happen there, we want to make
that as easy as possible. And so the idea of Quarto resonated really strongly with me. And so as I was
realizing that there's a lot of academia that I didn't, wasn't a great fit for me personally,
we can have a separate conversation about that. I reached out to JJ and he talked about Quarto and said,
this sounds like a great project and we really hit it off and I've been working on it since,
since we started. So that's how I ended up here.
That's cool.
That's right.
I think there's a lot of overlap on the data science side between our people, Python people,
and our tools and Python tools.
There's a lot more overlap than I think folks realize from the outside. And when you sort of notice
that like the people working on these tools end up sort of picking the tool that's best for the job
and Python is fantastic. Like I've been writing it for 20 years and sort of you find people trying
to find similar solutions to problems and sort of some things are more easily expressible or easily
to reach for in one language or another. But I think in 2024, the story is that more often than we realize
like teams and even people are like, they're polyglots, right? So they will speak like they will write
enough Python, they will write enough R, but they want something that sort of works together as well as you
can. And so that's something that we've focused on for two very, very explicitly. So you can have a
website in which, you know, half of your team is working in R and half of your team is working on
Jupyter notebooks, and they both can work on the environments that are most observable.
Yeah.
Or observable.
So directly in HTML and JavaScript.
So that's really part of what we're trying to do is sort of make it as natural as possible for people to keep
continuing their work, but then be able to publish it and sort of not forget like all of the computational
things that came with it and make it easily accessible.
I think also another demographic, another group in this is the people who are receiving the research,
receiving the stuff. They might not be either of those people. They don't want to see a bunch of code
and then a DF.head and then a plot. And then they want to report looking thing.
That's right. Yeah. And there's, we've definitely done a lot because it really does vary. I would say
the preponderance of people are in that category. I would say maybe 80, 85% of the people are in that
category, but then you do get the, the odd person who says, well, wait a minute, you know, where,
where did this come from? So we have a bunch of things, you know, like for publishing notebooks,
they'll let you, you know, interactively show the code or not show all the codes. Don't,
you know, show the source code. You know, we have a feature where like you see a plot in a,
you see a plot in a website and it just, it's just as a plot. There's nothing. And there's a
little text here at the bottom that says source notebook. You click it. Now, suddenly you're in
a notebook that you're in a lot. So ways to make it available, make the computations available without
hitting people over the head. That's cool. It's almost the equivalent of right-click view source
of the early web. Right, right, right. Exactly. But that's right. Yeah. That's very much.
But really to your point, I mean, that's why when I say production output, it's like the quality of
output that people are used to getting, you know, out of like office, or when people make
professional PDF reports, that's kind of what people are looking for at some level. Sometimes
people just want, Hey, just give me the information. I don't need it to be, but a lot of times they want
the production quality. And so we do spend quite a bit of time on making that possible.
Sure. And I would say the other thing that it's seems like this solves a bunch is the,
I have a notebook I created myself. How do I share it with the world? Yeah. Yeah. Right. A lot
of data scientists are like, there's interesting solutions out there, but there there's a lot of
uncertainty on what to do. You know, do I need to learn how to do Django or flask? Probably not.
Right. Right. Do you lean on something like streamlet where you kind of program to their model,
but it's cool and interactive, right? What do you do? You export to a PDF and just, or HTML, just here's
the notebook, but static, right? None of those are streamlets and pretty interesting option, but it's,
it's a very focused sort of tool, right? It's not a publication tool for sure. It's more interactive
tool. For sure. Yeah. And I think that one of the really interesting things that happens when you
sort of engage with the folks that are actually trying to produce this, like in, in a company or,
you know, in an academic department or like in a government agency, those, those stories you just
said, like, do I want a PDF? Do I want an HTML? They are all true, but for different stakeholders.
Yeah. Yeah. Right. So, you know, if I'm a data scientist in a company and I want the CTO to see
what I'm doing, the CTO is not going to have time to go pour over the sort of gigantic report that has
all the details. They want something that has up-to-date data that looks in a sort of expected,
like might have the company branding and so on. And ideally something that's like email to them,
like on a daily basis. Right. So we want the same notebook that you've used to sort of create your
analysis to go as easily from that into something that can be like a scheduled send with CI or with
one perhaps positive commercial offerings, or, you know, you can easily publish it as HTML,
through GitHub pages, through Netlify or through your own provider or...
Yeah. I see. So you get basically a static site that you can...
That's right. ... publish as you see fit, right?
Yeah. Yeah. Okay.
That's right. So at the very basic, right, Quarto sort of jumped the gun a little bit. Quarto is a
command line tool that you can use and you can take your notebook, right, as an input, like your
IPINV file and just say Quarto render, and then we will produce an HTML file. So you're sharing your
screen now. So if you go and get started on Quarto.org's webpage, which is where we are right now,
you sort of, you see there's a tutorial for computations on the left sidebar. And then there's
sort of a number of different pathways that you can go through there. And one of them is Jupyter,
which is actually the one that you're seeing there by default. And so in here, we're highlighting that
you can take like your Jupyter notebook or your Jupyter lab input. Once it's saved to a file, you can just use
Quarto directly to produce an HTML. So you can say Quarto render HTML, you can say Quarto preview,
and that will generate sort of like a local hosted website, but you can say Quarto publish.
And then we have publishing sort of targets to Hugging Face, to our own Quarto pub free service,
to GitHub pages, to a number of other places. So at a very high level, you can take your notebook as it
is, and it can produce a really nice looking HTML page that's available.
This episode is sponsored by us here at Talk Python. Of course, you can support Talk Python by checking out
our courses at talkpython.fm/courses and recommending them to your colleagues and team.
But this time around, I want to just encourage you to connect with us on a few other channels.
You're listening to the podcast, and that's really great. But did you know that we also have a blog?
It has a couple of really interesting articles I recently posted. Jump over to talkpython.fm/blog
and subscribe to the RSS feed there. And we also have a great mailing list where in addition to
announcements about Talk Python, I also share some tools and tips that I learned recently.
So if you're a fan of email, just visit talkpython.fm and click newsletter to sign up. That's it.
As always, thanks for listening.
And one of the really fun recent things that happened is Hamel Hussain, MB Dev guy, sort of
fantastic author. So he's working for Answers AI now, and they just published a service where you can
literally go on Answers AI and point to a GitHub repository that has an IPINB page, and they will
dynamically sort of on the backend, find that GitHub page, create the Quarto page from your notebook,
and then just publish it. Right? So like sort of zero click, if you have a public repository on
GitHub and you just want an HTML page to share with someone else, you literally do not have to do
anything. You can just go there, get the output. And so that's a really sort of like zero click way to do
that. Yeah. Go ahead. I was going to say it's called NBSanity. You can find it at NBSanity.com.
In the show notes also, I think there should be a link to Hamel's blog post announcing it.
And he goes into more details because one of the cool things is that you can actually use,
even if you're not running Quarto, you can put a bunch of the Quarto options in there. You can say,
oh, I want to show source code or not show source code. It makes source code expandable. Or,
and you, if you just put those in your notebook, when they render it, then they actually use those.
So it's a, it's sort of a way to use Quarto to publish your notebooks without even
installing Quarto. So it's, it's pretty cool.
Yeah. It basically, if you can just figure out the URL to put together, it's, it'll just pull it
together for you.
Yeah. And I think, I think that is like the concept of Quarto, which is okay. I have Python code or I have
a notebook and I want to project it. And I want to do that in a flexible way. And that's, you know,
that sort of web is like a default case. But I think the thing that people should also understand is that
we really do go quite a ways beyond that with like making PDFs, making Word documents, you know,
stitching things together in a website, you know, making presentations, you know? So it's,
there's a lot there. One of the curses of it is actually, it can be a little hard to explain.
It's like, what is Quarto? Oh, publish anywhere, anything, any computation, any language.
That doesn't really concretely connect with anything I'm thinking that I want to do, you know? But,
but if you dig into it, it does, it does, I think, connect pretty well to the things that people
want to do. But I think there's, there's interesting value to be gained from those kinds of decisions.
Michael, I know you had recently Charlie Marsh on the podcast and UV and rough and all these tools,
right? And sort of UV has taken a few of these moves that like, you know, make perfect sense,
which is as you start sort of like consolidating these tools, there's a lot of really interesting
use cases that arise naturally from the way you can compose them, right? So yes, we have render,
we have publish, we have preview, and it takes a little bit of time for you to explain. But in the
end, you get the system that sort of like grows with you. And like, we hope it will be the tool
that people reach for when they have sort of like data science, technical content production needs.
And so we hope to- Instead of trying to, like yourself, trying to piece together, say,
I'm going to try to convert my notebook to markdown and then use Pandoc on this and run this tool
against it. If you guys own that whole workflow, then there's new opportunities. Is that what you're saying?
That's right. That's correct. That's right. Yep. Yep.
Yep. So as an example, folks have, you know, we talked about Hamel and BDEV. Another web page that
folks might have known or sort of website and company is Fast AI, right? So Jeremy Howard's
Yeah. Sort of initiative. Fast AI is a Quarto website, sort of, you know, like it just,
yeah, so just go on Fast AI right now. If you open the source. Yeah. So fast.ai is the, yeah, got it.
Yeah. Right there. Yeah. So this is actually a Quarto website. So the blog here is, but it's all of
these apps. So if you see there, it's published with Quarto 1635 or something in there. And these are all
directly from notebooks. So the entries in here on the blog entries, they're all IPINB files. And then,
Quarto, among the other things we can do is sort of collate all of the different sort of blog
entries you have, make listings so you can filter them. So this is very useful for a blog. It's useful
for folks that have sort of like an ongoing set of reports that like need to be sorted chronologically.
If you have an academic website and you want to list your articles, that kind of stuff comes up all the
time. But the input for all of those are IPINB files, right? So Jeremy Howard: Yeah, that's right.
So this will work entirely in IPINB. And so from there, we generate the HTML. We sort of extract the
headers and create the listings all sort of automatically. So this is like an entirely
Quarto website.
Quarto, I guess it makes sense being a static website that it's pretty well suited for this.
A lot of these tools that I talk to people about, they're like, this is a great thing for internal
publishing of our site, or it's a great thing if you were going to interact with it, but it's kind of
heavyweight and it doesn't really support a lot of design. And it's not a, you would never build your
public website with this is like what I hear from a lot of these tools, right? But it's,
this is pretty excellent.
Jeremy Howard: That's you definitely can.
Yeah, we leaned, yeah, we leaned pretty hard into, into, you know, allowing a lot of CSS customization.
So we use Bootstrap and we have a whole theming system that's really based on Bootstrap themes,
but you can use SCSS directly to create your own themes. So, you know, it's, it's, you can just go
like, oh, make me a nice website. I don't want to think about it. People do that. But then people
who really want to like party on, I want to make this look just so can absolutely do it.
So yeah, again, we might, because I was going to say, we might miss a little bit of the details
for folks who are only listening, but another example that you might want to search just to
show sort of, you know, the range where you can go from that. It's also another quarter website.
So if you just search for real world data science, this is an initiative from the Royal
Statistical Society. They have a website, which yep, right. That one. So they have a number of
different writers that write sort of like columns and content pieces and ideas. This is also a quarter
website. So I believe this one is based on markdown. So they are using instead of IPA and BS inputs,
they use our markdown, but the same sort of thing. And the only reason I'm, I'm bringing this up is that
you can see how very different it looks, right? So it has categories and things like that. But if you want to
take sort of, you know, the time to do these and sort of have all the like the banner images and sort of like that
kind of thing, you can absolutely do it. And any result, you get to publish through a number of different
places that you might want to. Cool. Yeah. For people listening, it kind of has that landing page look with the
hero section with big pictures, right? You know, it doesn't feel very notebooky at all. That's for sure.
Another use case out in the chat is Kevin O'Malley says, "I teach a summer school on using Quarto for
academic publishing in the university I work in. It's a great tool, but we spend a lot of time thinking
about how to make documentation better. Interesting." Yeah. Documentation is a, I mean, part of,
we, I think Quarto's documentation is very good. Like I honestly say this without, I think it's, you know,
I don't want to say best in class because folks have actually realized how important documentation
is and there's a lot of really good documentation out there, but I think we're up there. I think our
documentation is very good. It doesn't mean that it couldn't be better. And I think part of the issue
with Quarto is that diffusion of entry points that we talked about earlier, right? Do you want to make a
single PDF? Do you want a website? Do you want dashboard? Yeah. And all of those become different
places. And are you coming from a Julia background? Are you coming from a Python background? Are you
coming from an R background? So we tried to create these like different entry points on the get started
webpage and our guides are customized for VS Code experience for, Jupyter experience and so on.
But we a hundred percent agree that documentation remains one of the hardest parts for us.
If you click on the guide, on the guide tab at the top, you'll see that, I know everyone
can't see this, but like, it's just such a vast number of things and it is easy to feel lost.
We try to organize it, but it's like, what does this not do? You know? So, so a little bit of a
choose your own adventure. It's a little bit of that, which is not always what people are looking for.
They might be looking for like, no, tell me, I want to get this to happen. Just give me step one through
four. And, I think we could probably stand to do a little more of that.
Yeah. But here, this trees, this is kind of a decision tree, you know, like,
what are you trying to do authoring? Are you trying to do diagrams? Okay. Are you using Python? Okay.
You go down this path and then we'll help you.
Yeah. Yeah. Yeah. Yeah. We, one, one thing I want to touch on just, I know a lot of people have
not experienced this. I know you two have, I have, and it's mind blowing. This is somewhat built upon
Pandoc, right? Yep. Yep. Yes. We can. And Pandoc is ridiculous, right?
It's ridiculous. Yeah. It is like the most, the biggest workhorse that no one, software that
no one knows about, you know, it is, it is an incredible piece of software. Yeah. Yeah. If you're
like, well, I have a, a LaTeX document and I want it as a media wiki markup format. Could I possibly,
yeah, you could just convert those? Yeah. If you, if people are willing to at the pandoc.org website,
yeah. On the right, there's a little gray. Yeah. I don't know what you would call it,
but it's a gray. It looks like if you drew the diagram for rock, paper, scissors, but 500 ways,
it shows all the connections. Exactly. All the connections.
All the connections. How do I get, yeah. The, basically the given one format,
what other formats can they go to? And literally it's illegible because it converts,
converts so many things to others. And that's a really interesting foundation for you guys, right?
Well, I want to talk about this a little bit because I think that the, the really big idea
behind pandoc is the, the, a consequence of the big idea is that you can do all this conversion.
But the big idea behind pandoc, if you, if you're familiar, like if in programming languages,
when you're parsing and writing interpreters, you have this abstract, abstract syntax tree,
right? Or IL, there's a sort of a abstract representation of the program. and then you can compute
on it. And I think what pandoc has done is they've created essentially an abstract representation of
what document. and so we think of documents as just like, oh, we just spray a bunch of content
into a file and it's just a big blob. pandoc to use documents as something you can compute on.
And so all the things that might be in the document, you know, tables and footnotes and figures and
bullet lists and, you know, all these things are in an abstract model. And so what, what happens is it
takes that, you know, whatever that is, word doc or markdown file, and it brings it into its abstract
model. And now you can actually compute on the document. And that's really actually the heart
of how Cordo is able to do, you know, Cordo is built on pandoc. And that's how we're able to do
almost everything is that we're actually not just dealing with text and markup. We're dealing with
this sort of abstract model of a document, and then we can do all these powerful things with it. So I
don't know if you want to expound on that. You probably could expound way too long on that,
Carlos, if you, if you chose to, but, but I think the shortest, important bit is yeah. So
pendoc operates on this abstract syntax tree. It's a document that has paragraphs. Paragraphs can have
spans with, you know, strong text and their text and things like that. And we court, you can think of
Cordo as a very, very big orchestrator of pendoc and sort of like configuration,
orchestrator or like choreographer for pendoc. So Cordo itself is a command line application. We ship,
uh, pendoc with it. So like our bundles all include pendoc with it, but fundamentally we are a TypeScript
application that, sort of puts itself in front of pendoc and then after it, right? So, you know,
all of the complicated things you might want to do to generate multiple websites, to extract bits of the
documents, to know the titles, to create your blog posts and your entries, right? So Cordo gets in front of it,
does all of that orchestration work, then calls pendoc a number of times and then calls sort of
some post processors. And the way this integrates with engines and Jupyter and so on is our, what we
call engines in Quarto are the things that turn, your document that has executable code with the
document that has the results of the execution, right? And so all that, that needs to happen for
an engine in Quarto to exist is that it takes Markdown or Jupyter notebooks as input, and then it produces
Jupyter notebooks as output or the Markdown annotated with those, results. And then we just sort of
process them and send to pendoc, right? So really pendoc is, is at the center of what we can do with
Quarto. And you can think of, Quarto as just sort of sitting around it and sort of expanding the scope
of the things you can do with pendoc.
We've done a few more things. Like if you, to use pendoc typically, you know, there's, you know,
160 command line options and you just kind of figure out how to, you know, it's tremendously powerful.
So we've tried to, I would say, organize that experience a little bit. so it's like, oh,
I just say I want a PDF and it's in YAML and I do a couple options and it does the right. So I think,
you know, you can think of pendoc properly as like this sort of engine that you can do anything
with. And we try to give you like the happy path to a bunch of things that you probably want to do.
Yeah. I think that's hugely valuable because while pendoc is great, it's also
super complicated. And a lot of times, if you want to combine different documents, you know, maybe I'm
actually working on a project that has a bunch of Markdown files, but they really need to be one
Markdown file on a certain order. And then that thing gets processed. But then as it gets transformed,
there needs to be changes to it. And right. You know, I'm, I can program, I can write that code to
do it, but there's a ton of common use cases, like take this notebook and publish it on the web.
Yeah. Right. It could just be built into your tool. Right.
So one of the thing that, I'm sorry, go ahead, you're going to go ahead.
I was going to say, even the thing you're talking about, I need to paste together a bunch of files
and turn it into a single file or turn it into a book or turn it into a, you know, those are things that we can,
we facilitate those sorts of things, things as well, you know, like this, this is really a book
actually. And it's got 20 chapters and each one is in its own file. And when it's a website,
I just want it to be like a website that lets you navigate my book. When it's a Word doc,
I want them all concatenated together into a Word doc, you know, et cetera.
Right. And then the final destinations and EPUB and a PDF or something.
Yeah. EPUB. Yeah. Or I went, yeah. EPUB or PDF. Sure. Yeah. Make the EPUB,
you know, create the EPUB archive just so, just so. And yeah. So sorry, Carlos.
I was just going to say that to Michael's use case of sort of having a number of markdown documents
and so on. I wouldn't presume to say you should use Quarto. Maybe it's a good tool for you. But one of the
things that we do believe in very strongly is sort of making sort of, it's a principle that we try to
abide by. It's sort of making hard things easy, but never at the expense of making very hard things
impossible. So, you know, we will provide you the happy path. We sort of, you know, the standard
YAMO options, we have validation for them. We have completion, we have sort of integrated documentation
if you're in VS Code, for example. But if you need to actually extend things, we give you a number of
escape patches and entry points. And so if you're in a Quarto project, for example, we have a fairly
complete system of like pre-render scripts and post-render scripts, or we'll give you the set of things that we
found on your project. You can run TypeScript code against it. You can run Python code against it. Tell
us what you've done to pre-process our project or to post-process our project. So if you need to start by
collating markdown documents or by, you know, going to some database and pulling the documents that you
want to render on a webpage, all of those things are enabled by this pretty extensive extension system,
for lack of a better term. Sort of, we try to put extension entry points in as many places as we can,
so that folks are not stranded when they go from a simple project to inevitably something that's more
complicated. And so we try to make Quarto grow with them as your project tends to inevitably grow as well.
Yeah, that sounds really great. When I'm sure there's some pre-built extensions, but I also imagine
that we could write our own.
Is that in JavaScript? Is that in any language?
Okay.
Is that shelling out to...
Well, let me tell you. So a couple of the things are pretty open. So what Carlos said about pre-render,
post-render, sure, any language, that can be just the shell. Okay. There's a thing called Pandoc filters,
which is essentially take the AST in and transform the AST. Those also can be written in any language,
filters. So for example, there are two different libraries to write them in Python, but people write
them in all kinds of languages. That's available. But I would say the official mechanism for extending
that has more affordances, more APIs, more flexibility that we have is based on Lua, because Pandoc has an
embedded Lua interpreter in it. So as it's running, they give you access to the runtime and you can do
all sorts of really flexible things inside Pandoc as you're running. So Lua is, if people aren't familiar
with it, was originally created actually for embedded game engines. So the idea is we need very, very fast,
very fast execution, very high level language. It looks not dissimilar from Python, I would say,
but it runs very fast. So for example, like the Cloudflare kind of, what is it called? Envoy for
writing super high performance, like REST proxies uses Lua. So like, okay, this code is going to run
on every HTTP request that happens. We're not writing that in any language that isn't just
going to be screaming fast. So I think the reason why Pandoc used Lua was they said, well, we can very
easily embed it and it's going to be fast because when you're processing documents with a lot of nodes
in them, you really want to be using a language that's very fast at runtime. So it is Lua. And if
you go to our website, there's a whole section on extensions and we do quite a bit too. Let's see.
Yeah. Go to where's extensions, Carlos. It's gotta be.
Yeah. If you just search for extensions, you should be able to find good documentation and sort of,
yeah, you can start from. Yeah. Yeah. Yeah. Yeah. That's right.
There's a bunch of ones that people, yeah, these are ones people are, have already done. So they've
sort of added features. Yeah. Oh, you guys support the concept of short codes.
Yes, we have.
Yes, we have short, you can write your own short codes. Yeah, exactly. Yeah. So you, you can write that,
the two kind of workhorse extensions are short codes and filters. And so short codes are like
content injectors, filters are content transformers. And so you can see examples of,
you know, different, different short codes and filters that people have.
Yeah. So an example for people who maybe are not familiar with this idea is pretty common in static
websites. Yeah. Static site generators. For example, Hugo has the concept of short codes as well. Yeah. And
it's like, I want to write a markdown, but I also want to embed a YouTube video.
Exactly.
And that is like an iframe and all sorts of things.
Exactly.
Yeah.
The video short code we support natively.
Yeah. So we have a video short code that's, that's built in. We wrote a video short code built
in because for this, it's so, it's so common, but you know, people make these specialized ones. One of
my favorite ones was somebody who was like a short code and you like give it some kind of,
I don't know what that was. It was like some kind of like chemistry or biology, you know, code. And
it creates this like interactive molecule visual visualizer, you know, right in there.
Yeah. Like a 3d, whatever the language for 3d stuff in the browser is that came out.
Yeah. And it just, it's wild. And you're just a short code and give it one little code and it just
does it. So, yeah. So these are, and these are, these are written in Lua, but, and part of that is
also because we want, again, this idea of, of being pan box supports Lua, but we also want
people to run these extensions with zero dependencies. So like, if I'm a, you know,
I write an extension, I don't know if you've got R or Python or like, I don't know what you're, what
you're, you know, and I don't want to have to satisfy a bunch of dependencies. So we want to have like
fast dependency free and well and agree with Pando. So that's why we ended up with Lua. And we, we like it.
Um, and, it's served us well. We've done, we did some stuff in our quarter extension. We do a bunch
of like, we actually add a bunch of like static typing annotations for Lua so that it's like, we get
really nice auto-complete and linting and stuff. So. Yeah. Cool. You know, JJ, five years ago, if you said,
I need to write an extension in Lua. Yeah. I would have to learn Lua. Maybe not well, but I would have to
like, I could probably write that. I could probably write it in Python or, or R and then just tell chat
TPT. You definitely could. Yeah. Yes. Yep. So. What do you guys think about this? This crazy LLM stuff
that's taking over programming? I think, I think it's pretty interesting. I think it's, I would say
that I was kind of a little wary of it until I saw, I'd say probably Claude 3.5 and O.1 are a huge,
a huge step change in capability. and so I was kind of waiting for that. but seeing that,
I would say they're already now quite effective at accelerating many parts of development.
I think part of what we have to do is figure out the, the human, the sort of, what is the right,
um, I think for, for many, most types of software for the foreseeable future, it's going to be human in
the loop. I believe. And so what does the interface for human in the loop? What does it look like?
Is it, you know, it can go all the way from do a thing that's complicated. Let me see the diff and
I'll approve it too. I just want to talk about it and then I'll do it too. Let's talk about it and you
can do some things, you know, and I'll tell you if they look good or not. And I think that's a really
interesting area of exploration for, for the tool building community for the next few years.
It's, I agree. It's super interesting. I, I, I don't have it built stuff for me, but there's a lot
of times I'll be like, I could look this up, but I'd, I'd like to see an example from it and then I'll,
I'll take it and make it mine. Or I have a thing, explain it to me. Like, what does this regular
expression do? Or what does this curl command do again? I can't be bothered to study them.
I have a funny anecdote about this. Cause I, cause I do the same thing. Like, let me look this up.
So I was like, I was writing a VS Code, I was working on a VS Code extension and I was basically
trying to save some state, you know, per workspace state. And I'm like, I know there's like, there's
a one liner for this actually VS Code. They have this built in. So I said, I just want to do some
per workspace state. Like, how do I do that? And it goes, oh, great. And it goes like, I'll make
workspace state manager as it produces like 180 lines of code, you know, and it's got all this kind of
events. It's got all this stuff. And I'm like, isn't, I was like, isn't there like a one-liner?
Like, oh, totally. There is a one-liner like here. It's right here.
You do have to, you know, when you have it, try to build stuff for you, you have to kind of go,
don't lead the witness too much, you know? Yeah. Yeah. Yeah. For sure. I will just add that
I think people who try to just say, I'm going to take this thing and just have it build the thing
and then build the next thing. And if you take it too far, you're going to end up with a pile.
You're dead in the water. You cannot understand. You cannot maintain. It doesn't quite do the thing.
That's exactly right. Yeah. Yeah. Carlos.
Carlos, you spend a lot of time universities teaching people.
This is... Yeah. It's interesting. I left, I think, just before this became really,
really bad. My spouse actually teaches Intro to Python. And so, you know, she's sort of much closer
to the thick of the bad parts of like sort of exposing like this really access to LLMs for folks
who don't otherwise understand what's happening. And so I'm of two minds of this. One is I think there's
something fundamentally complicated for us to handle, us as in like society and humans, which is it is much
harder to tell that something might be wrong than to generate the output, right?
Yeah. Sort of it's really complicated, right? Like it's actually just genuinely hard to do so.
And it's even harder when you don't have the expertise. And so it's absolutely the case that
there's a number of folks that are using ChatGPT to generate code, to generate sort of solutions to
homework is like the bad case that happens all the time. Right? Yeah.
Yeah. But even if you sort of step that aside and say like there's no grade in play or anything
like that, the risk is that folks really don't have the ability to tell when something is going bad or
wrong. And I think that's a complicated thing to do. The counterpoint that I think is quite interesting
is that we have computers right in front of us, right? Like, you know, if ChatGPT gives me like a
snippet of Python code, one thing I can do with it is I can run it myself, right? Like, you know, I can go and
check it. Right? And so I think the places where I find it to be extremely valuable are like when it
tells me something that I can very easily verify whether or not it's the case, right? Sort of like
I say, okay, can I tangentially, I'm trying to teach myself Rust because it's 2024 and like, that's what
everyone else is doing. And I found it to be sort of exceedingly valuable to just sort of like, you know,
ask for something, how do you do that in Rust? And it gives me something and I just, you know, sort of
use the code and then like, I go look at what it does and sort of, but I'm actually the one running the
Rust code, right? Or something else is there's, there's a like third party that can verify the
output in like a meaningful sense. And that combination to me seems really powerful, sort of
like the ability to sort of, you know, generate these potential things with my ability to quickly
check whether they are true or not, that seems transformative to me. Totally agree. Yeah.
And so, so that's where I think it's most exciting work that's going to come out is how do we combine
like these things? And one fascinating thing to me is that if you think about like PyLens, PyWrite or
Pydantic, these sort of like typing efforts for Python that exist in many other languages, something
like an LLM gets to benefit a lot from it on both sides, because the annotation is information that it
can use to sort of figure out what it actually needs to tell you. But you can also use the annotations
because the annotations means that there are fewer valid programs out there, right? That's what a type system
does. It disallows some programs to exist. And so if it gives you a wrong result, it's much more
obvious that that's the case. Right. You might see a type error.
That's exactly right. That's right. Yeah. And so that to me is where I think all of this stuff is
happening. If you, so you mentioned you're a mathematician by training, Michael. So Terence
Tao is a fields medalist, sort of very famous number theorist guy. He's been talking a lot about his
efforts to use lean, which is an automated theorem prover. So people are sort of trying to formalize
mathematics through like, you know, automated theorem prover programming language that has
like formal semantics and so on and using LLMs for sort of coming up with ideas for like the proof
strategies and so on. And there, if it doesn't, if the theorem is proven wrong, it will tell you
right away. Yeah. So that's the kind of thing that's very, very powerful to me.
Yeah. Yeah. I'll often, I'll often for something that's a little complicated, you know, I'll, I'll
have it generated. I'll look at it. Look, as Carla said, I'll look it over, I'll run it. And then I'll
say, I'll, I'll say like, now write me a ton of tests, you know, and then like, did you test for
this? Did you test for that? Did you? And then suddenly there's like 80 tests and that helps it's,
that's a little bit, it's not, that's not a guarantee, but it helps with that closed domain kind of thing.
Right. Not a proof checker, but, but you know, it's a proxy.
Yeah. I didn't mean necessarily take us this deep down the LLM path, but it's amazing. It's
super interesting. It's easy to go there. It's easy to go there. Yeah.
It's affecting all of us so much. And I think it's going to bifurcate the, the software developer.
Yeah. World on one hand, I think folks who are like, you guys are saying, I can check it. I'll take it.
Then I'll run with it. It's only going to make it better, faster, right? You want to do extension.
You don't know Lua. No problem. It doesn't matter. Yeah.
Right. We'll make that work fine. On the other hand, I think, you know, to your wife's position,
Carlos, I think there's a really serious danger that LLMs will stunt the growth of students.
Yeah. Yeah.
You already see it happening.
It's already happening.
Yeah. It's already happening.
This is already happening.
Yeah.
And it's, it's a really, I think it's, it's a shame because in computer science specifically,
the, the fix is easy, right? The computer is right in front of you. You can test that, right? Like that
kind of perspective that like, you know, you have a computer in front of you that can run code and tell
you what it's doing. There's nothing stopping you from doing that. That perspective is so important,
right? That's why open source is so amazing. You can like go into the Python code and like download it and
try different things. There's no one stopping you from doing that. So for computer science, I do
think that we have an easier way out where I think this is terrifying is where folks use LLMs as a
search engine with having no idea that this thing invents the fact that I don't know, like George W. Bush
has issued a part in the history of the app, right? That kind of stuff comes up, right? People publish stuff
on the news without minimizing this. It's already here and it's not just students, it's everyone.
Yeah. Yeah.
It's a slightly broader point. And then we can get off the LLM train here, but a slightly broader
point that typically to get the most out of these things in a lot of domains, and this could be law
or medicine programming, you really need like substantial human expertise to oversee them.
And that person probably has 10 years of experience. And so great. Okay. So those people are going to
become more and more valuable. I know how to be the human in the loop because I, you know, but how do we
develop the new, you know, the, the, the 10 years of experience? How do I ever get the 10 years of
experience if I'm constantly letting the LLM do things and I'm never learning? So that's the crisis.
I would say. It's an absolute, it's going to be a real problem in a few years. How do you,
how do you make the gap from new out of school to I have the 10 years experience? That is going to be
a huge problem. It is a huge problem. Yeah.
But do you know, William Gibson's quote about like, the future is already here. It's just not
even as distributed. That problem already exists. It doesn't need LLMs for that, right? This problem
of checking expertise, right? To tie back to the portal conversation, right? Like a number of there's
what got me started in the reproducibility crisis is this inability for us to tell whether some output
of an academic paper is correct or not. Right? Like it's really much harder to check. That is the same
problem that now absolutely everyone is going to run into on every place. Right? And where I think
Porto has something to say about it and like this entire project of computational reproducibility and
documents that have the code that generated them is that you have the ability to check, right? So, you
know, our manuscript support that JJ alluded to early, right? When you create a website, right? You have
the entire website and there's a link to the side that's like, here's the code that generated it. You can
run it on binder, right? You can run it in code spaces. Yeah. And so you can check when you look
right here. That's in the upper right. Yeah. This thing right here. That's right. Yeah. So that
shows the code statically, right? So there's a separate mode in which you not only have like the
source code that you can see it, but you actually have the full IPNB like available for you to run it
on binder and like check for yourself that it's actually producing the results that you expect.
Right? So you can go from the pros that is hard to tell whether it's true to the code that actually runs.
So you can at least see what the person is using to make the claims that they did. And I think that
kind of like integrated metadata that like sort of corroborates the statements you're making is only
going to become more important as we go forward rather than less. Yeah. Yeah. I agree. That harkens
back to your reproducible science initiatives, right? That's exactly right. Yeah.
So let's talk about using Corto. Where can I run it? So it's, it looks like it's supported at least on
the major OS's Mac, Windows, Linux. Yeah. Right. That's right. It's a, it's a command line tool
that you can install separately. You can also just pip install it. oh, interesting. Yeah. Yeah.
I mean, just that's a lot of people do that. and you can pip install older versions and,
you know, versions from GitHub and all that sort of thing. in terms of, I would say, you can
just use it with any editor with a command line tool. I do think it benefits from, from some tooling,
like some auto complete and some amount of just like, Hey, preview this thing, show it to me.
and so there is, there is pretty good tooling across there. So there's like a Jupyter extension.
There's a VS Code extension that does quite a bit of stuff. there's a Neo Vim extension.
there's a support integrated support in our studio. So, that's important. If you go to our, like,
if you go to our, like, get started thing, you can see, we sort of, let's see,
I think you have to scroll up. you go to get started. It'll kind of, if you scroll down,
we kind of say to you like, okay, what are, what, you know, what's your preferred tooling
environment? And then we kind of set you up in that environment with the right
extensions or other things. And so there's always use a text editor, but you know, I think the tooling
is helpful. Yeah. So one of the things I was thinking about when I was asking that,
two of the things really that I think are rough edges that you probably solve that people don't
necessarily know they're rough edges yet till they try it is one hand doc has a lot of dependencies
dependencies that are not obviously dependencies. Yeah. Like for example, I was trying to get,
some file out of pandoc and it was saying this LaTeX thing is not installed on your Mac.
Yeah.
I'm like, why is this here? Why is this happening?
That's right. We definitely, yes, yes, yes. We, we have, we have definitely solved that. So on,
uh, so it depends on the, now it depends on the scenario. So for LaTeX,
we don't embed a LaTeX distribution. However, if we notice you don't have LaTeX, we tell you just
type quarto install tool, you know, it's a, what is our LaTeX distribution?
Tiny tech.
Tiny tech. Install tiny tech. And then that's actually a tech distribution that we maintain
that is like very small, has different form factors and isn't like five gigabytes to start
with and does auto installation of packages. So for that, we kind of say, yeah, you need,
you need LaTeX. We're going to make it super easy. So it's a one liner. You can get LaTeX.
In other cases, like, types is another, many people may or may not have heard of. It's a,
it's sort of a competitor to LaTeX. It's another PDF, among other things, PDF engines.
and it's re it's a phenomenal tool. It's, you know, creates incredible output. It has a much to me,
like more sort of natural and scalable, programmable interface than LaTeX does. We just embed
the, the, the types runtime in Quarto. Cause it's not very, it's not, there's not much to it.
You know, it's not, it's not huge. It's not, it's not like that's cool.
If you haven't used types and you use PDFs, you generate PDFs as part of your day job. and you've
heard of LaTeX and you have the reaction that every single person that needed to use LaTeX is,
it's like fondness for the pain it caused and the quality of the documents it generates.
Types-
It generates incredible, it doesn't get better.
Types gets to what I would say is 90% of the quality that LaTeX does. There are some
micro typography tricks that they haven't quite incorporated yet, but they do a number of other
things. And it, so Types is genuinely amazing. I could not recommend it more strongly. It's a little
weird to type as typst.app. It's another open source product. They have an offering that is sort of like
a collaborative editor where you do those things, but you can use it as a command line. T-Y-P-S-T.
Types-t. Types without an I. Types-t. That's right. Yeah. Okay. Yeah, got it. All right. Wow.
Yeah, we can add that to the show notes. It's hard to, it's hard to phonetically tell me how
to type it and search it. But it's amazing. Once you know, it's going to hit, this is not going to
come up. It's very searchable. Okay. I'll put the show notes. It's a fantastic, fantastic tool.
Yeah. So yeah, Types is incredible. Yeah.
Pandoc supports outputting from Markdown to Types because of course they do. And so we can do that as
well. And it's phenomenal. It's incredibly, like I hope in five years we will not have to reach for LaTeX.
It's early, right? It's sort of existed for a couple of years, but I am genuinely, the team is extremely
impressive. It will not surprise anyone if I say it's a Rust application because again, of course it is.
But amazingly technical work. Compilation is impossibly fast. To me, the difference between
using LaTeX and Types is the difference between using Mercurio and Git. If you ever remember the
first experience when you said Git something and you just got the result back and you thought
something went wrong, it could not possibly be this fast. That's the same impression you have from Types.
It generates this amazing PDF in like 0.2 seconds. And you just look at your computer and like,
I cannot believe this just happened. It's really nice. So we support that.
We've made a big investment in Types and so we bundle the runtime and we're bullish on it.
All right. I'm going to have to learn more about this. This is very exciting.
So yeah. Okay. So that was the one thing I want to talk about was the rough edges of tools like
Pandoc and others. The other I want to talk about with you all is continuous integration. So you could
set up say an automation in GitHub where somebody pushes a new version of a notebook, it automatically.
Yeah. That's right.
Yeah. So yeah, we have the integration. We got GitHub actions integration. What's the story?
Yeah. So if you go to, if you go in the guide here, just, I know folks listening won't see this,
but we'll just talk through, go to publishing. You can see, we sort of have this idea of, yeah,
I guess you can go to publishing basics there and it'll give you an overview of everything.
So we basically have this idea. We have a Quarto publish command that can kind of publish to lots
of different destinations. So it can publish to Netlify, GitHub pages, you know, some posit things.
We have our own little hosting service, hugging face spaces. So the idea is we know how to talk to all
those. And so you can just say Quarto publish and it'll remember, oh, you published to this URL before you
want to update it. So that's like the workhorse for publishing. And then all of that works in,
you can see at the bottom, there's a note publishing with CI and all of this can work
by basically like put your token in CI, you know, you know, export the token in the environment,
call publish. And so lots and lots of people use CI to update things with Quarto. And they may be,
again, they may be publishing to get a pages, maybe Netlify, maybe hugging face, maybe, maybe another
service. Yeah. You want to give a shout out to Quarto pub? Yes. Yeah. The Quarto pub is just a free
service. I don't really know much about it. What is this?
It's literally just a free service that you can use to publish static, static documents and
websites. And that really all we wanted to do here, it doesn't support all the fancy features
like authentication and custom domains and all that our goal. And there are other services that do that.
Um, but our goal was to have a free service that makes it dead simple to publish your thing.
You get your own, you know, your own like sub domain and you can just publish stuff. So we
wanted to be just like, I can definitely publish my thing to the web. and so that's kind of what,
what, what it's for. and then if you want to do things like, for example, if you're using
get a pages, well now I can, you know, I can like have it authenticate. So only people who have access
to the repo have access to the pages, or, you know, if I'm using Netlify, I can do all manner of
fancy things. So it's, it's designed to be simple, easy, and free, to kind of get your stuff out to
the web. So I use that. Like when I'm, if I publish, I go give a presentation and I have a slide deck and
it's written in Porto. I just put it on Porto, you know? Yeah. Beautiful. So I suppose one of the
other publishing destinations other is just a pile of HTML, CSS. That's right. Exactly. Yep. Put it
wherever. Yeah. It's just going to make Porto is just going to make a directory for a website. It'll
be underscore site, you know, for a PDF, it'll be a PDF and whatever.
Put down some engine X or caddy and off. Exactly. Do whatever. Yeah, that's right. That's right.
One thing I will notice a note about the CI just before we switch subjects is, we have a
repository that I think we linked to, somewhere where we have a number of examples of using GitHub
actions. So it's a GitHub slash Quarto dev slash Quarto actions that we maintain. And we document
with a number of different use cases that folks might want to do if they need to like grab dependencies,
right? So your CI often where the sharp edges are that you're going to have to install R, you're going
to have to install Python and so on. And so we have sort of, you know, a number of actions that will
talk Quarto will render it and it will publish it. So from there, you can just take it where it is,
drop some of these into your own repository, and then you're off to the races. So this is another
place where we're trying to like reduce the sharp edges to like actually get people to see the stuff
you've built. Yeah. Yeah. Cool. I'll link to it in the show notes so people can find it and use it.
All right. we have time maybe we, if we lightening rounded a little bit, we got time for,
for two, we can do it. We can do it here. So, one, this is open source under what license?
MIT MIT, which may basically means that commercially you can do whatever. So
Quarto is sort of unencumbered in that sense. That's right. Right. Yeah. That's right. Exactly
right. Yeah.
What's the business model? How does this tie back to Posit and why is this?
So Posit has a, a pro so product Posit has a product called Posit Connect that is essentially
like an, I would call it an enterprise publishing platform for what we call data products. And so
Posit Connect does a lot of things. It publishes shiny apps. It does stream load apps. It does dash
apps. It does flask apps. It does apps. And it also does, content. So it does websites or documents.
And then it has, it adds some things like, oh, you can schedule, the content. So like, you know,
run this, update this once a day, update this website once a day, or whenever this thing,
updates, you know, send an email to these people. So it's, that's the idea. so Posit Connect is,
is, a commercial product that we sell. And so I think, from a business model standpoint,
um, if people are successful with Gordo, as obviously we make it very easy to publish it to
everywhere. We're not trying to privilege, you know, or say, oh, oh, you know, it's a Roach Motel.
You have to publish with Posit Connect, but we're, we're, you know, we do, we do try to have,
yeah, yeah, we do. We do try to have a value added product. It focuses, I'd say, honestly,
more on the like internal publishing, you know, than the, than the public, publishing.
Yeah. That's cool. And just for, for, for disclosure, people haven't listened to other episodes,
you guys have sponsored the show before for Posit Connect. And I want to say, thank you.
Okay. Okay. Yeah. Awesome. I really appreciate it. But, but this is not sponsored, right? This is just,
uh, no project. So, okay. So that was, yeah, that was one of the ones I wanted to talk about. Just like,
how open is it? It feels a little bit like the Visual Studio code model. Microsoft makes this.
It would be awesome if there were some great integrations to Azure and encourage people.
Oh, right, right, right, right. Yeah. I mean, right. People love it for whatever,
but if it's, if there's the right use case, then, Hey, it's a perfect tool.
Yeah. So a little bit of that, we, we've sort of like, Hey, we've tooled this up for internal,
you know, enterprise usage, as much as we can. we, you know, I'd say we've had,
we've had lots of contributions. I think our biggest external contribution was,
uh, would you say Carlos, the folks from Julia added the, Julia engine, which is a pretty,
pretty, pretty substantial piece of work. and so we, we very much like to collaborate and take
pull requests and yeah.
The yours are welcome, huh?
For sure.
The yours are very, are very welcome. Yeah.
And currently Quarto is, I think, you know, a, a large code base that is not super approachable.
I think that's a fair assessment that we would agree with. We are spending a lot of time in 2025,
actually figuring out ways to sort of let the community in and sort of change the ways that
people can write extensions and sort of make it easier for people to build on it. I will say that
in contrast to the way that Microsoft does like VS Code versus Codeium, right? So we don't have to split
products, right? So we have just Quarto, but it is true that inside Quarto, there are sort of things that
only make sense, for, so there's a published to like RStudio connect, for example, right? So
there are things that integrates with RStudio that are inside the Quarto code base that are there
because of RStudio. but that's an entirely fair trade-off that people can make, right? They don't
have to use those tools if they're, that's right.
That's right.
Not at all. Not at all.
Yeah.
But you want to serve your customers as best you can. That's right.
Yeah.
Okay. I don't know who wants to take this one, but people know node.js.
And one of the great ironies of a lot of these data science tools is a lot of the people working
on them, for example, Jupyter themselves, it's kind of like, we'll take one for the team and we'll
write all the JavaScript to make it interactive. So you all can stick in your data science language
and not worry about it.
Yeah.
That's right.
It sounds a little bit like that here. And so you guys are using Deno, Deno Deno.
Yeah.
How, one, how do you say that to, to like what it's, it's like an alternative to node.js,
right?
That's right.
What's the deal with this internal story?
Yeah. I don't know if it's pronounced Deno. I just usually pronounce Deno. But it is a,
I think Deno is right, right?
Yeah. So it is a, so it has V8 inside it, just like node does. It's actually founded by the same,
by Ryan Dahl, who is the founder of node and he's now CEO and founder of Deno, the company behind it.
So the main thing with Deno is sort of, it really wants to be TypeScript first. So you can run
JavaScript, but Deno has sort of like a really built-in type checker that uses sort of like,
you know, the TypeScript type checker, but it's, it's really quite built in and it has a really
advanced sort of capability system for folks that need to bundle things. You can run Deno and say,
run Deno, but do not allow it to go on the net. Right? So run Deno, but do not allow
- Oh interesting. - allow to like import other things. Run Deno, but allow only access to the
file system or do not allow access to the file system or do not allow. So they have a really
fine grain capability system that is quite nice. And for us, so that was, so one of the things that we
wanted was something that sort of let us just do that and quick and sort of, it's easily also
embeddable. So Deno is like a single binary that you get to ship and you get V8 with it. And so
we just bundle Deno internally. And so it's just a pleasant like modern alternative to,
to node where most of the standard library and all of those are TypeScript first. And so you have the
really nice type annotations. The standard library is all in TypeScript and you get access to that. And so
that's what drew us to it. - This is cool.
Yeah. I didn't know, I mean, I'd heard of it, but I hadn't really paid much attention.
Wow. It's popular a hundred thousand GitHub stars and it's less than two years old or something like that.
It's not bad. - Yeah.
Yeah. It's quite popular. They have a number of interesting things. So the company is built behind
and trying to use this Deno deploy, which is sort of like this, you know, serverless where you ship
- Edge computing. - TypeScript, edge computing. And so, you know, you can have like a very small piece
of TypeScript instead of having node that runs on the edge. And so that kind of, that's their business
model for us. It's just a modern alternative to node with all the lessons that they are.
Awesome. Right time.
Yeah.
That's cool.
All right, guys, I think we're out of time here as much as I want to talk more about it.
Absolutely.
But let's leave it with a little bit of a call to action. People are interested with Quarto.
Yep.
They want to get started. What do you all tell them?
I would go, I would go to the Quarto.org website and I would literally just, there's a get started
button and it basically will let you pick your tool, whatever VS Code or Jupyter, or just
NeoVim. And then it'll take you through a tutorial that's step-by-step that shows you the basic
mechanics of the tool. And then it shows you how to, how it works with computations, how you can embed
code and run the code and control how the code is run and all that. So I think if you go through that
tutorial, it'll probably take you, you know, a half an hour or something like that. You will have a very
strong, you'll be up and running and you'll have a, you'll be in your favorite tool and you'll have a very
strong idea of what the thing can do and how it's useful. And then from there, I'd kind of just go
back to the homepage and sort of browse through and say, okay, what can I do with this? So I can make
dashboards, I can make presentations, I can make reports, I can make websites. And I think it'll be
easier to connect concretely with those things once you've gone through the tutorial.
The other thing I want to point out is we have a pretty active discussion forum on GitHub. We don't
have a discord. We'll probably fix that in 2025. But we do keep a very close eye on both issues.
And on discussions and sort of, you know, we are, we try very hard to be responsive to everyone and
sort of, you know, if people want to share their work or ask questions, sort of take, you know, the
the quarter sort of documentation and then figure out like, you know, okay, what are the things? How
do I put them together? And they have questions. We are like, we keep a really, really close eye on that.
And we try to be very responsive. So I would encourage people to just hop on, on GitHub discussion,
ask questions, and we'll be there to help you.
Yeah, excellent. It's nice to have discussions because a lot of times people will come and
if there's no discussions, they'll file an issue, which is really a question. And you're like,
well, when do I close this? Because I kind of answered it, but you don't necessarily know you
answered it and they won't close it because it's there anyway.
That's right.
Yeah. So awesome. Well, congratulations, both of you on such a cool project. And I know it's
doing good things for a lot of people.
So I want to quickly shout out just the folks. And so, you know, there's a large number of group
folks like inside Posit that both help, like, you know, sort of besides JJ and Charles who contributed
early, Christoph Dervie, Gordon Woodhull, Charlotte Wickham, Mene, Mikael is a huge help on our issues
as well. So it takes, it takes a village and I just want to shout out those folks too.
Yeah.
Yes.
Cool. That's excellent. All right. Bye guys. Thanks for being here.
Thank you. Take care.
Thank you.
This has been another episode of Talk Python to Me. Thank you to our sponsors. Be sure to check
out what they're offering. It really helps support the show. Want to level up your Python? We have
one of the largest catalogs of Python video courses over at Talk Python. Our content ranges from true
beginners to deeply advanced topics like memory and async. And best of all, there's not a subscription
in sight. Check it out for yourself at training.talkpython.fm. Be sure to subscribe to the show,
open your favorite podcast app and search for Python. We should be right at the top. You can
also find the iTunes feed at /itunes, the Google Play feed at /play and the direct RSS feed at
/rss on talkpython.fm. We're live streaming most of our recordings these days. If you want to be
part of the show and have your comments featured on the air, be sure to subscribe to our YouTube channel
at talkpython.fm/youtube. This is your host, Michael Kennedy. Thanks so much for listening. I really
appreciate it. Now get out there and write some Python code.
Bye.
you
Thank you.