Mine Çetinkaya-Rundel & Julia Stewart Lowndes | Hello Quarto: Share, Collaborate, Teach, Reimagine

Transcript#

This transcript was generated automatically and may contain errors.

I'd really like to welcome our first keynote speakers, Mine Çetinkaya-Rundel and Julia Lowndes, who are going to be talking about Quarto . And there are literally no two better people suited to give this talk.

Mine is my colleague at RStudio . She's also my co-author of Alpha Data Science. She is a professor of the practice at Duke and just a fantastic educator. And I deeply appreciate her empathy with new r users.

Also whenever I correctly type Mine's full name, including the little dangly sedilla on the C, I like give myself a self high five.

Julia Lowndes did a PhD in marine biology and squids. She also started Openscapes in 2018, supported by Mozilla. Julia is like one of the people I just love to hang out with at rstudio conf. Whenever I see her, because she is just so passionate about educating people about the power of R. And whenever I get to hang out with her, I just feel rejuvenated and excited about the work that I do.

Unfortunately, Julia and Mine will not be taking answering questions today. But if you do ask questions in the Slido, they will read them and they will pass them on to the Quarto team. But they will not be taking questions today.

Thanks so much, Hadley. And thanks so much to all of you. We are so excited to be here.

Mina and I have been using Quarto for over a year now. Mina has been teaching with it and has been contributing to the development of it. And my teams with Openscapes were the first external testers of Quarto. And as we've used it over the past year, we have grown to love it so much, and we are excited to welcome you to Quarto.

But also, we know you have questions. We did, too. What is Quarto? Why is Quarto? And how does it interoperate with R Markdown and your other existing workflows?

Well, Quarto unifies and extends the R Markdown ecosystem. It unifies it for people who love R Markdown so that little points of friction are reduced as you make websites and books and slides. All of those will now have a common approach. And it extends it for people who do not yet know R Markdown as a friendly way to work reproducibly and publish documents that combine text and code and output in the same place.

So Quarto is a new open source scientific and technical publishing system. And the goal is to make the process of creating and collaborating dramatically better. So it handles inputs in multiple languages and outputs in multiple formats, all going through the same Quarto machinery.

So in our talk today, we'll introduce you to Quarto through stories and demos. First, Mina will focus on how Quarto unifies the R Markdown ecosystem through stories of sharing and teaching. And then I'll focus on how Quarto extends the R Markdown ecosystem through collaborating and reimagining.

So we are so excited to get started. So let's kick it off with you, Mina, to talk about sharing with Quarto.

Thanks, Julie. I'm so excited to have the opportunity to talk to you about Quarto, which I've been living and breathing over the last year.

So I work at the intersection of education, research, and development. The word educator might make you think that I am in front of crowds like this, maybe smaller, 24-7 lecturing at them. But actually, I spend a lot of my time in front of my computer creating and authoring artifacts that I share with the world for the purpose of teaching. And I often think everything I create, I share openly with an open license that allows for use, reuse, and adaptation.

I often think web first for wider reach, but I also still live in the confines of academia and traditional publishing, which means that I still have to make a lot of PDFs. Therefore, an authoring system that allows me to achieve multiple outputs from the same input, the same source code, that brings code and prose together is not only essential for me, but it's actually basically what I need to carry on my existence.

And for the last decade, that has been our markdown for me. In fact, I remember very vividly when JJ and Yue gave a talk at USAR 2012, the first USAR I attended, on Knitter.

When I attended that conference, I don't think I would have identified myself as an R person. In fact, I'm pretty sure we went to that conference because we were going to Bonnaroo already and it was there, and I thought, why not? This was the summer of my first year of teaching at Duke. I was very dedicated to open science. I had already been working on an open source textbook, but this idea of kind of wider reach and open science, but also doing computing, I had not really put the pieces together. And one of the reasons why I had not put those pieces together is that I didn't have a good workflow to bring them together.

If you know me, you know that I'm a prolific sharer, and I like things to look pretty as well, not just be functional and pretty, and I really did not have a good workflow for being able to achieve that. But I started listening to this keynote on Knitter, and it must have been no more than three slides into it that I just actually pulled out my laptop and started converting my teaching materials to use it, because this idea that I can bring narrative and then code together and have it just be like syntax highlighted and look organized and be ready to be published on the web was just such a dream come true for me.

And by the end of that keynote, I was already brainstorming ways of not just me using it, but thinking about how can I teach this to my intro students?

So I am going to call this keynote a success. If some of you have already tuned me out, took out your laptops and have gone to Quarto.org to start playing with it. But I do hope that you will continue to listen with one ear and take in these beautiful illustrations by Alice and Horst. And for those of you who want kind of a more laid-back morning, you can go to this link, nina.quarto.pub, sit back, and I will advance the slides for you.

And over the last year of doing this with Quarto, I felt like I finally found the tool that allows me to do this easily without futzing around with my code and the content part of my document, but just changing a couple things in the YAML.

For example, if I want a lesson, kind of a single document as lecture notes or something, I can say format HTML. I can easily change that to reveal JS without touching anything else in my document, and I have a slide deck. I can simply call that file in a Quarto YAML file to create a website. And you can see that all I needed to change is just this YAML. I didn't have to remove slide breaks. I didn't have to relevel headers. That does save me some time, and that time can go to actually focus on the content that I'm developing, and that I find extremely liberating.

But ultimately, while easily creating documents in multiple formats is nice, for the sharing story to be complete, the tool needs to support easily sharing things as well. So something like that Quarto publish command that you can run in the terminal, and I'm sure soon a button in the RStudio IDE. I think that tooling that makes it easy to share what you do with the world on the web is incredibly useful. And it's not just useful to you, but to the world, as it facilitates open sharing of knowledge for learning and reuse.

I've been talking about me and my work so far, but I, like many of you, don't operate in a silo disconnected from others. Much of my work and much of Julie's work is collaborative. So over to you, Julie, for collaborating with Quarto.

Collaborating with Quarto

Thanks, Mina. I have gained so much from the open sharing and the web-first approach from the R community, and it has so informed the way that I collaborate and the way that I work.

So I work at the intersection of actionable environmental science, open science, and data science, and what I absolutely love doing is mentoring, teaching, and empowering communities, having learned from so many of you, like I said. And I wanted to pay this forward and welcome more folks to this experience that I've had with the R and Mozilla communities in particular. So I've made this my job through Openscapes.

Openscapes is an approach and a movement that I launched in 2018 and have built together with my partner, Aaron Robinson. Our flagship activity is mentoring research teams in open science. We think of open science as a beautiful landscape full of open source software, data, and communities and many paths forward. And we help people move from the sad, lonely animals in the foreground on the bottom left and towards this landscape so that they can explore this and navigate this safely with their teams.

And our role is to welcome folks at the trailhead and help them establish what that trailhead even looks like. Who's there? Who is part of the team? How can we think about who can be included and start this journey together with limited trampling and frustration?

So we work with professional research groups in government, academia, and nonprofits, and we help these teams modernize their workflows and shift their culture with their teams and within their organizations through open source software and open source practices.

Adrian Rios from NOAA fisheries has been part of Openscapes, and she describes this in this way. She says as fisheries scientists, we know that when we're in rough seas, it's important to keep the fish afloat. It's also important to keep the ship afloat and to get out of the storm. She says Openscapes helps teams steer out of the storm of email chains with 37 versions of the same spreadsheet and into the calmer waters of open science and meaningful collaboration using tools like R.

So I think that I have the best job. I get to mentor and collaborate with teams like Audion's who are doing really critical and hard work around environment and climate. And I get to help them do it a little better by connecting them to the open source tools and community resources that we all produce. And it really blends working with these teams really blends for me the role of mentoring and collaborating because I learn so much along the way.

NASA Openscapes

With NASA, you probably think about outer space, but they collect an unbelievable amount of data about earth. And researchers use earth data in many ways, including how to understand impacts of the heat waves and the wildfires that we're increasingly seeing through the summers due to climate change. These data are freely available from 12 different data centers across NASA, but researchers have to download these data locally from each of these data centers to analyze it locally, and this puts a huge burden on the researchers. So now, following many years of preparation, these data are migrating to the cloud through AWS and others, and NASA data centers will be supporting researchers who will be migrating their analytical workflows to the cloud, too.

So my partner Erin had ten years of experience working with the NASA earth data community, and she brought NASA and OpenScapes together in a three-year project that we leared together. And our focus is on developing, first and foremost, a mentor community across those 12 data centers so that they can co-create and teach common tutorials for these researchers using NASA earth data.

So let me just stop here and say that this is a big project, and it is awesome. But it was also incredibly intimidating to me. I do not know the NASA community. This is an organization I've looked up to my whole life. I'm not familiar with these types of huge spatial data that they're working with, the type of research questions earth scientists are asking and modeling, not to mention cloud infrastructure, which is a whole new era.

But an additional thing that was particularly intimidating to me as an R person is that many earth scientists use Python. And they are developing tutorials primarily in Jupyter notebooks. And my role in leading NASA OpenScapes was not to learn Python from the ground up, but I needed to be able to collaborate and interoperate and support Python users.

So something really powerful, though, is that I brought almost a decade of experience and confidence using R Markdown. And I've been able to you've probably heard me talk about this, because I talk about it a lot. I feel like it's a superpower. Quarto let me bring this superpower to Python. Quarto was emerging right when we needed it. And I asked JJ if we could use Quarto for NASA OpenScapes. It was really early in its development, and this became a really exciting collaboration between the Quarto development team and the NASA mentors.

This was a really generous and gracious group of people together as we were learning how to collaborate together and build tutorials and try new software. And we were able to, through our questions and use, influence some of the design features, particularly the freeze feature and how it operates with Jupyter notebooks.

So this is the first Quarto site we developed for our first teaching event last fall. This is where we really found traction as a mentor community, and we were able to make this beautiful collection of tutorials that was, first of all, helpful for our own development as we were learning to collaborate with each other, because we could see which tutorials were there already and where the gaps were. But it was also a very friendly, contained place for our learners to navigate through these resources.

And importantly, Quarto was also something that we were all able to learn together. And that turned out to be really important, because it turned out I wasn't the only person who was intimidated by all these moving pieces on all these new pieces of software and how to collaborate together. Learning Quarto together opened the door for us to talk more about our workflows and develop better systems for collaborating and really take this to the next level.

And from all of our investment and workflows, we were then able to rapidly create additional resources for the other teaching workshops that we were leading that were designed to meet those learners where they were and interoperate between the materials we developed.

So there's two things to highlight here. The first is that Quarto enables collaborating across coding languages. This is one peak of a way to think about this. This is a simplified view of one of our YAML files, where you can see we've got multiple file types here. These are mostly we've mostly focused on Ipy and B, Jupyter Notebook files in our primary development so far. But as we've worked more and more with the NASA research community, we've found that there is a substantial R community using NASA Earth Data Cloud. And it's really exciting that the workflow we've invested in and have developed together, we can use to support our users as well.

The second is that Quarto enables contributing from our current tools. So some of our team, mainly me and Aaron, used RStudio primarily. Some used JupyterLab, VS Code. Some edit directly in GitHub through the editor. And this was really important that we were all able to use our own tools, because with all these moving pieces, we were able to integrate that workflow into the comfort of our own tools.

Demo: Quarto in Jupyter

So this is a Jupyter Notebook, and it's actually running in our Jupyter hub. You can see we're going to interoperate with Quarto in the terminal here on the right, and we've got all the files that Mina just created on the left. So the first thing we'll do is we'll say Quarto preview. And this will provide a URL where we can review the previewed version of the site that Mina has created.

So I don't have R installed here. But with the freeze function, I'm able to open this in this new environment. So here is our beautiful website. I like to kind of have them side by side so I can see them refreshed. And if we want to add a Jupyter Notebook, let's say, oh, look, I just added one.

So this is a Jupyter Notebook I've got over here on this tab. And this is how we can think about Quarto. We've got our YAML at the top where we're going to say hello to Quarto penguins in Python. We've got our markdown text here, and we're going to use the Palmer penguins package in Python. This is how it will load the packages. And the way you operate this in a Jupyter Notebook is that you execute the code as you go. So when I press this play button, this is going to execute that code and actually embed it in the document.

So we'll do that again with a plot about penguins by clicking this button. And now this plot is here as part of the document. So the workflow here is that you execute the code as you go and as you develop, and then you save your file as you go. So this is the workflow in a Jupyter Notebook.

And when we save that, now we can think about adding this to our Quarto YAML. And the way we do that is exactly the way that Mina did before. I can add a Jupyter Notebook right here next to these Quarto files. And when we save this YAML file, we're able to peek at the terminal that's going to tell us when the site refreshes, and there is indeed our hello Quarto in Python. You can see it's beautiful, and it looks exactly the same as the QMD documents in R.

So if we wanted to add a figure caption to this plot, we would use the same hash pipe comment system that Mina just introduced. So I can put this figure caption here, and again, I can execute and save, and this when I refresh over here, this will show up in our document. And there is our figure caption. But you can see that it's not here. It doesn't do anything to the Jupyter Notebook. It's a comment in the Jupyter ecosystem. It's not affecting the Jupyter Notebook at all.

Let's add one other feature here in the code chunk option. Let's say we wanted to display this plot in the margin instead. There is our plot in the margin from a Jupyter Notebook.

So let's now say that operating between formats is really important, particularly when we're in collaborating. So a workflow that's been really powerful is to convert Jupyter Notebooks into Quarto documents so that checking them in with GitHub can reduce merge conflicts. So what I can do here is to say Quarto convert and tell it the file, and it will by default turn it into a QMD, and you can go back and forth between these formats. So you can see it's created a new QMD document, and when I open it in the editor here, this is now that same document with our familiar view in QMD form, and you can see the Python. So this has a lot of utility and power, and it's very important for teaching as well.

Teaching with Quarto

So over the last decade, I have thoroughly enjoyed teaching with R Markdown. When you get students in the class for the first time and you give them a fully functional R Markdown document and ask them to hit knit, and they can see their text and their code and the output come together before they even learn any programming. You can almost hear, wow, that's so cool in the classroom. And I've also loved that this tool is something you can introduce to introductory students on the first day of class and that it can grow with them.

However, as students' expertise grow in statistics and also in computing, and also their needs grow in terms of the different outputs they need to produce to, say, just a single homework document that they can turn in as an HTML to a well-formatted journal article or a thesis that meets the school style, there is a little bit of friction that happens. And a pleasant surprise, for me this was a pleasant surprise with Quarto has been that this leveling up has been a lot smoother. The learning curve for going from a single document to a multi-document project has been a lot smoother.

So I'll tell the story of one of my students. So this is Holland Stam. She's an art, history, and visual media studies student who I met when she was taking my regression course just last spring. Holland came to my class with just one semester of intradata science under her belt, where she had learned R Markdown. And in my class, we dropped these students into learning Quarto after a brief overview of how it's different than R Markdown.

And so she was doing her homework assignments and stuff as single documents in R Markdown, but at the same time working on her art history thesis, which was pretty quantitative. So if you've ever taken an art history class, you might be familiar with these two textbooks, Garner's Art Through the Ages and Jansen's History of Art. These are foundational art history textbooks that have been around for decades at this point with multiple editions. And what Holland was looking for is representation of different genders and ethnicities of artists and how much space is given to them in these textbooks and how this changes over, how, if at all, this has changed throughout the editions.

You can see her meticulously measuring in this picture. This is exactly what she did to collect her data. Actually measure the art that is featured in the textbooks through the editions and then join this information with demographic data on the artists so that we could analyze and kind of try to build a model to see if things have changed over the years, what representation looks like.

On the sad side, the representation was exactly what you would imagine, the lack thereof. But on the happy side of this story, as she was working on her thesis, she realized each of my chapters could be just like one of my homework files because ultimately what do we do in our homework? Write a bit of code, get some results out, interpret it, and that's exactly what she was doing. And then with a bit of Googling around and a little bit of help from me, she was able to bring these chapters together with a single YAML file and, you know, turned it into her thesis.

However, when she realized that she can add captions to her figures as she creates them in the code chunks and that she can, she does not have to manually style citations, millions of citations she had for this thesis project that she can just use the visual editor to insert these citations. She decided, I am willing to put in the effort to do that.

So as a side story, Holland was in my kind of research lab and she also worked with another student of mine, Sarah Lemus, and they packaged up this data. So Sarah was incredibly inspired by Holland's enthusiasm about this project and Sarah is a stats student who had been working with me over that semester to learn a little bit of package development by updating some of the data packages I maintained. So it was very clear to us that the enthusiasm between these two students, they should come together and work on this project together. So if you're interested in the data that Holland collected and Sarah and Holland put together, you can actually get this package off grant now. It's called Art History and has a really cute hex.

Demo: Quarto features for teaching

So just like Holland, Quarto has solved a lot of my problems as an instructor as well. So I am going to demo a few of those to you. Now first and foremost, you can open a Quarto document in the RStudio IDE and render it. I've shown you this before. Why am I saying it again? I did not have to install anything. Everything comes bundled. So if you are teaching in the RStudio IDE, no installation required and we can basically get going. And I think to me that's incredibly liberating.

Beyond that, though, there's really handy features. For example, with a single YAML field code link set to true, I can each of the documents that I create can now look a little bit like package documentation you may have seen where the functions are clickable and it takes you directly to the documentation for that function. And that is incredibly helpful for learning and teaching because it saves me a lot of time from adding those links.

Now on the learning side, let's try to make a mistake. And let's see that it's really hard. I want to write false in capital letters. I'm trying to make a mistake. Quarto is constantly telling me don't do it, Mina. So let's go ahead and think that I actually managed to do that. And let's render this document. The error that we get is human readable and it tells me exactly what to do. It says maybe you should try false in small letters instead. And this is incredibly helpful for new learners and also experts who might be frustrated reading through cryptic YAML errors and really kind of pushes you in the right direction to get things going so that, again, you can focus on your content and not the minutia in a way.

Now, as I said, as an educator, a lot of slide decks is kind of like my life. So let's turn this into a Reveal.js presentation again and let me show you a few of the handy features here that I use regularly. The fact that you get a document outlined by default is really nice if somebody loses their place. Everyone always asks, can I get a PDF of the slides? Now they can without you having to do anything extra.

Other things that are really handy is being able to annotate your slides. So we can turn on the chalkboard feature and this way you can go to something like a plot and start outlining things. If you, like me, have been an educator through the pandemic, I bet you spent hours in faculty meetings, how are we going to show things to students on Zoom? Well, this is one way that we can do this. We can also open a chalkboard and just start writing on it, which is really handy when you're teaching in a classroom where there's a projector screen but nothing else.

I can also turn on Multiplex, which is the feature we're using right now if you're following along, and it will, you know, move forward your slides for you. So even if your students fall asleep, they can sort of, you know, stay with you as you go through things. In order to do this, you open the speaker file and kind of present from that and post the non-speaker file for them.

Another thing I'm going to do here is to turn on the code so that it is visible, because when I'm teaching, I would like to show the code to my students. And let's show one more handy feature. Oftentimes when you have a big chunk of code, like a lengthy ggplot code, you may want to iterate through that highlighting things line by line. So with one chunk option, you can define which lines you want to highlight, and it automatically adds animation to your slides so that you can step through them. And to me, that's really helpful, because I didn't have to add characters to my code to do that.

Now, my plot is tiny. That's not helpful. But again, without me having to do extra work to move it on the next slide, I can say change the output location to next slide, and it will automatically do that for me without me referring back to an older chunk label or something like that. So again, a lot of these things, many of you might know how to solve, but I think the fact that they're solved so elegantly is quite liberating.

The last thing I'm going to talk about is what about the research side of my life. Well, let's open a new project, and let's go ahead and write a paper. I'm going to submit a paper to the Journal of American Statistical Association. With one comment, I can basically from the terminal use one of the templates that are available, and there's a growing number of templates there. Should I trust the authors? What do you guys think? Should we trust the core development team? I think I'm going to say yeah, okay. And I'm going to call this my awesome paper.

This will generate a template for me that I can author in Quarto, which means I can put my code and my text in the same document, which is how I generally like to write my code. And another nice thing here is that, you know, if I was to get rejected from this journal and wanted to submit to another one, changing between styles is pretty easy, again, without changing your source code.

So let's go ahead and give it a title, my awesome paper that's ready to be submitted, and I'll put my name as first author, and we can render it to a document, and if any of you in the audience have used the ASA style before, the output should look pretty familiar to you.

Now, there's unfortunately one drawback. Quarto does not write your paper for you. But my experience with the Quarto development team is that when you open issues, they're like really quick to respond, so I don't know, maybe by the end of the week they'll figure out how to write our papers for us, too.

Quarto flattening the learning curve

So we've talked about Quarto flattening the learning curve and, you know, basically saying that when we are leveling up from a single document to a multi-document input and going to various output types, and I said that this was a pleasant surprise to me. In hindsight, it should not have been a surprise. It's just not what I was thinking when I first started teaching with Quarto.

But if you think about the features of Quarto, like consistent citation syntax across various formats, more intentional control over when you should run and rerun your computation, and a single, minimal, human-readable YAML that controls inputs, layouts, and theming, everything in one file, all of these features contribute to flattening that curve for kind of creating more complex outputs.

But beyond just growing and expanding the scope of your work with Quarto, I think that Quarto can grow with learners in a profound way as well. The fact that Quarto is language and independent and also authoring tool independent offers an opportunity for folks to take Quarto with them in their data science journey, wherever that journey might take them.

After working on this for a year almost with Julie, I am almost tempted to learn Python. And maybe I will. But you know what? Who is learning Python are my students. And they're learning Python and Julia and other languages, mostly in their computer science courses. And to imagine that they could learn R in RStudio with Quarto in my class and then go take a computer science class where they're probably living in a Jupyter notebook and learning Python but still using Quarto, that sounds like an incredibly bright future to me. And a bright future includes things we can't imagine yet as well. So Julie will now tell us a bit about reimagining with Quarto.

Reimagining with Quarto

Thanks, Meena. So we've already seen how much Quarto can do for teaching and collaborating and sharing. And now I want to push it a bit further. What if we could reimagine open science as part of the climate movement? We know what this R community and the open science and open source communities are capable of. So what if we put that energy towards climate?

Because we're in a climate emergency, we must rapidly and radically reshape society. We need every solution and every solver. This is hard. And it's big. And my hope lies in this community and climate researchers and everyone in this movement who feels like what they do every single day plays a part.

So let's think about this concretely with three user groups in this community, in this movement. First are scientists who are working directly in line with climate change. This could be fisheries scientists who are studying where our food sources are migrating to as the oceans warm and operating with managers and stakeholders. They're working with really hard problems. These really hard big problems. That's really where OpenScapes has been really bringing this passion and this movement that we feel in the R community to help these researchers and help connect them there.

And I think now so many of you that I talk to in the open source and R communities. So the second category is open science and R communities. I know a lot of you are feeling stuck, too. You're feeling the pressure on climate and feeling like changing to more efficient light bulbs isn't enough. What if you aligned your daily work as part of climate action as well? We want Posit to be around in 100 years. What is 100 years going to look like if we don't act now and really put this effort together?

And the third category in theme with the conference is extendable beyond these two categories. So we really need every solution and every solver across all facets of geographies and people and skill level and experience with technology.

So this work is really hard. And we'll return to concrete things that we can do in a moment. But this really does mean slowing down a bit in order to speed up. But it speeds up like a flywheel.

My colleague Ileana Fenwick is a marine ecologist who participated in OpenScapes earlier last year. And she really quickly became a member of the team teaching and extending and connecting other communities and seeing what was possible. And the way she describes this is beautiful. Because of OpenScapes, I've renewed hope in how we can bring about a kinder future in science. I see a commitment in the open science community to bridging the gaps where we've left members of our community behind. And it inspires me.

Because of OpenScapes, I've renewed hope in how we can bring about a kinder future in science. I see a commitment in the open science community to bridging the gaps where we've left members of our community behind. And it inspires me.

So we're talking about a profound culture shift that involves real deliberate work on both the tech and the human side. And we've got the tech side really figured out. The momentum and the potential and what we're all doing is amazing and phenomenal. And we can bring that power and energy to the human side, too. We can build inclusion into our daily work.

So let's think about the teams or the colleagues or the people that you interact with. And I think that they are probably way more similar to the groups I work with than we might expect. First of all, it means talking to colleagues. Asking them how they're doing. Are they stuck? What does their workflow look like? Where is their friction? Who's contributing to our workflow? Where are the handoffs maybe between reports or data? Where are people feeling friction? What can we do to help? So this means asking all these questions.