Skip to content
PodSubs
ShowsPeopleGuestsJobsNewsEvents
More
BlogPodCred
Menu
ShowsPeopleGuestsJobsNewsEventsBlogPodCredNetworksSign in
Join nowSign in
  • Shows
  • People
  • Jobs
  • News
  • More
    • Guests
    • Events
    • Blog
    • PodCred
    • Networks
    Join nowSign in

R Weekly Highlights

R Weekly Highlights artwork

Issue 2026-W09 Highlights

Feb 27, 202651 minAudio
ShareXLinkedInFacebookWhatsAppEmail

Choice is good, but sometimes you may want a little help! Our first two highlights showcase approaches you can take to inform your next LLM for analyses and open-source license. Plus how to make your mark(s) within your version control history. Episode Links This week's curator: Sam Parmar - @parmsam@fosstodon.org (Mastodon) & @parmsam_ (X/Twitter) How to choose the best LLM using R and vitals Pick a License, Not Any License Git commits: please mark your stitches! Entire issue available at rweekly.org/2026-W09 Supplement Resources rollama - R wrapper to Ollama https://jbgruber.github.io/rollama/ Opps, Git! How to recover from common mistakes workshop https://r-posts.com/oops-git-how-to-recover-from-common-mistakes-workshop/ Supporting the show Use the contact page at https://serve.podhome.fm/custompage/r-weekly-highlights/contact to send us your feedback R-Weekly Highlights on the Podcastindex.org - You can send a boost into the show directly in the Podcast Index. First, top-up with Alby, and then head over to the R-Weekly Highlights podcast entry on the index. A new way to think about value: https://value4value.info Get in touch with us on social media Eric Nantz: @rpodcast@podcastindex.social (Mastodon), @rpodcast.bsky.social (BlueSky) and @theRcast (X/Twitter) Mike Thomas: @mike_thomas@fosstodon.org (Mastodon), @mike-thomas.bsky.social (BlueSky), and @mike_ketchbrook (X/Twitter) Music credits powered by OCRemix Seven Pipes to Heaven - Super Mario Land - Nostalvania - https://ocremix.org/remix/OCR03256 You Are Not Confined - Final Fantasy 9 - Sonicade - https://ocremix.org/remix/OCR01064

Audio and video play straight from the show's own hosting. PodSubs stores and serves no media.

Transcript

From the show. Tap a time to play from there.

Hello, friends. We are back with episode two twenty two. That's a row of twos, if I dare say so myself, of the Our Weekly Highlights Podcast. This is the weekly weekly show where we talk about the latest happenings and highlights that we are sharing every single week at rweekly.org. My name is Eric Nance and I'm delighted that you're joining us from wherever you are around the world and unfortunately my co host is still digging out of a lot of cruft on the outside with snow and his neck in the woods, Mike Thomas. Mike, I'm so sorry, man. I feel like you just went through this, but you had to go through it again, It's okay. It's almost a daily occurrence at this point, seems like. So we've got

some snow, mountains and hills in our yard that are taller than me, but, it makes for fun igloos and and fort making on the warm days. That is true. We had a good share of that back when we had our batch here, but I do admit I am a happy camper about something else. Sunday morning was a glorious morning because now our country of The U. S. That we reside in can be considered the hockey capital for the next four years. Both the men's and women's U. S. Teams have brought home the gold,

they were exciting games, both went to overtime, I haven't been that excited watching a game since probably the mid-90s, so good stuff all around and yeah I'm gonna savor that for a bit. Definitely that three on three overtime will make you grab your seat. Yes and not everybody's happy about that, that's a different matter altogether but the town was there on all sides of it that everybody knows the rules beforehand. So gonna bask in that glory for a little bit longer, although the regular season is

just started again last night. It's very difficult watching the regular hockey after that glorious two week fest, so it's going to take a bit of adjustment for us hockey fans. Those of our listeners north of the border, you have my condolences, but we needed one in forty six years, so hope you're happy sharing the wealth a little bit. Can Connor McDavid win the big one? Eventually he will, it just may not be where he's at now. He was trying to in overtime. He sure was, yeah. I felt bad for him, but no,

you know, it is what it is. That's the juvie of sports, but we're not talking about sports here. We got our to talk about with its own share of great fun here. And this week's issue has been curated by Sam Palmer. And as always he had tremendous help from our fellow RWQY curators and contributors like all of you around the world with your poll requests and other great suggestions. Yes, we are living in the world of large language models and using them for many tasks in our daily work, or maybe we're just getting started in our journeys and we don't quite know

what to expect because just like anything in this world of tech, y'all got choices when you start this world, such as which frontier provider to use, which actual models from these frontier providers you use, what are the benefits and trade offs for your particular task. Sure would be nice to have a way to kind of, you know, take in a principle that we've done in the past in, you know, computer science and statistics and maybe run a little set of experiments, you might say benchmarking,

on how these models can actually perform. Well, on the R side of things, there is very much a package that can help you do just that and to walk us through this with a very comprehensive case study here is Sharon Machlis, who has been, you know, world renowned in her coverage of R for many years with InfoWorld, and now she is, I guess, kind of retired now, but she's still blogging away, so finding her spots to pick and choose, but she has been, you know, pushing the limits of her adventures of AI. I've been watching her ever since she started adopting this and writing about, so she has a great blog post that we're going to talk about here in this first highlight here. And yes, as I mentioned,

the vitals package is the star of this show and it has been inspired by Python's inspect framework. If you're on the Python side, you've been doing marginal language models for a while. The vitals package is authored by the team at POSIT and in on to 10, what it is supposed to do is to integrate with another package we talk about quite a bit, Elmer, as your kind of one stop shop to interface with a mix of different large language models in R,

but what Vitals will let you do is to let you set up these experiments, if you will, and let it judge the performance of different models based on criteria that you specify. And how do you specify that criteria? Well, you can create a data frame that at the minimum must have two columns associated with it. First is the input column, and this is corresponding to what is the request that you want to send to the LLM provider.

And then the other column is target, and this is what you expect the large language model to respond to that request. So as you can imagine, this can be very detailed, maybe very general, but she does mention throughout this post that the more specific you can get, probably the better off you'll be. You can add some additional metadata to this if you wish, but this is, one of the easiest ways you could start doing this. Pull out your favorite spreadsheet editor of choice and just start, you know, populating different rows of this corresponding to maybe the different type of task you want to do. Maybe you give a unique ID

and in the case of this blog post to start with, she's got three different kind of areas that she wants to benchmark here. One of which is to have the LLM create a bar chart with ggplot2 and do its own sample data and basically giving you some instructions on what to do on the axes labels, how the bars should be sorted, pretty straightforward. The other task is a sentiment analysis of text

and she asked the LLM to rate it as either positive, negative, or mixed. And she has an example here of desktop processor reviews, which I know run the full gamut depending on what you look at. Intel's had some quirks the past couple years and boy did that enter the Bloch Sphere recently. Last but not least, she has another interesting one here where she asked the LM to make a haiku, very, very straightforward there,

and then she is very, direct with the target that that must be like a three line poem with five syllables in the first line, upper symbols in the second and third line. So once you have that data frame ready to go, it's time to boot up vitals and ELMER, and you define then a task via the task R6 object, believe, and you give it a new and you feed in your data set and you got yourself ready to go to start associating it with some other things because it's one thing to define what your input and target are, now you got to tell

vitals what you want to do to solve it. And this is where the Elmer comes to play here. The solver is a way for you to usually interface with a chat object from Elmer to actually carry out the task. There may be cases you might need to do a custom solver for some more specific needs, but you get the ability to do either way. And yeah, being familiar with Elmer is definitely helpful here, but the other thing to note is that this is the part where you're going to interact with a model.

So if you are using a frontier provider, make sure you got your API key ready to go and all your authentication stuff ready for you. That's a non issue for local models, which we'll get to later, but at least for the frontier ones, you got to get all that squared away in Elmer first. Last but certainly not least, it's one thing to send that query out there, but you got to actually benchmark it, right? Now that implies the third component of vitals is the score. Now one popular method is that you let yet another LLM

play the role of judge and this is right out of the box. They have a function called model graded QA, which is basically using that LM to test how it solved that particular question or that task, if you will. You can also give it some different ways of how to solve it, how maybe it needs to look at things like exactly being specified, or maybe certain keywords must be part of the response.

There are lots of ways you can customize that, but again, you want to be diligent on how specific you get in your criteria. Sometimes the more vague you are, that can cause issues later on depending on the model you're using. So you can also say, do you want it to just be kind of a binary type of thing where the answer must be 100% accurate to your target or not? Or you can let it do partial credit to get it kind of seen.

Just like if it got closely there, there's a parameter called partial credit that lets you be a little more lenient on that. And she's explored different models to be this judge. Seems like opus4. Six seems to be better at this, but you are paying more for that as as opposed to, say, the Sonnet model that came previously. But, again, there may be other things that you can use or models you can use such as GitHub models or maybe some other ones from different providers,

depending on how extensive you want to take that grading task, so to speak. So once you set all this up, it's time to evaluate it and that's simply the eval method in vitals. And with that, you are going to then be able to finish running that. It actually does five processes under the hood or methods. The idea of sending it out there, scoring it, doing a log of that, getting the measures accurate, and you will get then a

way you can view the different tasks in more detail if you wish, as well as looking at the log file too. And this is where putting our stats add to the play, that might just be one execution of it, but just like anything in statistics, you might have weird variation depending on how many you do here, so that's where a parameter called epochs comes in. This is akin to maybe iterations if you do a lot of parallel processing or resampling if you will. So you might want to bump this up to say 10,

maybe more, but again the more numbers you bump up here, the more you may be paying out of your pocket because you aren't paying these frontier providers if you're going out that way. She did a little, cost estimate it was about 14¢ to use SONNET as the judge in these cases versus 27 for opus on say 11 runs of this. Again, mileage may vary, but again that's always good to keep an eye on how this might perform.

Now that invocation may just use one model provider. Of course, the idea behind this, you want to compare multiple models. There is easy ways that she outlines in this post of how you can simply swap in another LLM provider if you wish to augment that existing task, or you can start it from fresh. There may be some benefits to doing either approach. In the end, if you're doing a new model, again, you need to make sure you're authenticated that correctly, and you'll be off to the races.

So maybe you've done multiple tasks or maybe you've iterated on that similar task. It's time to actually look at the results, and that's where the vitals package has this handy function called vitals bind, which will let you literally, in essence, row bind, if you will, the multiple tasks that you ran to do the benchmarking, and you get a nice tidy data frame with a list column for the metadata, but you'll see the task itself, its unique ID of that subtask, such as the bar chart, sentiment,

or the haiku poem creation, and then you'll get the, for each epoch or each iteration, the score. And that score will be different categories. We have, I believe, I for incorrect and C for correct. If you do the partial credit, it might have an additional level there too, but in the end you can take a look at that and see how things did. And you can even, you know, be really slick and do some visualizations or do some

interrogations of the metadata and these results if you want to present this, you know, a little bit of a different way Because that metadata might be useful if you want to do some specific analyses such as when she wanted to look at the bar charts themselves that the LLM created, she was able to extract that from the metadata column and to be able to, you know, do some visualizations or at least do some hands on inspections. All of that was set in the context of using the frontier models to maybe compare Opus with Gemini or copilot models and whatnot.

But you know what? There's an upper side to this, especially if you wanna save some money, and that's a local large language model side of it. And this is where things can really get interesting because the local models, you know, there are definitely some gains to be had, but I think they're getting a bit better. Sure. And when you're using local models, as Sharon points out here, you are gonna be limited to the power of your own computer that you're running this on. So she was leveraging models that fit onto her PC's 12 gigabytes of GPU RAM,

which, you know, are are somewhat limited. A lot of these different local models or open weights models, if you will, have multiple versions that are published. You know, some that are smaller than others and then some, you know, kinda that are medium size. And then, obviously, the ones that are gonna perform the best are the giant ones, that you would need some serious computing horsepower to run on. So one really interesting thing is the fact that, you know, Vital supports this Olama project, which if you've never heard about it, it's kind of this, you know, sort of one stop shop for leveraging local models,

that you can essentially pull down these local models in kind of a very docker ish way. There's two commands, ollama pull, ollama run, to pull down the model you want and then to to actually run that model for inference on your local machine. And something that I didn't know is that there is actually an r package that's a wrapper around oLama called the r oLama package or rollLama maybe, which is really cool to check out. It's a project that's been around for since I think the beginning of 2025, maybe a little bit longer. Just looking at some of the, issues that are out there, how long it's been worked on. It's really, really interesting project by Johannes Gruber and Maximilian Viber, it looks like. So one to check out if you're interested in using local models. And Sharon leveraged three for testing purposes.

Minestrel, three with, I think, 14,000,000,000 parameter model. And then she also leveraged Gemma from Google and Phi, I think which is a Microsoft offering out there. And all three of the local models that she leveraged did a great job at the sentiment analysis tasks that she put it put forth towards it. And they all did really poorly on the bar chart. It sounds like some code produced bar charts, but didn't do the axis flipping that she had looked for and, you know, the bar

descending order sorting. And some of the other code, just really didn't work at all. And she puts in a a couple nice, I think, GT tables throughout, this blog post that kind of showcase the performance and the accuracy rates that she got. And sort of the next thing that she tried to do after this, and in that previous task, she did use again Opus LLM as a judge, cost her 39¢. And obviously, running the local models cost you zero, which is the big benefit there,

besides the compute that you need to to have. Yep. So the next task that she did was to have, these local models try to extract, a few different data points from plain text, using this function from Vitals called generate structured, which requires a chat object and a defined data type that you want the LLM to return, which is nice. And I guess as of this blog post, you actually need the development version of Vitals in order to use this function just as a gotcha for anybody that hears this and and tries to go out and install vitals and is looking to do the same type of thing with that particular function. This creates a a nice data frame here,

with an ID column that has really two values. Either we're extracting a basic entities or or we're doing some sort of a more complex entity extraction. Then she has a column called input that contains two observations as well, essentially containing the text that she wants the LLM to pull information from. And then a couple final column here called target. And she provides, you know, some really nice examples about how to actually define that data structure output that you want, the LLM to return using Elmer's type underscore object function.

And, to her surprise actually, the local model Gemma scored a 100%. And she did a little bit more digging to try to see if that was a fluke, it essentially came to the conclusion that it actually failed on two out of the 20 tasks that she had provided it with thereafter, but those were the easier tasks. And I guess the takeaway here is, you know, try to be as specific as possible in your instructions to these models. And I I think maybe inherently

when we have more complicated tasks that we're giving these large language models, maybe we do a better job at providing specific instructions to manage all of the complexities of that task. So, you know, really interesting use case here from Sharon on both leveraging these frontier models and the open weights models. I think with some of the advances, you know, since December and Claude's, you know, OPUS 4.6 and all the updates with Codex on the the, the OpenAI side and obviously Gemini three and now 3.1

coming out. There hasn't been as much talk about the local models lately, at least in the the circles that I've seen. And excited to see somebody talking about them again because, again, I think they solve a lot of problems around security when you're trying to deploy these types, you know, these types of large language models and and deploy these types of solutions that leverage these models in, you know, secure, highly regulated environment, if you will. So, yeah, great write up by Sharon. It's good to see that she's not fully retired,

clearly, and we're grateful for it. We're here for it. Yeah. Exactly. Really great post here. And I'd venture to say, and this may be Eric going on a bit of a hot take segment of the show, with the advent of what has taken a lot of the tech world by fire here, so to speak, this OpenCLaw initiative, where now a lot of people are going to want to save a bit of money if they're going to deploy OpenCLaw on their infrastructure to help with various mundane tasks with their day to day life.

And if all LAMA models or some of the newer ones coming out can do the job locally, that's gonna drive the market, I think, a little bit. I'm not sure how much just yet, but I'm sure it's gonna get the attention of the big players here, And if it's gonna, you know, have a boom that can benefit the models as a whole, that can only help us on the data science side of things and may want to run local models for very well defined tasks. Like you said, I do catch myself if I'm trying to interrogate a very esoteric problem with my shiny app testing that I'm being very specific in my prompt to help Opus or whatever, whichever model to try and help me troubleshoot it. And spoiler alert, it kind of failed the last time I did it, but that's been story for another day.

But for these kinds of like text extraction tasks, maybe it's helping you, you know, consolidate certain texts into a more, you know, boldness summary, or maybe you need to digest maybe some other, you know, sources of information. I dare say the local models, think will end up being well for these smaller scope tasks and maybe you can put in a multi agent ish pipeline or maybe, you know, string these things together. We've seen efforts of that in the R community to try to bring these multiple workflows together and let you pick the right model for the job. And that's where I think vitals can help you a lot. Maybe you know you have a task, it's not sure which direction to go for that task, can use vitals

to benchmark that and then move on maybe to more complicated model for the other task, but you get the power to objectively measure this in this world where it seems like everything is changing every week in this landscape. There are certain things you can control and one of those is the approach that you take to benchmarking these things. It's, as always, it's great to see the POSIT team, you know, bring this tooling to us, but also Sharon really putting this through the paces for us to learn from her experiences. Absolutely.

Up next in our highlights today, we did talk about the nature of, you know, leveraging local models kind of in the spirit of keeping things both, you might say, cheap, but also I like to say in the open as well. They're open source for a reason. Guess what? When we build packages in the R community or even other popular languages like Python and others, you want the rest of the community to benefit from your package most likely. And with that,

there is a task that often gets overlooked, especially if you're new to the world of development, but it is a pretty big deal depending on how you go in this direction, and that is picking a license for your project. And there is a lot of choice in this as well. It can befuddle a lot of people that are new to this, But our next highlight here, we have a great roundup from the R developer perspective in data science, what you should be looking for and where you can find out more. So this blog post comes to us from Pete Nagaraj

over on the Paired Ends blog run by Stephen Turner and in this post he talks about you know what are you looking for in terms of if you see something out there for free or available may not always be what you seem, what it seems I should say. What do you typically look for? It's probably not the license, honestly. I'm probably looking if the package does what I want to do,

but when you work in an enterprise or you are building software that incorporates open source software, you do indeed need to pay attention to licenses. And even as a package author, you may not know it right away, but there is the high chance that maybe the thing you're building is going to be part of maybe a larger project adopted by both those just in the community and perhaps even those by enterprises. Of course, the R language itself is under our license and that is the GPL, the GNU public license

for R itself. But the mandate if you want to bring a package to be available on CRAN is that you must, of course, make the source code of your package available. Now with that said, that doesn't always mean that every package will have the same license because there's a lot of different licenses when you share your code out in the community. So the first part visual in this blog post looks at for all the packages deployed on CRAM,

is there kind of a pattern in terms of like what are the licenses that are the most frequent? This may not come as much of a surprise to some of you listeners, but it was interesting to me that by a wide margin that they are typically some form at 68% about a form of the GPL license and that maybe is because R itself is under GPL, but there are actually different variants of GPL which we could go down much of rabbit holes about which one is better or worse for different cases.

The next one up at 24% is the MIT license, which is often viewed as a little more permissible, and then you'll see at the tail some interesting ones such as the Apache, Creative Commons, and yes BSD. Shout out to all the BSD fans out there. I know you're out there, not sure how much in the data science side of it, but I know on my Linux podcast, I do listen to a few of them. And the other thing to pay attention about licenses is whether they permit

commercial use or you might call copy left, and not all of them do that. If you want, and for instance, a GPL license, if you're going to make a quote unquote commercial thing out of that, you must license your product as the same GPL most likely. Don't quote me all on that, but I'm pretty sure that's the case. Whereas other ones are not as prohibited for commercial use and being in the same license,

MIT is typically cited as that and you know in the end, we'll get to resources at the end here, it can be a somewhat difficult choice but there are ways to help you make that point. I mentioned the enterprise perspective. There are things that can happen with different vendors that can cause havoc when licenses change. So one of those is talked about in this post, A little bit of drama for the Anaconda project

and this bit a few people, you know, probably by surprise. And Anaconda, for those who aren't familiar, this is kind of a software repository for Python packages and there are some convenience involved with it. And there was a little bit of a stink that happened in this year as well as previous years, but there has been some updates

that basically say if you have an organization of 200 employees or more, you need to purchase a license to actually use Anaconda. It wasn't quite the same for everybody like it was in the past. This caused a lot of blowback in the community, such that in 2025 there was a bit of an update in July that said that certain nonprofit organizations and academic institutions may be exempt from that commercial requirement.

But by that point, that was five years after this initial change with that 200 limit, the damage may have been done. So a lot of times when these licenses change, especially when they go from a more permissive to a non permissive, this can cause a lot of havoc and we'll see what the future holds for Anaconda in this shift, but it did get a lot of attention from a lot of people back then. So this is illuminating in terms of what choice is out there,

but it may be getting to the point of you may be developing a package, you're like, which way do I go here? Definitely, you may want to look at things like if you are building upon other packages as your dependencies, you may want look at the licenses they have, see if there's any restrictions if you use one of those packages as a dependency and making sure you're not caught by surprise there. But there's also some great resources you can look at that are linked at the end here.

A nice primer is called the Dev's Guide to Open Source Licenses. GitHub also has a README project that they talk about licenses, that might be a good one. GitHub also has a mechanism for, I should say, a website that lets you walk through the different decision trees that you can do for choosing a license. If you want to get into the GNU GPL license, nuts and bolts, there's an FAQ

maintained by the FSF, the Free Software Foundation. And then last but not least, there is an interesting one called Pick a License, any license, and it honestly is a bit of a harsher take on what licenses can do for your choice, but it may be good to get a well rounded perspective on some of the pitfalls or some gotchas you might experience as you're navigating through this. Now as for me, yeah, I do pay some attention to it. I'll be honest

from recommendations I've heard in the community, I kind of default to MIT. It just seems to work. I haven't had any trouble with that, both for my personal projects as well as projects that started at my company and then we went through an open source disclosure process to bring those out to the broader community. MIT is one of the like six or seven licenses my organization approves for open source use. So I haven't had anything bad happen to me with using MIT,

but again it is an important choice especially if you expect your package to be part of either larger ecosystems, maybe it might be used for commercial use down the road. It's a great blog post to kind of get you grounded on what's happening out there in the world of R as well as some considerations that you might have in mind as you're beginning your journey of picking that license for your new package. Yeah, it's interesting. This seems like a hot topic. Know Josiah Perry had a blog post recently on almost the same exact

topic. I was also listening to Charlie Marsh who created UV and and rough on the Python side. He was on Posits podcast recently, and he was talking about the fact that UV ships Python itself. And I think when UV I think UV actually goes beyond versioning your Python packages and actually fully manages your project's version of Python as well, which is, you know, different from, our end on the R side. And I think this was kind of a big thing around positron.

Right? They licensed positron sort of different than our studio. And I think that that's because maybe in the past with our studio, there were third parties that were essentially reselling our studio right out of the box. So I can fully understand that. And it's it's a tricky thing, and I think something that folks should definitely take time to look at before they publish their package. I know I'm guilty of it. You know, you're working on an R package or Python package, and you finally finish it. You feel like it's in a great state, and you wanna share it with the rest of the world.

You know, just kind of quickly jumping to that MIT license or, you know, maybe the easy thing to do just to get it out the door. But it's can actually be an important part of your your entire offering, you know, depending on if that piece of software you're developing has, you know, ties to an organization that you you work for or who you want to use it, how you want it to be used, things like that. So I I guess make sure that you are, you know, paying enough time and attention to those types of things and not just sort of skipping over them. And and I think probably one of those best tools is is one that Nagaraj recommends. It's it's GitHub sort of interview style. You know, choose an open source license site that can probably help you navigate the all those different decision points and things that you may have in mind for how you want your package to be used. So awesome blog post. You know, I think it's a topic that doesn't get talked about enough.

And as we've seen, if it does get overlooked and you're not thinking through it, it can certainly create a whole lot of issues. Yep. And again, shout out to those in the enterprise trenches on this. This can also be very important if, like, you're in my situation with the recent shiny state package I released last year. Certainly that started with my actual day to day job and trying to enhance Shining Bookmarkable State. It wasn't like something I was doing on the side like I do this humble little podcast here, it actually had a significant

need for my day job. And with that, I got to a point where this was a proprietary thing, like what ended up being the package code, but just starting in my typical R scripts. And then eventually when I was saying to myself, you know what, this is something that I need to share with the community. That's where I've got support from my management, but then I have, we have a process at our company that looks at, okay, if you're going to disclose this, we go through kind of a check process. But then, as I said, there's a list of licenses that we have on our approved list. Yeah, I definitely

dotted my I's and crossed my T's on that before I release that out there. So if you're just doing something as your hobby project, typically you get a little more leeway in which license you use, but when you're in the enterprise, you want to open source something, you do have to pay attention to that and hopefully you have access to either a governance type of department or legal department that can point in the right direction. I do know some organizations, especially those in life sciences, just haven't been as equipped for this issue yet,

but that's changing now with our, you know, my biased view on how the farm versus taking off and are being more involved in life sciences, the open source nature of it has become a critical issue. But some industries, this is a new thing. So definitely look at those resources you have both out here that this blog post links to, as well as your internal resources depending on which organization you're at.

And we're gonna round out our highlights today by having, a journey to the world of version control, which I've always said many times on this show, you will regret it if you do not use it. And boy, oh, boy, was I glad I used it literally in the last few hours when Claude Opus wreaked havoc on a testing script, and I had to, nope, go back to square one. Anyway, that's not the point of this post here. Been there. You've been there. Yeah. I'm sure multiple times, no less, and don't get me started earlier in the year.

But Git can save your behind on many of these situations, but there is kind of both, you might say, a science and an art to effective use of Git, especially when you get to the fundamentals of your actual commits themselves. And this, this interesting post that has a great title, git commits, please mark your stitches, and this has been authored by former R Wiki curator, Miles Salmon, who has not been shy about her experiences in learning both the nuts and bolts of Git as well as

practical advice on certain issues you might encounter with Git. And in this post, she opens with that she is learning not just technical things on the software development side, she's learning how to crochet, which big respect for that. I'm afraid I poke my fingers out trying to work with the needles that are shown in this picture here, But she has some great insights into her early days of learning crochet, such as actually marking

in these strings that you're putting together literally different markers based on how often you have to kind of fold the loops around and there are different patterns that you have to adhere to in terms of like the number of stitches in between consecutive loops or whatever and again I'm doing this horrible justice here, but I'm sure if you've been down this road, you know what we're talking about. Now, what does this have to do with GIT? Great question, but this is where I definitely

can relate to what she says here in the rest of this post. These commits that you make, if you treat them the right way, can very much function as these markers in time to your code base. I often think of it as like a developer diary of sorts that you get a tagline of what that code update was in that commit, and then if you read that in the future, say a year from now or even a couple weeks from now,

you will be able to tell at that quick glance what that particular commit was all about. And this can be really handy if kind of the worst case scenario happens, you've done your commits, you find out sometime in the future there's been a regression, and you've got to figure out where that regression actually happened. And if you have a lot of commits that could be quite painful if you didn't write these commits in a clear and concise way,

and there are many approaches to this, but in, as we mentioned before on the show, my allies created this handy r package, and I keep every time I say the name, I feel like I'm walking on ice here, superpulpit, something to that effect, I tried, and this has exercises inside to let you practice working with GIT when things aren't going as expected. And this is a case where having these thoughtful commit messages come to play

because there could be some exercises related to when you are trying to traverse the history or the log of your commit messages. When did I delete a certain file? Where did I delete that certain line? Did I, you know, when did I add a specific line or file? I need to see what this app or project looked like at a certain version or time and which commit

introduced this bug that I'm wrestling with. Each of those look at different git operations under the hood. The last one in particular is where you go into something called git bisect. And when you're in that mode, you're suddenly looking at your logger commit messages to try and figure out at what point do you wanna traverse back in time and inspect what your code base looks like. Well, what she shows in this post here and one of the pictures at the end here is that you can lead off your commit

with what is called kind of a one word keyword at the beginning. It kind of tells about the type of commit. This is mentioned in this paradigm called conventional commits, which I've now fully adopted ever since about a year ago. I use this all the time in my commits and it is awesome. It just takes a lot of discipline to remember to do it, but this is where you lead off that commit with a keyword such as fix, docs for documentation, or feature

or feat when you wanna build something new. There could be other ones like CI if it's related to continuous integration, could be testing, you know, or one called chore, but it's kind of like this mundane thing you just have to do just like your household chores. Just like my kids whine every day about doing their household chores. We often have to do that with commits too, what am I to say? So having that along with an informative commit message will make finding that point in time when you need to find just where that bug was introduced,

hopefully a lot easier. So as I said, her package, Sapirapopovit, has been updated with some exercises to look at these various tasks. I invite you to check it out if you want a way to learn from the friendly confines of R in a non production project, because the learnings you have through this and being intentional, I should say, on your commit messages, there is nothing bad that will happen here. It's going to take some discipline,

but future you will thank you later the more you adhere to a lot of these principles. That's Eric's take anyway. Mike, am I completely off base or do you like what Mel's cooking up here? No, I love what Mel's always cooking up in these types of blog posts and yeah, get in can be a tricky one at first. As I think I've said many, many times on this blog post before that, it can be a tricky language to teach, tricky language to learn. And, but it does provide this this peace of mind at the end of the day that is absolutely invaluable.

And it's when I go to hire, git is the most important skill that I hire for. Before R, before Python, SQL, Git is imperative. We couldn't do our day to day work and collaborate and make sure that, you know, we don't lose our work and carefully and safely introduce, you know, new features and things like that without Git. Thank you to git itself, and thank you to Mel for making this really cool analogy between crocheting and git itself and ensuring that

these stitch markers when you crochet prevent you from losing your place and help you count complex patterns. And that certainly sounds a whole lot like git commits that act as markers along your strand of work, if you will. A lot of psychological benefits. You know, it can feel like doing these commits early and often can be kind of annoying. But, when you have to go back, it is an absolute lifesaver. And I'll be the first to admit that I don't take advantage

of all of the kind of pretty cool different git commands that are out there. I am git status, git pull, git push, git switch branch, and and not a whole lot more unless I need to debug something and, you know, something has gone horribly wrong that we need to fix, then then I can dive into the the trickier things. But there are shockingly, you know, git doesn't strike me as a language that, has a lot of really awesome bells and whistles, but it kinda does. You know, some of these these functions here like git show,

git log, git blamed, and bisect, as we've come to find out, are really powerful and really useful tools. And I really appreciate the fact that Mel highlights some of these, you know, underused, underserved, functions from Git itself. So really love this blog post. Mel also mentions that she's hosting a workshop later in March, titled Oops, Git, How to Recover from Common Mistakes, where I'm sure you can learn even more about this stuff. Oh, that's awesome. Yeah. I'll definitely be looking out for that. It looks like that's part of the, yeah, workshops for Ukraine series. There's been a lot of great content that's been shared in that space coming up looks like March 19. So I will put a link to that in the episode show notes if any of you are interested

in learning from a very, very authoritative source on this on these concepts. I do say that along with, you know, practicing at the command line level with Git, I'm not gonna lie, this is one of those cases where having an intuitive GUI with it is extremely helpful. There are many different ones out there. I admit there is one I use a lot in day to day called GitKraken, that's cross platform. It does a great job of visualizing

both the history of my commits, as well as when my staging area, what's been changed, what's not been changed. Often what happens to me is that I'll write a commit, I'll put it in, then I realize, oopsies, I forgot to include that one additional change. That's where there's a git commit dac tac tac amend command that'll let you update either the title and or what you include in that commit. And that's where a framework like GitKraken and some other ones out there will let you like point and click, hey, is this an amend or is this a fresh one?

That one has saved my behind more than once because there are times I, when I do an extensive like doc write, rewrite, and I'm putting all these rOxygen tags, and then I refresh the man pages of those, and I realize, oh, rats, I forgot to include that one. Then I can do that. So don't be shy about finding whatever tool in Git helps you on that journey. Nobody's judging on that. As you said, Mike, when I shared the same, when I work with colleagues on projects,

it's more about the fundamentals of effective use of Git. If you have a good handle on that, no matter which language you're working with, you're going to be in good position and use all the tools for the job that you see fit. So I'm plus 1,000 on that one. And you can plus a thousand a lot of things in R weekly itself. There's the full gamut of new packages that are coming out in the R community as well as great uses of R in organizations and areas, and there's even a great

selection of this. Definitely my, peers in life sciences will be paying attention to a lot along with much more. And one thing I didn't have time to read this yet, but it definitely got my attention just as, a famous wrestler I used to follow, Roddy Piper, would say, every time you have the answers, I change the questions. Well, there's yet another part of large language models that I did not know about or AI in general that, James Wade is is, looking into. He's been in the forefront of a lot of this research in our LLMs

and that is the use of recursive language models. I'm gonna have to wrap my head around that one and see what's going on there as I may. That's just one example of what you can find in the rest of the R Weekly Issue. So never a never a dull moment in this space. But this project, we're not AI driven. It's all human curated, and we need your help. If you see that great blog post or highlight that should be included in the issue, we are a poll request away at rweekly.org. Just hit that little octo code in the upper right corner and it'll be taken to GitHub directly to

edit the draft of this week's or the upcoming week's issue. We have some great, you know, template guidelines when you fill out that PR. It's very easy, very straightforward, but we live off of your contribution. So don't be shy with that side of it. And don't be shy about getting in contact with us. You can find us through the episode contact page or the show contact page in the episode show notes right here in your podcast player of choice. You can also get in touch with us on these social medias. I am at our podcast at bsky.social

on blue sky. I'm rpodcastsat, rpodcast wow I can't talk. I am rpodcastsatpodcastindex.social, Mastodon and if you want me on linkedin just search my name and you'll find me there and mike where can the listeners find you? You can find me on blue sky mike thomas. Bsky.social or on linkedin if you search catch brook analytics k e t c h b r o o k you can see what I'm up to.

Great stuff and, yep we're hopefully going to be up to more, crazy adventures in our side of things, and we shall keep you updated as always of our weekly itself. So thank you again for tuning in to this week's episode and we'll be back with another edition of our weekly highlights at least soon. Bye everybody.

Open the transcript file

Hosts and Guests

Hosts

  • Eric Nantz Host Feed-stated
  • Mike Thomas Host Feed-stated

Credit the people on this episode

Be the first to rate this episode

More episodes

All episodes
  1. Issue 2026-W47 Highlights

    Nov 20, 202648 minAudio

    Our takes on the increasing removal of friction in good and not-so-good ways thanks to AI, a visual tour of hot air balloon accident data, and a case study of novel image recognition with the rplatipus package. Episode...

    Credit the people on this episode

  2. Issue 2026-W46 Highlights

    Nov 13, 202633 minAudio

    The flow of both data and analytical jobs just got smoother with mizu, opening the door for multiple agent harnesses in Positron, and an optimal statistical model tailored to complex experimental designs with a friendly...

    Credit the people on this episode

  3. Issue 2026-W45 Highlights

    Nov 6, 202644 minAudio

    What happens when that online data set isn't so easy to download anymore? We learn of two packages to ease the pain of obtaining these files and then some. Plus a visit to the visualization corner with a handy way to...

    Credit the people on this episode

  4. Issue 2026-W44 Highlights

    Oct 30, 202631 minAudio

    The celebration of rOpenSci's 15-year anniversary continues with the community sharing their perspectives, and a fun Shiny app that could be quite useful during celebrations on a weekend or the holidays. If you ever...

    Credit the people on this episode

  5. Issue 2026-W43 Highlights

    Oct 23, 202659 minAudio

    We learn about the variety of ways you can contribute back to the core of R, a roundup of the excellent choices available for package and environment reproducibility, and an amazing collection of Shiny applications and...

    Credit the people on this episode