R/Pharma 2021 Day 1. Rich Iannone. The gt Package: Past, Present, and Future

Hi, everybody. Welcome. And this is Ning from Roche, and I will be chairing the first session. So before introducing our first speaker, I just want to say that if you have any questions during the presentation, please feel free to ask them in the Q&A session. And if we have time left for a certain session, we'll try to go over that. So our first keynote speaker is Rich Iannone from RStudio. And Rich is a software engineer that focuses on writing R packages. So he really wants to help people accomplish things that were difficult before. He has been at RStudio for three years and has been immensely enjoying his time over there. Some of the R packages he has developed include gt, Diagram R, Blastula, and Point Blank. As far as outdoor activities are concerned, Rich enjoys meeting up with friends and wanders through the many valleys and ravines of the greater Toronto area. So with that, I would like to welcome Rich and he will be talking about gt today.

Thanks so much. So yeah, we'll talk about gt. I've got a presentation here. I'm just going to make this a bit larger. Great. So my presentation is called the gt package, Past, Present, and Future. We'll go through all three different time frames. And you can always find me at, you know, on GitHub. That's where my work is. You can contact me on Twitter, even by email. It's all possible.

Okay. This is like my elevator pitch for gt. It's a package that lets you create display tables or summary tables or presentation tables, whatever. Tables that you share with a declarative interface. It allows us to fine tune the final appearance of the table, which is great. We can integrate these tables in R Markdown and even in Shiny. So it's good for all those different applications. So I just wanted to prove that gt is a package. If you haven't seen it before, it makes tables like this. These are tables I made well before gt was even released in 2018. Not bad. Almost good enough for entries in the table contest. So this is what you can do with gt.

So that was the past. And I'll dwell a bit more on the past in this presentation. Three parts. Past, present, and future. The past sort of answers the question, what is the gt package and what actually went into it? It's a bit like a developer story. We're going to turn our attention to the present day. What can gt do now? And the more exciting part is the future. What's in store for gt and beyond.

The past: designing gt from scratch

So let's go into the past just for a little while. So way back in 2018, early 2018, we looked at a number of table packages available in R. I was surprised. There was quite a few. I thought there was five. There's more than that. So we looked at all of them. And we noticed they had strengths in different areas. Some were known to be a bit domain specific. You know, heavy on the stats summary stuff. While others are more general. You can just do whatever you want. We noticed that most handled one, maybe two, sometimes a few output formats. So we saw these and we thought, can we innovate in this area at all? And yeah, we thought we could. We wanted to make something gt plot like. We wanted to focus on noninteractive tables that delivered camera ready output in a wide variety of formats.

So we had a few core requirements before we even sort of started, you know, making gt. So the first thing we had to have was a declarative but forgiving API. So, you know, things we have today are from this. Like, we should always start a gt table with the gt function. Any statements could be expressed in any order, give or take. Order sometimes matters. But usually not. And each function should act as instructions. Gt should then figure out what to render. So it will sort of reconcile what you expressed and render the table in the right way.

We wanted to have table generation in multiple output types with the same API. So the same set of statements supplied here, gt should always work when taking the same code used for HTML. And, you know, you can also make a LaTeX table with the same code. We really wanted powerful formatters for cell values. So take, for example, this unformatted column of values. We want to have things like formatting to an exact number of decimal places, formatting as integers, handling rounding and things like that, changing separators, the digit separators, a way to express values in scientific notation, a way to use percent signs, perhaps not scaling, ways to force the percent the positive sign so it can show changes. We want to have significant digits. We wanted to have great support for things like currencies, you know, expressing values as bytes, even decorating values using a pattern. We wanted it to be flexible and have values formatted the way you wanted them to be.

We also wanted to have it so you can experiment in the API, like move columns to the right, move columns around, you know, have GT do things for you, like group columns together if they're united under a single spanner, or you can just move columns manually.

We really wanted footnotes. That's a thing we didn't see too much of in other table packages, but we know it's a thing and we wanted to have it in there. We wanted them to be pain-free. So we didn't want you to have to worry about them and manually sort of reorder them. First of all, we wanted it to be straightforward to define table footnotes. Then we wanted the ordering to be sort of automatic. And the more advanced features are things that are just expected in footnotes, like we should be able to apply the same footnote to multiple locations. And if you have multiple footnotes at one location, that should be allowed and it should handle the numbering or lettering, you know, in the right way.

So, you know, we worked away at it in most of 2018. We released it in 2018. We had HTML as, like, the main output format, but we had LaTeX and RTF as experimental output types. Since then, we had tons of conversations with people on social media, inside GitHub issues, and through lots of customer conversations. And through those conversations, we learned pretty quickly what was, you know, what was working and what wasn't working at all with GT.

So we got to work on fixing stuff. So we improved the RTF output support. We improved LaTeX, because, you know, they weren't too good at the beginning. We added additional cell formatters, like these ones right here, and we improved the existing cell formatters as well, added more options. We provided more ways to style cells, which was very important. It's what people wanted. And we had various other quality of life improvements and API enhancements.

Okay. In terms of those customer conversations with people, we had lots of those with people in pharma, and we discovered what the biggest requirements were. So we had conversations with Yilong Zhang from Work, Tom Tensfeld and Mike K. Smith from Pfizer, Mike Sackhouse from the Taurus, Devin Pastore and Evan Eveson from Metrum, and Adrian Waddell and Gabe Becker from Roche. So one of the big things we had to do was, again, fix RTF and LaTeX. That was an important set of requirements for pharma. We made them quite a bit more reliable. We got much more dialogue going about what pharma needs through a working group. It's called the R Tables for Regulatory Submissions Working Group, and it's put on by the... well, sponsored by the R Consortium and put on by Joe Rickard. It meets every six weeks, so it's just like an advertisement for that. If you want to join, please contact Joe or any of us at RStudio. All are welcome. If you have any interest in guiding requirements for regulatory tables, this is the venue for it.

What gt can do today

Okay. So that was a bit of the past. I didn't want to go too deep into it, but I do want to talk about what GT can do today. So you can make really nice presentation tables in GT. You can make really nice presentation tables in three output formats. Here's the same table in HTML, in LaTeX, and here it is from RTF, actually a screenshot of the table in Word.

And GT works really nicely with R Markdown and Quarto. If you don't know Quarto, it's a great publishing system, and it works in Quarto, and you should definitely try it out if you're, you know, really into this sort of thing. So we were pretty happy because people tend to be using GT. We were seeing evidence of a large and enthusiastic user base. Some metrics, you know, we don't see this too often, but there was this plot that was made by Tom Mock, mentioned since 2010 in Twitter. GT is actually in the ranks, which is not bad for a package released in 2018. Lots of GitHub stars, which is, you know, good to see.

We did some work. We closed quite a few GitHub issues, and we talked a lot about GT. We gave a lot of presentations and delivered a few workshops. And people on Twitter, that's a place where I see a lot of GT. It's always a little hard to see GT tables on there. These are actually GT tables. I couldn't believe this was actually one. It looks like a magazine page, but it's actually a table made with GT, and this is one as well. I couldn't believe it until I saw some code, but yeah, that's a GT table.

We had some contests. In late 2020, we held the RStudio Table Contest, and you can submit any tables from any table package, and a lot of prizes were given out. And the same thing is happening now in 2021. There's an ongoing RStudio Table Contest 2021 edition.

GT, we wanted to make it usable to other packages. So, not just, like, you know, creating one-off tables, but you could use GT in another package to create table outputs. Here's some examples from GT summary, which is an incredibly awesome R package for making summary tables. Point blank, where, like, some of the reporting outputs are GT tables. And GT extras by RStudio's own Tom Mock. If you need, you know, more HTML power, then this is, like, a slam-dunk package for you. It's just amazing.

So, that was all good stuff, but where does GT fall flat? I mean, it's not a perfect package by any stretch of the imagination. We actually learned from several users in Pharma, we had quite a few conversations, that not all their table requirements are fulfilled by GT. There's some table typologies that are needed by Pharma, but they're kind of difficult to make with GT. So, some examples are, you know, heterogeneous columns. So, you have, like, some values down a single column, and then some text. Well, how do you format these values? Well, not so easy. Multiple spanner levels. You know, we can have level one spanners in GT today. Level two, you're not going to get it. It's just not available. It's not expressed in the API. Okay, indentation levels in the table stub. I mean, you can sort of do it by styling, but it's not really first class, these indents. You can't really establish a hierarchy in the table stub, and you kind of need that.

Okay, some of the things we saw were, you know, in Pharma, there's all sorts of great table generation packages, and they have APIs that are directly tuned into Pharma's needs. However, you know, one thing we noticed, and we notice this everywhere, output formats are limited. So, R tables, its main thing is ASCII. It pumps out ASCII tables. It can sort of do HTML. It's sort of like a new format that it's in development. Another great package, tplyr. Just incredible. Creates HTML in the tech. Use another package to generate RTF, and, you know, it has to use another package to generate RTF. So, you know, it's a problem. But these packages are ideal for Pharma. Rendering support is a mixed bag, which is unfortunate.

The future: introducing TGen

So, that brings us to the future. What's in store for GT and beyond, and I hope I'm, you know, sort of leading in the right direction about where I'm going. We're going next. We're going to break things apart with GT. So, while GT is general, a large amount of effort was put into rendering for multiple formats. So, right at the beginning, we wanted to have multiple formats generated by GT.

Okay. R tables. So, I hope you've heard that package. Maybe you haven't. Adrian Waddell and Gabe Becker at Roche, they made this package. They're developing it. It's perfect for what Pharma needs, but it has different support for table outputs. You've seen that before. ASCII is kind of like the main thing, getting into HTML. It doesn't have RTF. So, that's a problem. Okay. So, this is, like, the beginnings of a solution, or sort of, like, a way to fix this. What if we made a separate library for rendering that others can use? So, this is like a graphics device, but for tables. So, a separate thing that you just throw your table representation into this, and it faithfully pumps out other formats, any format that you want, and we'll just have one thing do all of the outputting.

Okay. That's the proposal. So, we think that's a good idea, and it's worth the development investment, like, really worth it, and it's underway. It's called TGen. So, that's what it's called. We're keeping it under wraps for quite a bit longer, because really, it's very, very alpha. It's just, like, sketches that sort of work. We want to save you, like, the, you know, like, the headaches from, like, looking at it. So, you know, we just want you to know about it for now. So, this is the first mention of TGen at any conference. So, this is, like, a really early look.

So, this is the first mention of TGen at any conference. So, this is, like, a really early look.

So, some goals for TGen, because goals are important. It's not meant to be used directly by R users, but through packages. It'll contain R functions for describing tables using a low-level API, like these row and cell functions that are constructors. It's designed to be a good fit for any table packages that are making static tables, present and future packages.

So, R tables, it makes farm-of-focus tables, TGen renders. You know, let's just combine them and see what we can do with it. So, what we've done is we've created a fork of R tables that interfaces with the TGen R package and provides support for LaTeX rendering, which R tables currently doesn't have. So, let's actually see it in action. I'm going to go to my favorite IDE, which is RStudio. And we did some work here in some other files to make it work. And what we've done here is we took one of their vignettes, or this is one of their vignettes. We just called it PDF document. Okay. Because before, the tables are being rendered as text. Okay. So, let's actually render this in real time. It's a bit of a long knit. In the meantime, I do want to show you that here's the vignette from CRAN. And these tables here are text tables. Okay. This is like the before. And as soon as this knit is done, we will have a proof of knit and also some LaTeX tables in the vignette. Because it's all LaTeX. Okay. Here we go. I'm going to zoom in a little bit. And there we are. This was done by TGen. So, tables are here. It's got indentation. I'm going to scroll down. There's lots of tables. I don't want to go too far. But these are just text tables. Word text tables. But they're all LaTeX tables. Okay.

So, that's my little demo of what TGen can do in this very early stage. TGen handled the rendering. Our tables team didn't even know about this. They didn't focus on it. They didn't ask for this. They just got this kind of for free. So, in the future, they just need to use TGen for the rendering. And the great thing is they can just focus their efforts on making a great table APIs for the industry. They don't have to work on the output stuff. Just let TGen handle that and work on the API side.

They don't have to work on the output stuff. Just let TGen handle that and work on the API side.

Okay. So, we plan to extend TGen with features that Pharma can make use of. So, this is like an open call to developers of table packages. We want to talk to you. Tell us about what you need from TGen. Just get in touch with us. There's multiple lines of communication. And, yeah, that's pretty much it. Just, you know, talk to us. So, we recognize there are table requirements that are particular to regulatory submissions. And that will be addressed in TGen. As far as, you know, being responsible, all GitHub issues will be seen by the team and we'll actively participate in discussions. And we'll continue to prioritize any action items from such engagement. Because, you know, it's the pharma industry. We love you guys.

So, in the future, I can sort of see this. There's a logical endpoint for Roche. We can have access to an eventual package that makes regulatory table creation as simple as a single standardized function call. So, Roche's vision of this is using a few packages. One is RTables that we've talked about. It's a general table generation package. It's open source and on CRAN. There's two more that they have in development and they're currently closed source. They're works in progress. One is called Churn. It builds on RTables, providing many helper functions. They're common for pharma. So, we can make adverse event tables. And Chevron is something that builds on top of RTables and Churn and provides functions that implement specific FDA submission tables. So, one function per table. So, the way this works is this will be sort of strung together. And they're currently making preparations for collaboration within the industry and the open sourcing of Churn and Chevron. And by combining Roche's staff with TGen, it should be possible for you to take advantage of these tools, regardless of whether your workflow is based on ASCII, HTML, RTF, or PDF.

So, we want to focus a bit on TGen and make it work for GT first and then help others make it work for their own packages. Again, we want to have support for HTML, RTF, LaTeX, and beyond. Migrate the rendering in GT to be TGen mediated. So, the core priorities for us will be TGen and GT going forward. But we are still keeping on top of all things that are important for users of GT. We won't do much on table rendering, of course, since TGen will be eventually doing all that. But, you know, GT still needs a ton of work. And many more things can and should be added. Like things like more formatters, better formatters. Ability to easily make manual changes, like adding rows and merging cells, sort of like arbitrarily. Unlimited levels for spanner labels, enhancements for footnotes, because there's always more to keep can do there. And ways to access values from a GT table. And this is particularly useful in R Markdown and Quarto.

Education, outreach, and closing

So, that sort of like ends that. I wanted to sort of like end off by saying education and outreach are pretty important to us. This would be nothing without, you know, teaching people how to use it and like, you know, being involved in the community. So, to that end, I recently provided a workshop here at Arm Pharma. It's recorded. So, soon it will be available for everybody to see. Also, if you poke around on my GitHub, you'll find all the source material there as well. I think it's called GT Workshop is the repo name. And in the near future, I'll be putting my streaming hat on and teaching some GT and maybe some other R stuff in the Pharma casual setting of Twitch. So, I'll let you know when I broadcast there. And I'm always available to conduct more workshops. Just ask. And, yeah, it could be like small, large. It's really not a big deal at all what format it's in, as long as it happens. And if you have any questions about GT, where it's going, just, you know, problems, issues, contact me, Phil Boucher or Jason Mills, and we'll be sure to get to you in short order. And that's really it. I just want to say my presentation, it breezed by because I really want to have lots of time for discussion. And it's available here on this GitHub site. So, that ends off my presentation.

Q&A

Thank you very much, Rich. It's very amazing to see the new features and also the cross industry collaboration. Just a reminder to everybody, if you have any questions, please feel free to ask them in the Q&A session, and we'll spend the next 20 minutes or so to address those questions. And I'll be monitoring the Q&A session over there. Also, please feel free to vote up the questions you want to answer, you want to hear about as well.

Yeah. So, I guess my first question is that it's very exciting to see the TGen work. If people want to, say, contribute to a new feature or test out the alpha version or pre-alpha version, like, is there a way for them to get involved early? Yeah. I would say just contact us, because we're sort of, like, keeping it a bit private, because it really is super early. It's almost, like, very rapidly developing. So, I would say just, again, contact them. We'll, if you have video chat, if you're into that. Otherwise, you can have an asynchronous chat in other ways. Just reach out to me. And that's probably the best way at this early stage, because we don't have any of the usual mechanisms, like GitHub, you know, like issues or discussions. And it's a bit more personal to talk to us. And we always enjoy it.

Cool. And you also mentioned about the table working group, right? So, would that be a good channel as well? Yeah. That'd be perfect, actually. Yeah. We'll talk about it there. There'll be, like, maybe some demos as time goes on. And it's a really good group. And, like, you can learn a lot just by knowing what other people need in the industry. So, it's useful in lots of ways. Not just for, like, learning about GT. It's about the whole scope of, like, getting regulatory tables done in R.

Cool. Awesome. Yeah. And then there is a question about interactivities. Like, I think there is a question about, like, whether you have any plan on having some interactivities just as just, like, paging and collapsing. Yeah. That was thought about. And we do want to do that. We sort of pushed that a bit back, especially since TGen is getting off the ground and becoming a bit of a focus. We do want to have some light interactivity in the near future. So, definitely watch that. But I think the core priority is still that the problem space that is not fully solved is, like, static tables. But you never know. I'm not ruling it out. But it's definitely not going to be this year or early next year for that.

Cool. Yeah. And maybe one related question from me is that in terms of the RStudio, like, ID integration, I remember, like, there was some integration for GT. Is there any plan to, like, have that as well? Well, the great thing about TGen is you never have to see it. So, there really doesn't need to be integration. We just have to make sure that all the tables get rendered properly. And then we hope with, like, TGen, you never see it as a user. So, it's kind of like, I guess, no for that.

Yeah. Cool. Thanks. Yeah. And any plans to add hover text to GT tables? Sorry, what text? Hovering text. Oh, hovering text. Well, you can do that sort of in if you have HTML output tables. You just have to know a little bit of it would be a bit of an HTML wizard to do that. But it's all possible. You can do things like text transform to modify the text, like, the cell text in each cell. And then you can replace stuff with a template that contains hover text. I actually do that in point blank. I use a library called balloon.css. And it has really beautiful hover text. If you want any clues how to do that, just look in the source code. I know it's terrible. Go check the source code. But if you do, you'll get some good clues about how to use hover text that looks really nice.

Awesome. Yeah. I see another question also for HTML. It's kind of asking if they have, like, a very long or wide table, can there be kind of, like, fixed header and fixed position, et cetera? Yeah. Oh, I see. Yeah, yeah, yeah. That is a definite issue we want to resolve. Especially when it comes to, like, attack tables and things like that. So, yeah, that's on our watch or sort of like our to-do list to solve. Because, yeah, that's a known issue. And personally, I don't like it.

Cool. Awesome. Yeah. And another question about getting feedback and, yeah, whether they should give feedback via GitHub. I assume GitHub issue will be a good place as well. Yeah, GitHub is not bad. If you even just put it in the GT repo, like, issue there, that's great. And if you don't want to make it an issue but have, like, sort of, like, these questions, you can definitely use the discussions area too, which is sort of, like, a new feature of GitHub. And it's activated in the GT repo. So, yeah, up to you. Just the key thing is that you just, you know, post it somewhere, and we'll see it.

Cool. Awesome. Thank you. Yeah. And some questions about submission. So, one question is, like, for the probably the scope or the vision of TGen, would that be, like, providing some common functionalities for general regular submission or that will be tied with, like, specific companies' requirements? I assume it's no, but I want to hear from you. Yeah, it's definitely no. Basically, by the time the table reaches TGen, it will be fully resolved and worked out. It will just have, like, a specification for a table, which means that everything will be formatted, all the text will be there. There's, like, nothing left to do except render. So, definitely no more reshaping and no more moving things around. Yeah, that's what TGen does. And it's kind of nice. It's free. In that, you can separate the API from the sort of, like, the compilation side or, like, the sort of, like, the table device side. So, yeah, definitely there's going to be no more, no functions like that in TGen.

Yeah, and I feel like from the working group and from your slide, we see, like, a good diversity of companies. So, I assume that, like, all the feedback will be taken. Oh, yeah, absolutely. Yeah, yeah. Cool.

And several questions about the streaming, the switch streaming. Could you provide a little bit more details on how to find it, et cetera? Yeah, so I'm still working that out. I've sort of, like, I dusted off my old Twitch account, and I've been improving my equipment here in the office bunker. So, I'm making this, like, a stream-friendly area. And basically, yeah, I'll do some GT stuff. I'll start with that. I'll do some other R things as well as I think of them. I'm sort of developing a program, like, a program of things to do. But, yeah, it might also be things like delivering a GT workshop, maybe some more advanced stuff. I will post it maybe on Twitter and other places and get it amplified so you hopefully hear about it. And, yeah, that's my goals. That's my late 2021 goals and to get sort of, like, a little more active with teaching GT.

Awesome. Yeah. And I saw another highly voted question is about RTF. And I feel like you already mentioned that, but is there anything else you want to mention about RTF integration and functionalities around that? Yeah. Well, RTF is a big thing. So, we definitely want to have that in TGen. We want to improve on it. So, basically, we want to see what's important in RTF tables are actually, you know, sort of, like, submitted. And we want all the things to be possible in TGen. RTF is kind of a tricky one because it's the hardest code to generate. But we think we could, with all the lessons learned from GT, we can port that over to TGen and even make it better. Because right now in TGen, we have better LaTeX support than we ever had, you know, even presently in GT. So, it's actually quite nice just to have a thing where you just focus on the output, the rendering side.

Thank you. You're welcome. And then another question, what about GT to mark down to PowerPoint or other slide format, besides slide generation? Yeah. Yeah, that'll be eventually supported in TGen as well. So, everything is sort of moving over. And it's definitely on the radar for something to be done. I actually have a fork or a branch of GT, which does Word table output. And it's just as good as RTF. We, you know, we sort of, like, didn't release that because we're going to work on TGen support over there. But you're definitely free to try that out. Just, like, you know, load the branch into your library and use that in R Markdown in a Word document. And you should be able to get GT tables in a Word document through that. It's a little hard to find, but if you have a question about where to find it and how to install that, just reach out.

Awesome. And one question about row spanning. Is row spanning or cell merging in the works for GT packages similar to column spanning, but for rows? Yeah, I think so, yeah. So, things like, we'll have things like ways to merge and also to add structure to rows, like hierarchical parts on the left side. So, yeah, it's definitely a thing we got to do. And also things like, we have row summaries, we want to have column summaries as well. So, that's something that's definitely on our to-do list.

Cool. Awesome. Yeah. Yeah. I think we covered most of the technical questions. Yeah, maybe you can spend the last five minutes or so just, like, talking about collaboration and maybe talking more about you. And, like, one question is that, like, I see that there are a lot of activities going on since last year, the GT presentation last year. Yeah. What was, like, the most inspiring feature or surprise learning for you, like, during the past year? Yeah. Yeah. It's kind of, like, people want different output formats. And I was like, it's a constant thing. That was surprising to us. We thought, you know, just a few would be good. But, no, we got to have more breadth of output formats. And that's really what we're hoping TGen will help achieve. Because it's, like, separate and sort of, like, self-contained, we don't have to worry so much about the impacts on the generating side, like, the API side, which is great. So, it's, like, isolated and we just work on output formats. And we really need to generate, like, almost, like, eight or so of them. And it's basically all the Office outputs, which are Open Office XML, HTML, RTF, PDF, text. There's probably one or two even more beyond that. But, yeah, it's constantly surprising, actually, you know, just how often it's asked for and how much is needed.

Cool. Awesome. And I guess, like, for this presentation, you are more focusing on, like, pharma use cases. Just curious, outside of pharma, what are the other, like, spaces that people are using GT and what are their requirements, et cetera? Yeah. One big space that we noticed, especially on Twitter, is, like, sports analytics. I see the bulk of tables is, like, analytics from sports. So, it could be, like, NFL. Sometimes it's hockey. Lots of times it's basketball. But it's really great to see because, like, you get, like, sort of a sports stats nerd. So, it's really awesome to see that stuff. And, yeah, that looks like a big area of, you know, abuse for GT. I'm trying to think of what else. I mean, that's the one I see the most, besides pharma. Yeah. I see pharma and that are, like, the biggest ones. And also just generally science as well.

Yeah. Maybe experience sharing for developers. Like, how do you handle those, like, massive amount of requests from different areas? Yeah. Well, you know, we sort of triage everything in GitHub. We prioritize. We think, you know, we sort of, like, balance what we can do quickly with what's most important. So, that's how we choose to work on a feature. Sometimes features take a long time to implement because we really want to get it right when we do release it. So, it takes a bit more time. Yeah. So, it's sort of that balancing act. Like, there's, you know, we sort of lump things into groups and triage and try to be sort of methodical when it comes to handling enhancements. Things like bug fixes, we want to fix right away. So, we definitely prioritize that the most. But when it comes to features, yeah, we want to be careful and work on the things that, you know, a lot of people can use and can be done nicely.

Cool. Yeah. Do you have, like, people, like, for developers, do people, like, specialize on one area? Or, like, you guys are kind of, like, taking tasks just, like, based on the urgencies, etc? Yeah. It's basically just on urgency. And there's not too many of us working on GT, actually. You know, maybe two or three at a time. So, yeah. So, we don't have much, like, you know, like, doling out of different tasks. Yeah. We just sort of take it. We use triaging. And, yeah. We handle things in sort of that order and make sure we get it right.

Cool. Awesome. Yeah. Maybe the last question. So, yeah. I feel like, like, big progress has been made, like, from the cross-industry working groups. And it's amazing to see that all those people come together. As you mentioned, like, all people come together with their, like, own kind of grassroots efforts from their company and now really try to make a, like, a single package that are usable for wider audience over there. Could you share a little bit of experience on that? Because I know right now, like, there are multiple working groups hosted by different organizations, by fields, by archivist, etc. Just any experience, any tips on how you guys, like, came to this stage? Yeah. Well, that's all Joe. Joe Rickert. He does the working group for our tables. Cool. And, yeah, he'd have more to say on that. But he was able to get off the ground and get lots of people initially. And so, and the group has been, you know, growing a bit. And, you know, and every meeting is good. We learn something new. And let's say it's a success. So, yeah, definitely join if you can, if you have any sort of, like, any interest, really, in this sort of thing. And just give us, like, if you don't like it, you can always, like, you know, just go for one meeting. But I think it's worthwhile. And it's a great thing.

Cool. Awesome. All right. Thank you so much, Rich. I feel like we learned a lot. And I'm pretty sure people are eager to try out the new TGen package. Yeah. So, thanks again for the great presentation. And, like, I guess if people have any questions, they can find where, like, the channels you mentioned. Yeah, right here. Yeah. Yeah. I'll, just contact me and I'll talk to you. Cool. Awesome. Thank you. Yeah.