Untitled Linux Show 271 Transcript

Please be advised that this transcript is AI-generated and may not be word-for-word. Time codes refer to the approximate times in the ad-free version of the show.

Jonathan Bennett [00:00:00]:
This week we have some hardware reviews, one we've got in hand and the other one we're still dreaming about. And then Linux kernel 7.4 really is cooking and looks to be a really great Christmas present for us all. Then there's more Ubuntu Core Utils news. Intel is ending their bug bounty program and we get to talk about Mint and a whole lot more. You don't want to miss it. So stay tuned.

Rob Campbell [00:00:27]:
Podcasts you love. From people you trust. This is Gnu News. This is Twtit.

Jonathan Bennett [00:00:35]:
This is The Untitled Linux Show, episode 271, recorded Saturday, September the 19th. Touched by AI. Hey folks, it is Saturday and it is time to geek out about Linux. It is The Untitled Linux Show and today we are, we are here. Well, it's not just me. I'm here, but there are 3 of us here. We got Rob, we got Jeff, and we're gonna have some fun today. Welcome to the show, guys.

Jeff Massie [00:01:01]:
Oh, love being here. It's Linuxtastic.

Jonathan Bennett [00:01:04]:
Linuxtastic. Oh my goodness.

Rob Campbell [00:01:07]:
I'm not going to put that down as a show title.

Jonathan Bennett [00:01:10]:
Yeah, I was going to say, somebody keep him away from the show title controls.

Jeff Massie [00:01:14]:
And you need to be part of the— just saying, you need to be part of the club because some of the best show titles that we could have don't happen on the recorded part of the show.

Jonathan Bennett [00:01:24]:
That's true. Multiple times while we were just chatting before we started the stream, the guys threw out zingers. And I'm like, what are you doing to me? That would be perfect.

Rob Campbell [00:01:31]:
Some of the best conversation that you get to hear.

Jonathan Bennett [00:01:35]:
Yep, absolutely.

Rob Campbell [00:01:36]:
Of course, I don't think you started the stream yet then either, so no one else did either.

Jonathan Bennett [00:01:39]:
Nobody else heard it. It's our little secret. What happens backstage stays backstage. Anyway, we've got some Linux-y stuff to talk about, and I am going to kick it off with a bit of show and tell. And normally we call this segment Random Crap Rob Talked Me Into Buying, but this time I don't think it was Rob's fault. I picked up a Framework 13 Pro, and I've got a special little module. I think we've talked about what this is, but I figured I would take a minute and talk about this guy. It's got some interesting features to it.

Jonathan Bennett [00:02:13]:
So the 13 Pro, it's the refresh of the 13 series. The Pro part refers to a few features that it's got that none of the other ones do. One of the ones I really like is that the actual bottom case is aluminum as opposed to the plastic that the previous versions have been. Pretty much the same keyboard and mouse setup. The 13 Pro, I discovered, does have the fingerprint reader. The power button is a fingerprint reader, which I actually really like that. I didn't think I would, but I've gotten to play with it and I really quite like the fingerprint reader there. The screen is a touchscreen, which I'm not terribly crazy about, but I suppose it's, you know, it can be nice to have from time to time.

Jonathan Bennett [00:02:52]:
It's got the 4 USB-C Framework ports. And so I've got USB-C and HDMI on one side, and USB-C and then the Meshtastic radio on the other side. Particularly going to be showing that off at the Things Conference, which I'm headed to next week. And then looking at this, it does have a couple of other interesting things that I've not seen before on Framework modules. I don't think my other 13 has this. It's got a headphone port. So right, turn to the camera. Not that you're gonna be able to see the tiny little port, but right here, just in front of the 2 modules, the slot for the 2 modules, we do have a headphone port.

Rob Campbell [00:03:31]:
That's serious courage.

Jonathan Bennett [00:03:33]:
It's serious courage to bring back the headphone port. Yes. I actually really missed that on my 16. I wish it had the headphone port. Because right now, my headphones plug into the monitor, and then I have to kick sound out over HDMI. And that actually can be a pain sometimes. But anyway, it's a nice little machine. I've got this one set up with a 16-core AMD AI 300 series CPU.

Jonathan Bennett [00:03:56]:
I think I threw 32 gigs of RAM into it, which was expensive. Didn't quite have to take out a second mortgage on the house for all that RAM, but we had to have a talk about it. Like, just so we know, the budget's gonna look a little weird because I'm gonna have to pay for the new Framework laptop this month. I'm not kidding. We literally had that talk.

Rob Campbell [00:04:14]:
But it's a nice little machine.

Jeff Massie [00:04:15]:
I like it.

Jonathan Bennett [00:04:15]:
I like it a lot. And one of the things I really like about it is that it will travel so much better than the 16-inch. I can fly with it and I don't feel like I'm pulling a desktop replacement, which is really what the 16 is. I can pull it out and it's not a full desktop replacement. Hopefully it won't blow the breakers on the airlines because that's the other thing that the Framework 16 does. It's got such a massive power supply on it that it literally pops the breakers on the plane. Uh, not, not the, not the greatest experience there. Um, but yeah, I, I've been, I've been In the couple of days that I've had it, I've really been digging the 13 Pro.

Jonathan Bennett [00:04:52]:
It's a nice Linux laptop. And of course, the other nice thing about Frameworks, they've got pretty much official support for like Debian and Fedora and the major distros like that. And with some instructions for how to make things work if anything doesn't work just out of the box. So really, it's been a good experience.

Rob Campbell [00:05:06]:
I got a tip for you that might help with one of the things you weren't so happy about.

Jeff Massie [00:05:11]:
Yeah.

Rob Campbell [00:05:12]:
You can turn off the touchscreen and then it's just a regular screen.

Jonathan Bennett [00:05:16]:
Indeed. Yeah, if my kids ever get ahold of it and start using it, I'll probably turn it off because I don't like them touching the screen. But I don't, like, I know not to touch it if I don't want to use it. Like, I have finger discipline. I can just not touch the screen and it's fine.

Jeff Massie [00:05:34]:
Well, I was going to say, how else are you going to smudge up the screen properly if you're not?

Jonathan Bennett [00:05:39]:
Right.

Rob Campbell [00:05:40]:
Mine's not a touchscreen and somehow I smudge it up. I don't ever remember touching the screen though.

Jonathan Bennett [00:05:45]:
That's because you sneeze and you cough on it, Rob.

Rob Campbell [00:05:47]:
I don't know. I think I smudge up the keys and when I close it, it just somehow transfers over.

Jonathan Bennett [00:05:52]:
That's actually very possible. That might be exactly—

Rob Campbell [00:05:54]:
That's my only serious, uh, idea that I have.

Jonathan Bennett [00:05:59]:
Yeah, yeah. Look, somebody wrote me a note on the screen. What does it say? Q-W-E-R-T-Y.

Jeff Massie [00:06:08]:
Oh, I was thinking usually when you have the touchscreens You know, you power it off or something and you see the reflection on the screen and you go, wow, I touch a lot there, there, and there.

Jonathan Bennett [00:06:18]:
Yeah, yeah, that's the thing. It's kind of like the other version of screen burn-in. It's screen touch-in, right?

Rob Campbell [00:06:26]:
Here's your pen. Let's see.

Jonathan Bennett [00:06:28]:
Yeah, yeah, exactly. All right. In other hardware news, Rob, did you buy a Steam Frame?

Rob Campbell [00:06:36]:
No, not yet.

Jonathan Bennett [00:06:38]:
Are you going to buy a Steam Frame?

Rob Campbell [00:06:39]:
I'm really thinking about it. Um, but I haven't yet.

Jonathan Bennett [00:06:45]:
All right, give us the scoop.

Rob Campbell [00:06:46]:
So Valve has officially released the Steam Frame now.

Jonathan Bennett [00:06:51]:
It's—

Rob Campbell [00:06:52]:
and for those who haven't been paying attention, well, I don't even know why you're here, but for those who haven't paid attention, it's a new standalone VR headset. Uh, and the, and the first reaction from a lot of people might be the price tag. The 256 gigabit model starts at $1,059 for those trying to get that currency right. While the 1 terabyte version costs $1,299. That's a lot of money for a VR headset, especially when you could buy something like the Meta Quest for considerably less. But I think the comparison becomes more complicated once you look at everything required to play the best PC VR games. So I myself purchased a Meta Quest some time ago. I don't know, 4 or 5 years ago, maybe longer.

Rob Campbell [00:07:51]:
I don't remember which one, which one I got. I don't know which one I have, but I bought it some time ago. And one of the games I really wanted to play was Half-Life: Alyx. The Quest itself, the Meta Quest, that is itself, could operate as a standalone headset and play a lot of games, but it couldn't run Half-Life: Alyx on its own. To play it, I needed to connect the headset to a gaming PC, which is one of the big things that actually led me to upgrade my last PC because what I had was not suitable to run it. So Yeah, it wasn't powerful enough, so I had to upgrade that also. So by the time I purchased the Quest and built the computer capable of running Half-Life: Alyx properly, I probably spent pretty close to $2,000 fairly easily. So suddenly the headset wasn't really, you know, $400 or $500 purchase anymore.

Rob Campbell [00:08:54]:
It was, you know, Part of a much more expensive VR gaming system. And that's what makes the Steam Frame interesting. Valve has ported Half-Life: Alyx to run directly on the Steam Frame's ARM-based hardware. The game is included with the headset. Another major plus because you get this. It is a great game. I love it. Probably my favorite.

Rob Campbell [00:09:19]:
And it can be played completely standalone without purchasing a gaming computer. Without streaming the game from another machine or anything. So my Quest to play it, I have to tether. So I have to have a fairly long cable to my headset and the PC, and it gets kind of tangled on things and it just gets in the way. This would be pretty awesome playing standalone because the, the Quest, you could play it tether-free. The standalone version does not make some— does make some graphical compromises compared with running Alyx on a powerful gaming PC. But it's reportedly the complete game, including support for community-created mods and levels. You can put the headset— put on the headset and play one of the best VR games ever made without a cable.

Rob Campbell [00:10:18]:
A separate computer or any other $1,000 supporting hardware. The Steam Frames can also wirelessly stream more demanding games from a PC if you really— if you already have one. So if the quality is not good enough, I could probably still stream that from my computer. And Valve says more than 100 games are currently Steam Frame standalone verified. So yes, $1,059 sounds expensive, but— Well, it is a little expensive. That might be some another talk Jonathan's gonna have to have with his wife. But, um, I'm not sure it's a fair comparison to this, you know, this— the Meta to Steam Frame, uh, with the purchase price alone. So for someone who doesn't already own a capable gaming PC, a better comparison maybe is Steam Frames against the total cost.

Rob Campbell [00:11:11]:
And when I compare it, the nearly $2,000 I spent achieved essentially the same goal. So I haven't ordered it yet. I already have a Meta Quest and a computer that I'll work with, but I'd really love to play that tether-free because I know one of the things I do really like to do with my Quest is just go in my backyard and map out a huge area because, uh, the actual motion running when I play VR, uh, works with me a lot better than, um, movement in VR when I'm really not moving. Sometimes I get a little nauseous with that. So playing great games like this, uh, tether-free sounds awesome. So I still It's time for an upgrade anyway. Like I said, I haven't— I think my Steam, my Meta Quest is a good 5 years old. So maybe it's time to upgrade.

Rob Campbell [00:12:12]:
And Jonathan's wife, I think it's time Jonathan gets into a little VR gaming.

Jonathan Bennett [00:12:21]:
Maybe. I've actually looked at it and trying to figure out something I'm involved in. They've got a VR thing that they're doing. And so if I get it, it's probably not going to come out of my pocket. It's probably going to go on a contract, which, you know, if you can get the work, it's nice. Uh, but, uh, yeah, yeah, we'll see. It's— it looks cool. I, I love the idea of, you know, going to your backyard or renting out a warehouse or whatever and, uh, actually being able to run around playing a VR game.

Jonathan Bennett [00:12:52]:
I think that is indeed pretty cool.

Rob Campbell [00:12:54]:
Yeah, I know my Meta Quest. I, I feel like I mentioned this before. I wonder if my neighbors ever have seen me Just in the backyard running around with this thing on my head and ducking down. And, but, uh, one thing with mine, like, I know it's not the newest model, it's at least one or two generations behind. One thing that has a problem with is sun. When the sunlight is very bright, it messes up its orientation. But otherwise it's all right. It works well.

Jeff Massie [00:13:21]:
Yeah.

Rob Campbell [00:13:22]:
Yeah.

Jeff Massie [00:13:22]:
Sounds like you need one of those circular treadmills.

Jonathan Bennett [00:13:27]:
Maybe. Yeah, that'd be worth trying too.

Jeff Massie [00:13:29]:
Oh, and I would like to point out in the Discord, Jonathan's wife was like, hahaha, no.

Jonathan Bennett [00:13:38]:
Indeed. Yes, like I said, not coming out of my pocket, not anytime soon. Uh, all right, uh, let's see, we've got, uh, we've got more stuff. We're gonna dive into some actual kernel stuff here in just a minute. We're gonna take a quick break though. Gotta pay the bills. And we'll be right back to talk about some interesting things coming in kernel 7.4. Don't go anywhere.

Rob Campbell [00:14:00]:
We'll be right back.

Jeff Massie [00:14:02]:
Well, if you've ever compiled your own kernel, as some of our members in the Discord do, you know, like Keys512, I'm looking at you, you know the pain. And, you know, you make one small change and then you wait or, you know, adjusting settings, whatever it is, you know, and you recompile.

Rob Campbell [00:14:20]:
Okay.

Jeff Massie [00:14:21]:
This week, that wait got a lot shorter. And weirdly, AI gets some of the credit. Now, the work comes from Lorendo Stokes, a kernel engineer at ARM. And he's been running a patch series aimed at the 7.4 kernel, or hoping it will land there. I mean, it's looking like it probably will, but, you know, nothing's for sure yet. The patches tackle a bunch of single-threaded bottlenecks, buried in the kernel's build system, things like kbuild, kall, sims, modpost, objtool makes this map, and even the Rust build tooling. This is the 3rd revision of this series posted just this week, and it's 20 patches deep, and the results are genuinely pretty big on an all-mod config build. That means basically every module gets compiled, Builds are about 30, 36% faster.

Jeff Massie [00:15:21]:
Incremental builds, which updates only the parts of the kernel that have changed since the last build, you know, rather than recompiling the entire source tree from scratch, are around 70% faster. No-op builds where nothing even changed, you know, you'd see that more like an automated type place, jumped up by close to 90%. Stokes tested this on both Apple M2 hardware and AMD systems with consistent gains across both. On the M2 specifically, full builds sped up about 10% with Clang. Incremental builds were up 45 to 55% or faster depending on compiler, and no-op builds landed in that 74 to 76% range. Now, here's the part that makes this painful for some. Stokes didn't find these bottlenecks by hand. He used an LLM to help him hunt them down.

Jeff Massie [00:16:14]:
And in his own write-up on the kernel mailing list, he was refreshingly blunt about how that went. Quote, it generated a lot of code. Much of it was hideous, end quote. So the AI was good at spotting where the kernel's build process was wasting time, but the actual code wrote to fix the problems needed some serious human cleanup. Stokes said he personally audited everything, rewrote large chunks of the generated code, and rewrote the commit messages, cover letters, and code comments by hand before any of it went near the mailing list. So he didn't unleash this and go back and redo it. He polished first, then sent. Every commit in the series carries an assigned assisted by tag.

Jeff Massie [00:16:57]:
So, you know, the AI's role is documented. So, you know, if anybody's— Unsure, he made sure to document, yeah, he had help from AI, but nothing shipped without a human actually verifying it first, which, you know, this goes back to what Linus Torvalds said himself and has recently talked about, you know, how these tools are actually, you know, helping in kernel development. The, you know, and the pattern, the maintainers are seeing that LLMs have gotten legitimately good at spotting bugs. And the efficiencies that humans might scroll right past, but they're not something you can trust to write production-ready code on their own, which is, you know, good at— good at— it was put as good at threading the needle, bad— or good at finding the needle, bad at threading it. So kind of like Linus said, you got to look it over, you got to check. You're ultimately responsible for whatever the AI puts out, and you should be able to defend it and articulate what it's doing and make sure it didn't do anything dumb. Now, as for where this stands right now, 2 of the original patches are already merged. The second revision went out around September 14th, and this third revision, the one with the, the full 20-patch set, went out just a few days ago on September 17th, rebased against the latest upstream.

Jeff Massie [00:18:20]:
Reception so far is described as largely Uncontroversial, which, you know, kernel development, that's basically a green light. You know, nobody's complaining. Hey, things must be pretty decent at least. If it lands as expected and it's accepted, this could be part of the Linux 7.4 kernel. Now, just to be totally clear, this isn't the kernel itself running faster on your machine. This is the kernel taking less time to compile. When developers and enthusiasts build it themselves. So if you're someone who regularly builds your own kernel, whether for testing, custom tweaking, or just because you like to live dangerously, this is a speedup no matter how you compile it.

Jeff Massie [00:19:04]:
And it's going to be something you're going to feel. This is the percentages like you will notice a difference even seat of your pants. Take a look at the articles linked in the show notes, which also contain more links to more information on this patch series and how it's come come about over the last several months and happy compiling.

Jonathan Bennett [00:19:26]:
Yeah, you know, I, years and years ago, I found a compilation quirk like this in the OpenWRT build system a long time ago. And in this case, it was the difference between compiling something with a single compilation thread and doing a make with a number of cores on it, like you know, 2 or 4 or whatever. And it would fail every time you tried to do the initial build with more than 1 core. And I forget how old I was at the time. I was pretty young, maybe in early 20s or so. And that annoyed me. And so I sat down and I figured out what was going on. And it turns out that because it's cross-compiling, you end up building GCC multiple times, which is pretty typical for a cross-compile.

Jonathan Bennett [00:20:12]:
When you put it in parallel mode, it tried to build GCC multiple times at the same time, and the downloads were clobbering each other. And so the solution was to say, you know, even when you're doing these parallel compiles, GCC has to be serialized, do one at a time. But man, I spent several hours tracking that down, figuring out exactly what was going on. And I look back on that sort of thing now, and I'm like, if I had Claude or even Gemini or some of the others, hey, this is doing this thing, fix it. You could just walk away and come back 30 minutes later. Oh, that's probably what it is. All right, make the pull request, right? Like, it would be that easy. Um, the downside is I wouldn't have the cool story to tell that I fixed something in the OpenWRT build system though.

Jonathan Bennett [00:20:53]:
Um, but, uh, yeah, you know, it's, it's, I don't know, it's just the way tooling, tooling, uh, tooling develops and it changes things.

Jeff Massie [00:21:01]:
I guess that's—

Jonathan Bennett [00:21:02]:
I, I also similarly don't have any cool stories about writing code in assembly because I'm not old enough to be an assembly writer. I do everything thing in compiled languages.

Rob Campbell [00:21:13]:
So what I hear you saying, Jeff, is, I mean, for those out there, just a PSA, if you are not a fan of AI, do not upgrade to 7.4.

Jeff Massie [00:21:25]:
I guess if you're morally against using anything that ever touched, you know, but well, you'd have to go back several kernel revs to not have anything touched by AI, but some people get tired of hearing about it. But this shows a very good balance between, hey, it helped find a problem, but it's not the solution writer, or it wasn't a very good one. So it's like, I think it has a very lesson learned for would-be coders or people that want to do it is like, sometimes it writes crap and you need to be able to look at the code and decide what's important and what needs redone. Yep.

Jonathan Bennett [00:22:01]:
I bet there is somebody out there that has a fork of the Linux kernel from before they started using AI tooling. For purity reasons.

Rob Campbell [00:22:08]:
I'm going to look at that and have that be my tip next week. I'm going to go all in on the other direction now.

Jonathan Bennett [00:22:16]:
It's a weird place, man. I will tell you, you will find it. It's a weird place.

Jeff Massie [00:22:21]:
So when you load that 2.4 kernel, make sure you—

Rob Campbell [00:22:24]:
Yeah.

Jonathan Bennett [00:22:25]:
That actually reminds me just a touch of errata. I think this was last week. We talked about a developer that had a disagreement with a project's AI policy and left and orphaned a bunch of packages when he did so. And we sort of had the assumption that, oh, well, he must be one of the anti-AI guys. No, no, it was actually the other way around. I went and we looked this up and I forget the guy's name or even what the— it's a Linux distro.

Jeff Massie [00:22:56]:
Void Linux.

Jonathan Bennett [00:22:57]:
Yeah, Void Linux. Void Linux has a little bit of an anti-AI policy. It's not as strict as some of them are, but, and it was a, I think it was the text for a pull request or maybe a review on a pull request that he let the AI bot run and do the review. And he got called out for it. And they're like, we have this policy that you don't use AI-written text in any of these pull requests or pull request reviews. And at that point he went, well, that, that just totally breaks my workflow and I'm out. So it was, it was kind of the opposite of what I expected it to be. This was, this was an AI enthusiast taking his toys and going home.

Jonathan Bennett [00:23:36]:
But, uh, you know, it's very, very—

Jeff Massie [00:23:39]:
He dropped like 20 packages or something, right?

Jonathan Bennett [00:23:43]:
It was like 100 packages.

Jeff Massie [00:23:44]:
Oh, 100?

Jonathan Bennett [00:23:44]:
Yeah.

Jeff Massie [00:23:45]:
I know there was a big chunk that somebody's having to pick up then.

Rob Campbell [00:23:50]:
You know, that almost like— I didn't read the full story. I knew that it was the AI Pro guy that, that left, but, uh, So it wasn't the actual code so much, it was the text of the pull request?

Jonathan Bennett [00:24:05]:
Yeah, it was the— he used the AI to write, I think the specific disagreement was a review on a pull request, but apparently he had plans or had used it to write his own PR comments. And so he was just like, no, I'm not interested in that.

Rob Campbell [00:24:24]:
The menial task like comments seems like a good place for it.

Jonathan Bennett [00:24:29]:
It can be. So one of the— I've had a conversation that was actually at DEF CON with a project manager for one of our projects. And he was describing his workflow when people come in with AI pull requests. And he's like, yeah, they have the pull requests and then we use a tool called CodeRabbit to do all of the review, the initial reviews on them, right? And it'll write up comments about things that it finds. It's like we let our clanker talk to their clanker. And once they both get happy, then we put human eyeballs on it and do a real review with humans. You do get sometimes some weird stuff and particularly like over-verbose text out of the AI.

Rob Campbell [00:25:10]:
Just ask it to be concise. Yeah.

Jonathan Bennett [00:25:12]:
Yeah, sometimes that works. Sometimes you get weird results too.

Rob Campbell [00:25:16]:
I've often done that. Like it gives me too much word. I'm like, be concise.

Jonathan Bennett [00:25:21]:
Yeah, I've, I, I have found that you usually have to do 2 or 3 rounds of that. Like, okay, you did better here, but you still have 300 words to describe this where you could describe it in 5. Go back and make it better.

Rob Campbell [00:25:34]:
I feel like though, like, I, a lot of, a lot of my development, especially my older stuff, there was, you know, I didn't comment as well as I should. I just wrote code and it's like, I can go back, I know what it does, I could see it. But it almost seems like it could be a good use, just like, hey, Claude, comment up this code, you know, be concise.

Jeff Massie [00:25:59]:
What I do is I tell it, be very direct, you know, right to the point, don't embellish. And because I work international, I always say, keep the language simple and direct so it's easily translatable into another language. And it does pretty good about keeping Because you have multiple things saying, hey, get to the point and don't get flowery.

Jonathan Bennett [00:26:26]:
Yeah, I've seen different approaches to this. The one that humors me the most is something called Ponytail. It's ponytail.dev. And it's, you know, it's describing like you're the senior dev kind of guy. He says nothing. He writes one line. It works. And it's a rule set for basically getting your AI to act like that stereotypical ponytail-wearing super nerd.

Jonathan Bennett [00:26:54]:
It humors me so much. All right, we got some more—

Jeff Massie [00:26:57]:
Ponytail, neckbeard, and a sweater vest. Whoa, watch out. Code's getting written today.

Jonathan Bennett [00:27:03]:
Code is getting written. All right, we got some more 7.4 news that I found in my roundup. And there's continuing work with AMD. And the HDMI FRL update, that is essentially HDMI 2.1 landing in the upstream kernel again, hopefully in 7.4. And we've got Alex Deutscher, one of the AMD GPU maintainers, sending out a big batch of updates. And there were some of these in it. Not a whole lot of detail to go into there. But just a note that it is continuing to come and some really neat things landing there.

Jonathan Bennett [00:27:47]:
That wasn't enough for a whole story. So I went looking for more. And something else happening in 7.4 is binder.c is going away to be replaced with a Rust binder. And so this is something that's been sort of around for a while. It's some Android code. And Google has been for many years now working on trying to upstream some of their Android stuff into the Linux kernels that they have fewer patches to maintain on top of the kernel for Android to work. And Binder was their inter-process communication layer. Essentially, it's what allows one process to talk to another process.

Jonathan Bennett [00:28:27]:
It's how intents get launched and all of those things. And they wrote it in C and it was kind of a disaster. It's been just a problem to maintain. I think there's been some security problems. Well, They are now replacing it with Rust binder in Rust, and they said that they finally now have not only achieved full feature parity, but it also matches and can often beat the performance of the C binder. And apparently it's run successfully on Android devices for quite some time now, and so they are yanking the C code. and pushing the Rust code. GKH, Greg Coyle Hartman, picked it up and it looks like it's going to land in the 7.4 merge window.

Jonathan Bennett [00:29:19]:
So another bit of fun work there. And then something else that I saw just before the show started, also in 7.4, is that files are getting read a lot faster. This is the do_open file system function and it's part of pathname lookup. Currently, there is a duplicate directory entry and they're optimizing that out. Apparently, in some cases that can give you a 39% speed improvement, which if you're opening a whole bunch of files all at once, which compiling sometimes does, it works. It makes it a lot faster. This is pretty interesting to see in the VFS subsystem. And it should again show up in 7.4.

Jonathan Bennett [00:30:12]:
So, you know, it's interesting to see as many years as the kernel has been around and as many people have been in there looking for fixes and ways to get it better, that you still see so many of these things that show up. Like in this case, Michael Larabelle describes it as low-hanging fruit. It's cool to see that there's still places in there that people are finding things and making it better.

Jeff Massie [00:30:36]:
Oh yeah, 7.4 is going to be, I think, a pretty big release.

Jonathan Bennett [00:30:39]:
Yeah. Well, I mean, we called it a Christmas present back when we first started talking about this. It really is going to be a Merry Christmas for all of us Linux nerds. Looking forward to it. All right. We're going to take another quick break now that we're done talking about kernel proper. And we're going to talk about core utils. Rob's going to be back with that right after this.

Rob Campbell [00:31:06]:
Ubuntu is about to reach another major milestone in its efforts to replace some of Linux's oldest tools with some software written in Rust. When Ubuntu 26.10 arrives, its default core utilities will be entirely based on the Rust-powered new utils project. The last 3 holdouts, cp, copy, mv, move, and rm, remove. Some of the— I think you do those first. That'd be the first ones on my list. But, you know, they're kind of the core of the core utils in my opinion. But they are now scheduled to move away from their traditional GNU implementations. These commands may not sound exciting, but they are some of the most fundamental pieces of Linux system.

Rob Campbell [00:31:57]:
You know, the copy, move, and all that. CoreUtils also provides commands such as ls, cat, chmod or changemod, date, and du. Linux users depend on these tools constantly, even if they rarely think about what language they're written in. Canonical began making rust-core-utils the default with Ubuntu 25.10. So that's pretty quick in my opinion. One year, just a year ago, they started and only a year later they're finishing that transition. Most of the transition also made it into 26. So, I mean, they had the bulk of it done even much sooner.

Rob Campbell [00:32:46]:
But Canonical held back, you know, the copy move remove because security audits uncovered unresolved time of check to time of use problems. That was something, you know, it's probably a good decision that they held off on something and, you know, didn't push forward when they weren't ready yet. If you're replacing tools responsible for copying, moving, and permanently deleting files. Yeah, mostly compatible isn't quite good enough. So the audit found 113 issues of varying severities with 44 receiving CVE identifiers. Most have since been resolved, allowing Canonical to complete the transition in 26.10. Rust advocates will point to memory safety as the big advantage. Rust is designed to prevent entire categories of memory-related bugs that have historically affected software written in C.

Rob Campbell [00:33:41]:
So, you know, as I said many times, many, many times, that doesn't make Rust magic— Rust software magically secure. Though, you know, the number of issues uncovered during these audits proves that safe memory management, you know, it's not going to prevent all the errors. It can't. Canonical says utils is intended to be a drop-in replacement, treating differences from GNU core utils as bugs. So If something doesn't work as expected as you used to with the regular GNU core utils, it's a bug and it should be reported. Most users shouldn't— so most users shouldn't notice anything has changed. It should just feel the same. So I guess that's good.

Rob Campbell [00:34:28]:
However, scripts and automated systems can depend on obscure command options or decades-old behavior. So even small differences could create unexpected problems. Personally, I don't know if I'll ever get the chance to truly enjoy fully Rust-based core utilities, you know, in my distribution of choice. Projects such as Debian tend to move carefully, especially when replacing foundational GNU software that has been tested for decades. But for good or bad, Ubuntu users will get the opportunity very soon. You know, so I can respect Canonical for being willing to test a modern memory-safe replacement At this scale so quickly. And for— it's still for slowing down a little bit when the audit showed the software wasn't ready. At the same time, replacing reliable tools simply because Rust is newer and shinier.

Rob Campbell [00:35:25]:
I don't know. I don't know. They really pushed through it quick. But the real test, real test is not all these fancy words that I'd say to you. The real test will be whether or not Ubuntu can You know, say it's core utils, you know, they're written in Rust and they work just like they always did before. You know, it'll be whether millions of people can use them every day without even noticing anything changed. You know, people who don't listen to podcasts like this, who just use Ubuntu and upgrade and keep right on using it, they're probably, hopefully, ideally, They're not even gonna know that, uh, that anything's changed.

Jonathan Bennett [00:36:05]:
So that would be the ideal situation for, uh, yeah, you know, with 26.04, I don't, I don't remember, like when it first launched, there were some bugs found, but after that, I don't remember any like game-breaking bugs where people ran into problems because of that. It seems like it was kind of a non-issue after the, the first couple of minor things.

Rob Campbell [00:36:24]:
Yeah, there are some things. There's something with the sudo rust Or rust-sudo-rs or whatever it was.

Jeff Massie [00:36:30]:
And I think there was another one, but, uh, yeah, I want to say that's— I want to say the charts have had it at like 95% compatibility or something like that. I mean, it was pretty high for the— because they would run the standard benchmarks or capability benchmarks versus the regular core utils versus Rust utils and Yeah.

Jonathan Bennett [00:36:56]:
Well, so I interviewed the Rust Utils guy and they actually, the Rust Core Utils works pretty closely with the other 2 core utils implementation to get that benchmark. It's a test suite that basically goes through and makes sure that from one version to another, the core utils all do exactly what they're supposed to. And yeah, not only do they stay in sync with that, but they will like share with each other, you know, hey, I found this really niche case that is not covered by the test suite, why don't you add this test to your test suite as well? And then the other thing that's interesting there is that there are a couple of places where the Rust core utils intentionally work slightly differently. Like, I think the big one is when you're using cp to copy a file over. I think the Rust core utils gives you a progress bar by default. Whereas on the old-school core utils, it does not. You have to, you know, bring out some arcane trickery to make it happen.

Rob Campbell [00:37:56]:
You know, just imagine being, you know, the GNU coreutils, you know, basically you're training somebody to take over your job.

Jonathan Bennett [00:38:04]:
No, I mean, I think it's, I think it's that idea that it's going to be around on some Linux distros for a very long time.

Jeff Massie [00:38:12]:
Well, and wasn't there concern with the person writing the Rust coreutils that the code was so old that the original Utils was based on, they wanted to kind of update the code because there was—

Jonathan Bennett [00:38:28]:
That's possible. It was, it's, I mean, the original core utils was part of Unix, right? And then they got rewritten as part of GNU. And I'm not sure if we're on what the 3rd or the 4th rewrite of them now, something like that. You know, it's gone through, it's gone through several iterations. And then the other thing to think about, like, this is not the first project that's rewritten core utils. You've got things like BusyBox. It's got its own rewrite of core utils baked into BusyBox as part of it. Um, I mean, it's, it's, it's not that unique.

Jonathan Bennett [00:39:05]:
It's not like it's the first time this has happened.

Jeff Massie [00:39:08]:
Well, I thought, I thought, and maybe I'm totally misremembering, that they were concerned because it was in C or something and they weren't sure in, you know, 20 more years about C or something. I mean, it was something like that, I thought.

Jonathan Bennett [00:39:22]:
Like it's a really crusty ANSI C that it's all built in. Yeah, that could be.

Jeff Massie [00:39:26]:
Yeah.

Jonathan Bennett [00:39:27]:
I don't remember that exact detail, but that sounds feasible for sure.

Jeff Massie [00:39:32]:
Or at least, and that was the justification why the Rust person said, oh yeah, I want to rewrite this into a modern language. But maybe I'm totally misremembering.

Rob Campbell [00:39:45]:
So either way, good for Ubuntu for pushing things forward with the Rust core utils. Um, after last week's debacle, I've, I've, I'm moving, I'm working on moving my Ubuntu servers away from them.

Jeff Massie [00:39:56]:
So, well, I think the most interesting thing though is you got the Rust core utils that are trying to match the exact function of the original utils And you know, in there, there's places where they have some quirks, which could almost be a bug. And you write it and you're like, oh, this is perfect. And then you go, I have to write a bug into my code to make it match the old method because it's been that way for so long. Everybody just expects it to work that way.

Jonathan Bennett [00:40:25]:
Bug for bug compatible.

Jeff Massie [00:40:27]:
Bugged by default.

Jonathan Bennett [00:40:30]:
Yes. All right. Well, let's descend into chaos. That's where Jeff's taking us.

Jeff Massie [00:40:36]:
That's pretty standard fare, I think. Chaos is an independent distribution, which is based in the Netherlands and is shipped with KDE Plasma as its default desktop since early in the project's history, which is well over a decade. I wasn't sure if the 2014 version of Chaos had KDE or not. I was just looking at DistroWatch real quick when writing this story. But at least over 10 years, it's had KDE. You know, the Plasma has been the default desktop for a long time. Well, that changed back in February when Chaos developers ran into a wall with System257. In their own words, running an install on systemd-257 has been tested a while now.

Jeff Massie [00:41:23]:
Creating an ISO with it still fails. The problem is Chaos relies on a split /usr setup, as in split /usr is split up. And recent systemd versions stopped fully supporting that. The split slash refers to the file system layout where the core system directories like /bin, /sbin, and /lib are kept entirely separate from the /usr hierarchy. Allowing /usr to be mounted on a separate partition. Now, while most modern distributions, you know, such as Arch, Fedora, Debian, they've completed the, quote, user-merge. So it's kind of rolled everything into one. You know, it doesn't quite match.

Jeff Massie [00:42:15]:
Well, you might be thinking, well, so where does KDE come in with this? Well, the developer said, quote, Plasma pretty much demands systemd and will be fully mandatory soon. So by their March 2026 release, Chaos had already swapped its default desktop from Plasma to the Nere compositor paired with the Noctilia shell. Now, this probably, you're probably thinking, well, this stuff sounds like it happened a while ago. Why are we talking about it now? Which, which is fair. With this week's release notice, though, Chaos 2026.09, this is where the decision made is made permanent. It's the 2nd stable release built on the dinit instead of systemd. And in the official announcement, the team spelled out exactly where Plasma stands on going forward. Quote, the Plasma 6.7 series will be the last Plasma version available in Chaos.

Jeff Massie [00:43:17]:
Once Plasma 6.8 moves, once Plasma moves to 6.8, it will be removed from the Chaos repositories. So this isn't just not the default anymore. This is Plasma getting fully phased out of the entire Chaos distribution entirely on a defined timeline tied into KDE's own release schedule. So on the technical side, Chaos describes in its new init stack simply, quote, Chaos uses dinit, Turnstile, Seatd for the system startup seats and services. systemd isn't gone completely. It's just been reduced to handling udev and temp files with elongind sticking around to keep, uh, Polkit working. Login duties have been moved to greetd with a console-based greeter called TUI Greet as the default, though a graphical, um, Noctalia-based greeter is available for anyone who wants to use it, but the team says it's just not as polished yet. So your mileage will vary on that one.

Jeff Massie [00:44:29]:
Right now they're saying stick with the TUI. The scale of this release is bigger than it might sound because the team said, quote, around 70% of this distribution was rebuilt in the last 2 months since a bunch of major packages updates have been held back specifically until the dinit transition was finished. So that batch includes, you know, the Linux kernel 7.1, GCC 15.3, glibc 2.43, and Mesa 26.2. And Rust 1.98, among others. So, you know, it will be interesting to see, watch whether other smaller distributions maybe follow a similar path, you know, as more of the ecosystem of KDE leans further into systemd as a dependency. You know, now I'm not saying I don't— the big players, you know, Arch, Debian, Red Hat, they, they won't even consider pulling systemd or even putting it into a secondary position, at least not in the near future. But, you know, what will some of those small niche distros do? Because there's— we've talked about them before in the past. There's a few small ones that really don't like systemd.

Jeff Massie [00:45:43]:
Will they maybe just go, hey, Chaos kind of laid out a nice roadmap for us and that's the way we're going to go? I don't know. Time will tell. Take a look at the article linked in the show notes for more details and see if this makes you more or less interested in Chaos. Personally, I was kind of interested, but getting rid of KDE, I'm kind of less interested personally.

Jonathan Bennett [00:46:07]:
Yeah, I still like KDE quite a bit. I do. I'm not the rabid anti-systemd guy, but I do get the annoyance that it touches so many things. I wasn't real familiar with DNN. I kind of went on a side quest just now reading about it. Looks like an interesting alternative. Just unfortunate that, and I'm not sure who to blame, but it's unfortunate that it's so hard to support something other than systemd right now.

Jeff Massie [00:46:38]:
Just want everybody kind of aligned on it for the most part.

Rob Campbell [00:46:41]:
Yeah. Yeah, I'm not too interested. It sounds like a chaotic mess to me.

Jeff Massie [00:46:47]:
Well, you know, and I'm okay with systemd because for me it works and I don't know enough about the deep underpinnings to really have an opinion, strong opinion one way or another. So it works. I'm happy.

Rob Campbell [00:47:02]:
Okay. You know?

Jeff Massie [00:47:03]:
Yeah.

Rob Campbell [00:47:03]:
It has a lot of useful features.

Jonathan Bennett [00:47:05]:
It does. When it absorbed DNS, the local DNS, that's when I sort of got irritated by it.

Rob Campbell [00:47:13]:
Uh, yeah, you know what, I agree with that.

Jonathan Bennett [00:47:15]:
I still want to go turn that off. Not figured out how yet, but I want to. I'm sure it's possible.

Rob Campbell [00:47:22]:
Um, yeah, because it, it's not in like resolve anymore, right? It moved from there, right?

Jonathan Bennett [00:47:28]:
Or, uh, I think on most systems it just rewrites resolve.conf to, to point to its own local port. Then there's a big warning, do not modify this file. I'm like, it's my computer. Buzz off. I'll modify it if I want to.

Rob Campbell [00:47:42]:
What's the file doing here then?

Jonathan Bennett [00:47:46]:
Yep. You know, that's the reason why I left Windows so long ago, right? Is I would open on a fresh Windows XP install. You would open up the C folder and it would give you— it wouldn't show you anything there. Just this warning. Modifying contents of this folder may destroy your PC. Warning. Are you sure you want to see that? You know, I did a Windows reinstall one time and I saw that. I'm like, I'm so sick of this.

Jeff Massie [00:48:09]:
Well, did you guys see one of the Linux video people? He released a video of, it was like, I want to say it's like 2003, 2004, Bill Gates complaining to some of the really higher-ups at Microsoft, his adventure trying to install Movie Maker. And just, it was like, Just a total mess. I mean, it was just, you know, oh, you can't do this here. I can't find this. What does this even mean? Oh, I've got an update, but it doesn't tell me where I'm updating. It doesn't, you know, it—

Rob Campbell [00:48:42]:
No, I haven't seen it.

Jeff Massie [00:48:44]:
It'll— I'll throw it in the ending notes and get more information on that. I saw it just this morning. It was just released today and I kind of got a chuckle out of it.

Rob Campbell [00:48:56]:
You know, since we're talking about Windows, you know, we recently had a story, I don't know, sometime in the last month about all the vulnerabilities that are being patched in the kernel lately. I don't know if they ever got to that 2,000 count yet, but that was what we're looking at. I know Windows is hitting new records there too. They just, their last Patch Tuesday was just Close to 1,000, just under 1,000.

Jeff Massie [00:49:26]:
Yeah. Yep.

Jonathan Bennett [00:49:30]:
I mean, so that's surprising. The tooling is getting better. It's kind of like the— it's real similar to the wave of vulnerabilities that started getting discovered by fuzzers when fuzzing really became a thing.

Rob Campbell [00:49:42]:
Unfortunately, they did a great job finding them. But I believe from what I heard, you know, I only loosely hearing about this. But a lot of their patches had a lot of problems. And there is a new term. I mean, anyone in IT industry has at least loosely heard of Patch Tuesday. Well, now there's Unpatch Wednesday. I didn't make that up, but.

Jonathan Bennett [00:50:10]:
Yep. Yep. No, I believe it. I've got the battle scars as well.

Jeff Massie [00:50:19]:
All right.

Jonathan Bennett [00:50:19]:
Let's talk about, he's speaking up. Speaking of patches and the AI CVE wave, Intel is ending their bug bounty program. It's— they're not ending their bug reporting program. They're just no longer paying for it. And this is a continuation of a trend that actually we've seen across a lot of different companies and projects. I believe curl has done this. They're no longer paying out for vulnerabilities. And so Intel— and this is probably 2 different trends actually coming together because Intel is also trying very hard to tighten their belt.

Jonathan Bennett [00:51:04]:
And part of that is they're sort of ending sort of their more open and open source projects. But it's also the bigger trend just because the AI has gotten so good at finding vulnerabilities. That bug bounty projects don't make nearly as much sense as they used to. It's so easy to find them. And essentially every time the frontier models update, there's a new wave of vulnerabilities that gets discovered. And so, yeah, Intel is closing their bug bounty program and I believe, yeah, launching a new one on integrity. But It is a responsible disclosure program without bounties. So not too hard to figure out what's going on there.

Jonathan Bennett [00:51:49]:
I think Intel is, like I said, not the only one that has and not the last one that will make this change. I think with just a few, very, very few exceptions, we're seeing the end of the paid bug bounty program.

Rob Campbell [00:52:04]:
Yeah, there's one more career path, bug bounty hunter, that's It's slowly going away.

Jonathan Bennett [00:52:12]:
Yeah, not entirely, but—

Rob Campbell [00:52:14]:
I didn't say gone, but going dwindling.

Jonathan Bennett [00:52:19]:
Yeah.

Jeff Massie [00:52:21]:
I could see payouts for exceptionally big bugs that were maybe hard to find or something, you know, really obscure that just regular AI just doesn't spit out.

Jonathan Bennett [00:52:34]:
I think you'll still see bug bounties getting paid out. for the bugs that continue to have a market value. And so I'm thinking particularly of like getting root on phones. That's one that, you know, I mean, I think Apple's top bounty was $1 million for a vulnerability that'll let you get full root on an Apple phone. And it's because those have market value. And if a researcher finds it and is not able to sell it to Apple, they're gonna turn around and they're gonna sell it to, you know, either a completely criminal organization, or they'll sell it to, you know, somebody like Cellubrite or, um, NGO Group. Is that the other one? There, you know, there's a couple of these groups that that's the thing that they do is they, they make sort of legal hacks so that governments can get into cell phones. And of course, you, you read about those guys on the news from time to time, the shenanigans that they get up to.

Rob Campbell [00:53:30]:
Have Have either of you heard, I'm going back to Windows again, but either of you heard of the Nightmare Eclipse? I don't know, researcher or hacker or what he is that has been troubling Microsoft pretty much all summer long.

Jonathan Bennett [00:53:47]:
Yes. Is he still releasing stuff?

Rob Campbell [00:53:49]:
Yep. Right after Patch Tuesday, next day, he releases either they didn't completely fix the last bug he released. And there's still vulnerabilities or something new. Yeah, pretty much. I think every Patch Tuesday's had something.

Jonathan Bennett [00:54:04]:
Yeah.

Rob Campbell [00:54:05]:
So anyway, I just brought that up because, you know, I feel like that's somebody that you just pay, bring him in.

Jeff Massie [00:54:10]:
Well, that's how this—

Jonathan Bennett [00:54:12]:
that's actually how the Nightmare Eclipse thing started. That dude was a bug bounty researcher and he found something and Microsoft refused to pay out on it. And he's like, all right, he kind of washed his hands of playing by the rules. Like, I'm just going to make your lives hard from now on. And, uh, yeah, he has proven to be able to do that.

Rob Campbell [00:54:30]:
Yeah, they are good.

Jonathan Bennett [00:54:33]:
Yes, exceptionally good at making life hard for Microsoft. Uh, absolutely.

Jeff Massie [00:54:40]:
Didn't they get cheated out of a bounty or something like that?

Jonathan Bennett [00:54:43]:
That's essentially what it was. They, they reported something, were hoping for a bounty, and, uh, Microsoft refused to pay on it.

Rob Campbell [00:54:51]:
Yeah. Yeah. And then, then he made it, since they didn't do anything about, I don't remember the paper, but I know since they ignored or did not respond to his report, he made it public or whatever. And then they tried to threaten legal stuff and, and then they put back down from that.

Jonathan Bennett [00:55:12]:
Yeah, it was one of those deals where it's like, here's a vulnerability. Oh, that's not a vulnerability. That's just a finding. Okay, I'm releasing it to the public. You can't release vulnerabilities to the public. Well, is that the way we're going to play this?

Rob Campbell [00:55:24]:
Yeah, they threatened legal. Like, if you do things to damage our users, legal stuff can happen. And then the whole community, the whole, I don't know, researcher community just kind of went crazy. Like, that's not how you— Treat people trying to fix your stuff for you.

Jonathan Bennett [00:55:49]:
Yep. Yep. There was chatter about this at DEF CON and some other places I've been. Yeah, absolutely.

Jeff Massie [00:55:55]:
All right.

Jonathan Bennett [00:55:55]:
Well, we got one more break to take. Well, we got 2 more breaks to take, but one of them we're going to do right now. We're not going to do 2 breaks in a row. That would just be insanity. We're going to take a break and then we're going to come back and we're going to waste some time or we're going to talk about people wasting time. Maybe both. We'll be right back. Don't go anywhere.

Rob Campbell [00:56:12]:
As Jonathan said before the break, Mint developers are again wasting more time on side projects rather than focusing on the important issues with Linux Mint. The Mint team has announced 2 new applications for Linux Mint 23, along with the redesign of an existing one. The first one, Clockenstein, Shown to users simply as a calendar, is a new calendar application supporting local calendars, Google Calendars, and CalDAV services such as Nextcloud. So that could be a real handy integration there. It'll keep calendars synchronized in the background and deliver reminders even when the application is closed. The next one is XEPUB, or yeah, is a new ebook reader with bookmarks, search annotations, customizable fonts, and the ability to remember where you stopped reading. Mint is also redesigning its library application to make documents easier to organize and find. You know, these sound like well-designed applications and they will probably be useful to many people.

Rob Campbell [00:57:32]:
But is a new calendar and ebook reader and document organizer really the most important things Linux Mint needs right now? You know, Mint's biggest problem, as I see it, has been its continued reliance on X.Org. While most major Linux distro environments, distributions have moved to Wayland years ago, Mint has remained stuck on an aging display system that is largely in maintenance mode. Cinnamon added an experimental Wayland session back in 2024, but the current stable release of Mint still uses X.Org by default. The Mint team says Wayland will finally be considered fully supported in the next Cinnamon release. Both X.Org and Wayland will remain available, and Wayland will still But Wayland's not going to be default yet. But more importantly, that version has not been released yet until Linux Mint 2023 actually ships and users can test it on real hardware. Mint's supposedly stable Wayland support is still, it's still promise. Problems involving NVIDIA graphics, display scaling, screen sharing, accessibility, color management, and other desktop features will only become clear once ordinary users begin relying on it.

Rob Campbell [00:58:54]:
Yes, different developers have different skills. Some write an ebook reader and others are more capable of fixing Cinnamon. Development does not work by placing every programmer into one big pool, as I'm kind of trying to do here. But development priorities still matter. Especially for a relatively small project maintaining its own distribution, desktop environment, utilities, and growing collection of applications. To Mint's credit, application development may be what it really does best. You know, its update manager, software manager, Warpinator, XApps, and other desktop tools are often practical and easy to understand and useful outside of Mint itself. And then Timeshift is another great example.

Rob Campbell [00:59:48]:
Probably my favorite piece of software made by Mint. You know, I mean, they didn't originally create Timeshift, but they adopted it in their project, integrated it extremely well, and helped turn it into one of the most valuable system restoration tools available on Linux. You know, that track record makes these new applications worth watching. Clockenstein, XePub may become excellent cross-desktop applications that we can all enjoy across the ecosystem. But it raises a larger question in my mind. You know, if Mint is better at creating polished applications than keeping its underlying desktop technology current, perhaps it's spreading itself too thin trying to do both. You know, maybe they should just stick to app development. Since they really kind of seem to excel there.

Rob Campbell [01:00:40]:
You know, leave the desktop maintaining to the professionals. I don't know, but the apps seem pretty— the apps seem like they'll be a nice addition. So maybe it'll, you know, help obscure the issues underlying.

Jonathan Bennett [01:00:58]:
Should Mint just become another spin of Ubuntu?

Rob Campbell [01:01:03]:
Or Debian.

Jeff Massie [01:01:05]:
Well, they are a spin of Ubuntu.

Jonathan Bennett [01:01:08]:
Well, kind of.

Rob Campbell [01:01:10]:
They're not an official flavor. They are a derivative.

Jeff Massie [01:01:13]:
But here's where it gets interesting. Okay, so GNOME got rid of X11. KDE is getting rid of X11 totally. At what point does Ubuntu go, yeah, we're not putting it in there anymore? So then the developers are going to have to You know, if they're going to still base it off Ubuntu, load it in themselves and handle that. And, you know, at what point do you go, there is so much overhead here, let's just make Mint GNOME or KDE and just put our own flair on everything?

Rob Campbell [01:01:48]:
KDE makes a lot of sense to me. I wonder if they're getting all their stuff just upstream from Ubuntu, like X.Org.

Jonathan Bennett [01:01:56]:
I'm not sure.

Jeff Massie [01:01:57]:
I believe it's still in Ubuntu.

Jonathan Bennett [01:02:03]:
That sounds right. And then there for a while, and there probably still is, the LMDE, the Linux Mint Debian Edition, which that one was what was recommended to me at one point. And I did a couple of installs with that. Didn't hate it. I tell you, the thing that I really ran into with that is that there's no official upgrade path. from one version of it to the next. And that kind of soured me on it because like people say, oh yeah, Linux Mint, it's great for new users. It's the easy one, easy to maintain.

Jonathan Bennett [01:02:34]:
It's like, okay, great. I haven't been here for a couple of years. How do I fix it? You get to reinstall it. Thanks.

Rob Campbell [01:02:40]:
That's still a thing. I knew Zorin Linux only just fixed that a couple of years ago now. So are you sure?

Jonathan Bennett [01:02:49]:
At the time. At the time, that was the official solution on Mint.

Rob Campbell [01:02:53]:
That was the Zorin solution for a while. And I remember we did a story on it about 2 years ago where they officially added an upgrade path. I imagine Mint has one now. But—

Jeff Massie [01:03:07]:
Well, one time Mint had a KDE spin. I don't know if they still do, but they don't. Oh, they got rid of it.

Rob Campbell [01:03:18]:
Their one decent spin they had.

Jeff Massie [01:03:21]:
And it was kind of always in the background. You kind of had to, you had to kind of look for it. You know, it wasn't, wasn't out in front, but that would mean they'd, if they were still keeping it up, they'd be like, oh, well, you're committed to Wayland now because that's all it runs on.

Rob Campbell [01:03:35]:
Yeah. Technically, it's, so I hear it's in the repositories and you can install KDE. I assume you're just getting the vanilla experience, which, you know, when you install KDE from vanilla experience from the repo and Linux Mint, I mean, I don't know. What do you got? Is it really Mint anymore? You kind of, you know, they put all their work into their flagships, Cinnamon and XFCE. You know, I don't know.

Jeff Massie [01:04:08]:
You're almost Kubuntu at that point.

Rob Campbell [01:04:12]:
Almost. Without Snaps, though. That's the argument people say. That's the argument I get. I was like, oh, it's just, you just pretty much want to. And it's like, well, but no Snaps. That's one reason why people, one of the reasons I know people that do gravitate towards Linux Mint.

Jonathan Bennett [01:04:28]:
Yeah, that makes sense.

Rob Campbell [01:04:30]:
They get Ubuntu without Snaps.

Jeff Massie [01:04:33]:
Well, there was some of that. One of the reasons it pushed me off was just because I was running Firefox and went to a Snap and then it just, it destroyed my video decoding. But I could run that same version of Firefox on other distros and it worked just fine. It was, it had to do with the Snap. And then I could go in and turn off the Snap, which I did, and it worked better. But I mean, it's several steps. So somebody new is not going to go in there and go, oh, okay, do this. Now you got to reprioritize your— package repositories for Firefox and you got it so it doesn't pull from the Snap.

Jeff Massie [01:05:08]:
And, you know, it's like, and I'm sure they probably have it fixed now, but it was just annoying. And then it was like, hey, well, let's just see how the other half lives. And yeah, or how the other 1/100th lives, I guess.

Rob Campbell [01:05:21]:
Oh, mine was all when they, uh, when I realized they weren't giving me all my security updates.

Jonathan Bennett [01:05:32]:
Yeah, that makes sense.

Jeff Massie [01:05:34]:
I've already started thinking about, I've got a 24.04 that's just chugging away and it is on the security stuff, but I've thought, what other pretty stable distribution would I go with? And I might just run flat Debian and call it a day.

Rob Campbell [01:05:53]:
All right.

Jonathan Bennett [01:05:53]:
We've got, we've got what, one more story from Jeff talking about PipeWire?

Jeff Massie [01:05:59]:
Yes, we do.

Jonathan Bennett [01:06:00]:
All right. Well, let's talk about PipeWire.

Rob Campbell [01:06:01]:
Yeah. Covering that one since Ken's not here today.

Jonathan Bennett [01:06:04]:
Yeah. Yep.

Rob Campbell [01:06:05]:
From Ken's area.

Jeff Massie [01:06:08]:
This one's for you, Ken. If you're on Linux, you know, there's really a high probability, very high, that PipeWire is under the hood. And today we've just seen version 1.6.9, which landed on September 17th, about 2 months after 1.68. And, you know, while it's still a maintenance release, there's, there's some interesting things in it. Something that I personally like that changed— PipeWire adjusted its upsampling cutoff frequencies to preserve more high-frequency content, meaning when PipeWire has to upsample lower quality audio sources, say around 32 kHz in particular, they're, they're losing— they were losing more high-end and detail than they should have been. Under the old default. So now they fixed that so that if you're kind of picky about audio quality, such as Monomi, this update is worth grabbing on that alone. And the fact that we're just going to get it anyway.

Jeff Massie [01:07:06]:
But, you know, social enthusiasm here. On Bluetooth, PipeWire fixes a memory leak that could occur when transport fails to start, plus a crash during the cleanup of ISO-IO audio transport, relevant if you've ever had your Bluetooth headphones randomly drop out or your audio daemon quietly balloons in memory over a long session. Jack users get a rework of how PipeWire tracks removed objects so apps won't keep reporting, trying to keep reopening ports to devices that are already gone, which causes, which in itself causes its own memory leaks. Network audio syncs and sources are now properly tagged, so tools like PavControl stop trying to wake them up unnecessarily. RAOP support has been patched for encryption problems on OpenSSL 3 and newer, plus fixes for choppy transmission over TCP/IP and audio getting cut off midstream. Pulse server compatibility layer crashes are fixed, or some of them are fixed. GStreamer lockup fixes during state changes and some command line tool polish. pw-record now supports A-LAW audio and fixes an MP3 encoding bug.

Jeff Massie [01:08:29]:
pw-cat handles the end of encoded files correctly now. So that's a nice improvement. So While not earth-shattering, this was a good polish for update for PipeWire, and I look forward to it. And take a look at the article linked in the show notes for more details and links to the official GitHub page, which lists out even more fixes and changes as well.

Jonathan Bennett [01:08:52]:
Yeah, I looked, I looked briefly at this, and it seems like there are just, just a few, um, a few decent fixes that they landed here. Some interesting stuff. Um, one, one that Let me find it again. There was one in particular that I thought was really interesting. Maybe it was the passthrough format handling for video.

Rob Campbell [01:09:15]:
Hmm.

Jonathan Bennett [01:09:16]:
Yeah, some interesting stuff there. It's good to see PipeWire continue to being developed and continue to come along. For a lot of things, it really has changed the game. Routing audio around in Linux is so much better now. You can do so many things so much easier than you used to be able to.

Jeff Massie [01:09:33]:
Oh, and it— I don't know if people realize, or maybe if you're, you're newer, you can do things like, you know, sometimes I'll record a radio show and I'll have it going directly to Audacity, which is an audio recording program, but I want to play a video game at the time and I'll listen to the radio show later. I can have the video game audio going right to my headset, the audio from the streaming radio show goes right into the recorder, but I don't hear it. So I'm just only hearing my game and I can just route those around wherever I want it. And it's pretty cool.

Jonathan Bennett [01:10:11]:
I mean, I remember the days on Linux where you couldn't have 2 different applications making sound out the speakers at the same time. Maybe that wasn't that many years ago.

Jeff Massie [01:10:20]:
Now you can get the speakers going, your headphones going, and they're playing different things.

Jonathan Bennett [01:10:24]:
Well, I mean, PipeWire has a complete jack implementation in it. So you can literally, you turn everything in your computer into virtual ports and you can just plug and unplug and route. You can literally route audio wherever you want to. You can do live plugins and all kinds of fun stuff. In fact, the desktop behind me, I've got a, I got tired of listening to YouTube videos where the mixing was terrible. And so I've actually got wired into my main outputs now a full-time compressor just so that the audio level stays about the same for everything that I listen to.

Jeff Massie [01:11:01]:
And for those curious, we've covered in the past, but QPWGraph gives you graphical representation where you can just connect sources and outputs in whatever fashion you want.

Jonathan Bennett [01:11:15]:
Yeah, there's a few of those programs that let you do that. Super useful stuff. All right. Well, it is about time to dive into some command line tips. I know we've got some interesting ones. We're going to take our last break of the show, so don't go anywhere and we'll see you on the command line on the other side. All right, Rob, you're up first and you've got an exercise app. Is that right?

Rob Campbell [01:11:40]:
Exercise. NoR. NoR and they're just Exise, E-X-C-I-S-E. So this is a command line app, TUI, I believe. It looks TUI to me. Similar, there are many GUI apps like this. I can't remember any of the names of them except for one of the popular ones in Windows is called WinDirStat, which it's not even the one I use in Windows anymore when I am on Windows because I found ones that are faster, but it's the only name I can remember. So anyway, this is Xsize, and it's basically a graphical representation of your storage where, you know, where the big stuff is here.

Rob Campbell [01:12:26]:
Awesome. Lib. Awesome. Share. Go into that, and it's going to break it down smaller. And, you know, if you find a really big file while you're digging through this, I'm not going to do it. But could, it's somewhat of a demo machine. But anyway, you hit Backspace or Delete and you can just delete it.

Rob Campbell [01:12:50]:
So be careful in here. But so yeah, graphical representation of your storage and then you can excise large files that you don't want. I assume that's where they got the name from.

Jonathan Bennett [01:13:07]:
That makes sense. You know, I've been, I've been using, uh, NCDU for this, which I learned about as a command line tip here on the show. Um, and it does essentially the same thing. It lets you, you, you know, kind of drill down and see what's using up your disk space and deleting it. But NCDU does not have the, the great, uh, different size blocks, you know, the, the visualization of it. It's all, it's all like, you know, here's the name and here's the number of gigabytes or megabytes or whatever.

Rob Campbell [01:13:33]:
So that is, it's for those, this is for those visual people who don't want to numbers. They don't care for the numbers so much because it just gets all gobbled in their head, but they can visually see when a big block is bigger than a small block.

Jonathan Bennett [01:13:49]:
Makes sense to me. All right. Jeff has a potentially comics-themed tip for us. What is Snoopy in this context?

Jeff Massie [01:14:01]:
Well, you know, I'll be honest, this is going to be one of the shortest command line segments we've had in a while, but Snoopy is a small library that logs all program executions in your Linux system. It's a wrapper around the execve function, and it's a Linux kernel call which instructs— it's a call you use to execute a program That's in a separate file. So it, like, if you do cd, it's going to get logged. So you install it and then it will log those commands. And you can check the /var/log/auth.log if you're on a Debian system. It's /var/log/secure for like Red Hat, CentOS. And /var/log/messages for most others. If you're not seeing it, you can check your Snoopy and syslog configuration, your snoopy-config and syslog-config to find the output format and the destination for your system if it's in doubt.

Jeff Massie [01:15:07]:
The link in the show notes has the instructions for that. It might look pretty quiet on the development front, but it's still supported and it's just in maintenance mode. So there's no new features. If anybody has any bug fixes or something causes a hiccup, they'll patch it. But otherwise, it's pretty much, it is what it is. So if you look at the link in the show notes, it takes you to the GitHub repository and it gives you all the details of, you know, installation and depending on your platform configuration. A lot of distributions have this actually in their default repositories. So if you really want to know what's going on in your system and Like to know everything that's running and who ran it, Snoopy's what you need.

Jonathan Bennett [01:15:54]:
Very cool. Yeah, it's a neat command. All right.

Rob Campbell [01:15:57]:
It'd be very useful.

Jeff Massie [01:16:00]:
Yeah.

Jonathan Bennett [01:16:00]:
Although they do have a warning that it's not for— how did they put it?

Jeff Massie [01:16:04]:
It's not total security. If somebody's really breaking in and kind of nefarious, there are ways around it.

Jonathan Bennett [01:16:11]:
It is not a reliable auditing solution. That's the way that they put it. Yes. That makes sense too. I want to talk real briefly about .pc, and no, that's not being politically correct, that is package configurations. This is how, when you compile something, how the compiler, the linker, the tooling knows that you've got a package installed. There is a library that I am using that does not have a way to do the .pc as part of its install. So I had to go down this rabbit trail of figuring this out, and I figured I would give you guys the breadcrumbs to come along with me.

Jonathan Bennett [01:16:57]:
So PC files are processed by pkg-config, and that is one of the— I think it's actually a core util that again goes out and looks to see, do we have dev development versions of these libraries installed so that we can compile against them? And so oftentimes we are, you know, you're your Make script or your CMake script will go out and check for these and complain at you if you don't have the right files installed. The way that this actually works is when a dev library is installed, it writes a .pc file to a location in, I think it's /var. I don't remember exactly where it puts it by default. There is a location it puts it, and of course I don't see it at the moment, but it writes these out one for each, and it essentially lists out the, you know, the name of the library, gives you description, has some information, but it also has like what, what files it gives, what you should include when you're compiling What flags are used, required, what it conflicts with, some other things like that. And so essentially, this is how, if you've ever wondered about it, like once I do a make install of that library and then I go back and do a, you know, run the make scripts and run the Makefile, how does it know that that thing is installed? Well, this is how it works, PCFiles. So not, you know, not the entire discussion of it, but a breadcrumb to point you in the right direction if you ever have to work with this in the future.

Jeff Massie [01:18:45]:
Yeah, some of these, and some of these I totally get it because some of these you get into the man page and some of that stuff, it's like, holy, there's a whole book on this, you know. Here's the breadcrumbs so you can go down and have your own learning adventure.

Jonathan Bennett [01:19:01]:
/usr/lib/package-config, that is where they tend to live. By the way, I went ahead and took a check. At least that's what Google says, and surely we can trust Google. So you probably have a whole bunch of those files on your computer right now.

Jeff Massie [01:19:18]:
Let's see.

Rob Campbell [01:19:20]:
Well, now you're Windows 1, Jeff.

Jeff Massie [01:19:26]:
Yeah, but I never boot into there. I know you live it, Rob. It's okay. You're trying to put your own securities on me, but it's okay. I can take that weight for you, buddy. It'll be okay.

Rob Campbell [01:19:44]:
It's my day job. Yep.

Jonathan Bennett [01:19:50]:
That is not where they're at on this computer. I wonder.

Rob Campbell [01:19:54]:
Stop using Google.

Jonathan Bennett [01:19:57]:
I guess. You can check the exact search path by running that command, a package command config. Package config command. Well, got that one backwards. Let's see. /usr/lib64/package-config. Well, of course, that makes sense. Well, I think that is it.

Jonathan Bennett [01:20:19]:
I think that's the show. It's been a lot of fun. I'm gonna let each of the guys plug something if they want to. Uh, Rob, we've, we've talked about your book for a couple of weeks in a row. You have anything else, uh, that you want to let folks know about, or is, is that the one?

Rob Campbell [01:20:33]:
That's it. You know, I noticed that, uh, Jeff doesn't have my book sitting next to him, so I'm guessing he must have hated it and threw it in the garbage. Um, I don't know. Uh, and there's no new reviews on, on the Amazon page either. So I'll try harder next time.

Jonathan Bennett [01:20:55]:
Next time you write your autobiography?

Rob Campbell [01:20:58]:
Memoir. It's a memoir, so it's different. You can have multiple memoirs pretty easily.

Jonathan Bennett [01:21:01]:
I suppose that's true.

Rob Campbell [01:21:03]:
But no, I'm sure he loved it.

Jeff Massie [01:21:07]:
Well, I'm still where I was. I haven't had a chance to go all the way through it yet.

Rob Campbell [01:21:11]:
Oh, okay. All right. Fair enough. Anyway, for anyone else who's interested, you can come find information on me at robertpcampbell.com. On there, links to my LinkedIn, my Twitter, my Bluesky, my Mastodon, and place to donate a cup of coffee to me, which, you know, I already thanked him last week, but no one's donated since, since then. So I'll thank Mario again for donating the 3 cups of coffee they did. And Twitter and Bluesky, I've been posting there a lot more lately. In fact, I even posted to the show since, you know, there's a topic that nobody covered that I thought was going to get covered and I only have room for 3 shows.

Rob Campbell [01:21:50]:
So I had to post it there. So, you know, connect with me. I've been posting there a lot. I've been posting there regularly, trying to do at least 3 times a week. I think I hit 4, maybe 5 this week. I don't remember. So yeah, come connect with me. And if you are interested in this wonderful book, it's a memoir.

Rob Campbell [01:22:12]:
So not an autobiography. The difference is essentially, it's more like stories with a trajectory of my life, my path from trailer park to technology leader. I was not born in the trailer park, as I said, but that's where I grew up initially.

Jonathan Bennett [01:22:31]:
And next time you write the book, will you be born in the trailer park?

Rob Campbell [01:22:38]:
Maybe if I make it a fiction, maybe I'll make a fiction. Anyway, uh, and if you're interested, also on the page, you can, you can either search Amazon, it comes up pretty easy once, once I type— maybe it's just me, but once I type Trailer Park 2, the rest comes up. Um, but on my page, robertpcampbell.com, go to click on memoir or just scroll down and there's a link there to buy it on Amazon.

Jonathan Bennett [01:23:05]:
And there you go.

Rob Campbell [01:23:09]:
There you go. There you go.

Jonathan Bennett [01:23:12]:
All right, very cool. Jeff, what you got for us?

Jeff Massie [01:23:14]:
Well, I, I do have the book right here. See, I'm a third of the way through, quarter of the way, something like that.

Rob Campbell [01:23:20]:
About the same place you were last time.

Jeff Massie [01:23:22]:
Yeah, I didn't get a chance to read it this week. Um, the video that I was talking about earlier about Bill Gates trying to install Movie Maker On YouTube, you can look at Brody Robertson, and it's Bill Gates Realized the Insanity of Windows. And I also have a link in the show notes. And finally, Poetry Corner this time is we're going to take some artistic license. This isn't so much about technology this week, but I'd like to thank Steve for sending me this. And I really kind of liked it. So here you go. There was a young man from Cork who got limericks and haikus confused.

Jeff Massie [01:24:03]:
Have a great week, everybody.

Jonathan Bennett [01:24:08]:
That's great. That's great.

Rob Campbell [01:24:12]:
All right.

Jonathan Bennett [01:24:12]:
Thank you guys. It has been a blast. And if you want to find more of me, you can check out Hackaday, particularly that's where FLOSS Week Weekly Lives, and we have a, uh, have a lot of fun there. Taking a week off, like I said, I'm going to be in Europe this week, and, uh, but I'll be here. I should be here. I'm flying back in early on next Saturday, and so should make it for the show. You get to experience jet-lagged Jonathan next week, but, uh, I'm sure it'll be— I'm sure it'll be great. Anyway, we appreciate everybody that is here, whether you watch us live or on the download, audio, video.

Jonathan Bennett [01:24:43]:
We just want to say thank you, and we will See you next time on the Untitled Linux Show.