Untitled Linux Show 268 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're talking about the boatload of CVEs in Linux and what that actually means. Chromium is getting Flatpak support. The German sovereign tech agency wants in on that particular game. Multikernel is here. Ardour has an update. And we might be getting HDMI 2.1 for Christmas. That and a whole lot more. You don't want to miss it.

Jonathan Bennett [00:00:22]:
So stay tuned.

Rob Campbell [00:00:26]:
Podcasts you love. From people you trust. This is TuxDigital.

Jonathan Bennett [00:00:34]:
This is The Untitled Linux Show, episode 268, recorded Saturday, August 29th. Merry Christmas, maybe. Hey folks, it is Saturday and you know what that means. It's time for Linux. We're here to talk hardware and software, the desktop, the command line. It is The Untitled Linux Show and I've got a couple of cohorts, not a full cadre, but there are a couple of us. We got Rob and we got Ken. Welcome guys to the show.

Jonathan Bennett [00:01:01]:
Hey, thanks for having us.

Ken McDonald [00:01:01]:
Glad to be back this week.

Jonathan Bennett [00:01:03]:
Yeah, it's good to have, well, not quite everybody back. Jeff has taken a leave of absence for the day, but we finally got Rob back.

Rob Campbell [00:01:12]:
I told you, I said, I'll be back.

Ken McDonald [00:01:15]:
And we've always got a spot open for David to come back.

Rob Campbell [00:01:18]:
Sure. The day that I'm back apparently happens to be a Skynet anniversary or the Skynet awakening.

Jonathan Bennett [00:01:25]:
Yes.

Jonathan Bennett [00:01:27]:
I saw that. I don't remember if there's a date attached to that. Like if today is actually the day or if it's just the anniversary. It feels a little spookier this year than it has any of the previous years. Like it's a little bit more within the realm of possibilities.

Ken McDonald [00:01:43]:
I'm trying to think how far in the future the original Terminator movie was set to have come back from.

Rob Campbell [00:01:52]:
I think it was like, actually, I think it was like '28. I just heard this recently and I'm like, oh, that's coming real soon. '27 or '28, I want to say.

Jonathan Bennett [00:02:00]:
Yeah, well, I will look for that. While I am looking up minutiae about Terminator, we're actually going to let Rob talk about security in the kernel. And the question here is, are things getting better or are they getting worse?

Rob Campbell [00:02:16]:
Yeah, so the big question I got to ask here is, or people might be asking here is, is Linux getting less secure? That might be the first thought when you see a headline saying the Linux kernel is approaching 2,000 CVEs per release. For some perspective, Linux kernel releases from 6.9 through 6.19 averaged around 500 CVEs. Starting with Linux 7.0, that number climbed above 1,000 and with Linux 7.2 went beyond 1,500. 1,500. And the current rate, Linux 7.3 could cross 2,000. That sounds terrible, right? But the number does not necessarily mean that Linux suddenly has 4 times as many vulnerabilities. It means the Linux community is finding, documenting, and fixing far more of them. The Linux kernel project became its own CVE numbering authority in 2024.

Rob Campbell [00:03:22]:
As part of its current process, developers review fixes going into supported kernels and assign CVEs very cautiously. Because almost any kernel bug could potentially have security implications, many fixes now receive CVE numbers that might not have received one in the past. Another important detail is that these CVEs generally are not assigned until a fix exists and has been added to a supported stable kernel. So in many cases, the headline's not saying here are 2,000 vulnerabilities that nobody has fixed. It's closer to saying here are nearly 2,000 potential security-related bugs that were identified, tracked, and fixed. And now it's time to update. AI-assisted code analysis is also helping researchers find bugs that may have remained hidden for years. That does not mean AI created those vulnerabilities.

Rob Campbell [00:04:25]:
Those bugs and vulnerabilities, they were already there. People just weren't finding them. And maybe some people were and they just weren't telling anybody. Who knows? But we're simply getting better at finding them now. This is where comparing Linux and Windows and macOS becomes difficult. You know, those operating systems, Also publish CVEs and security updates, but their source code and internal development process is largely closed. We can't independently inspect the complete code base, see every bug that was found internally, or know how many problems were quietly fixed behind the scenes without ever receiving a CVE. You know, without Linux, the source code patches Discussions and CVE process, or with Linux, I mean, these things are all out in the public.

Rob Campbell [00:05:20]:
That transparency can make Linux look worse because we could see all of its dirty laundry, but hiding the laundry does not make it clean. And, and yeah, I can attest to that in a real-world scenario, but the growing CVE count is not automatically evidence that Linux is becoming less secure. It's more than likely showing us that Linux is actually becoming even more secure. Just make sure you patch often.

Jonathan Bennett [00:05:54]:
Yeah, something to really keep in mind here is that Windows and macOS, they are fixing bugs and they are not calling all of them CVEs and they are not really even things that, you know, would be CVEs, they are not releasing to the public as CVEs. They generally save that for things that are known outside of their own company.

Jonathan Bennett [00:06:11]:
So.

Ken McDonald [00:06:11]:
Yeah, you actually talked about this 2 years ago, didn't you, Jonathan?

Jonathan Bennett [00:06:15]:
We've talked about it a bunch of times. Yeah. The Linux kernel, I've for a while now thought that they are probably doing a little bit of malicious compliance sort of thing here because they, you know, they have these long-term support kernels and hardly anybody was using them. So they started pulling the plug on that. And then shortly after they did that, they started with the idea that every bug fixed inside the kernel is a potential vulnerability. So we're going to call all of them CVEs, whether there's really any known way to exploit them or not. And because of things like the EU Cyber Resilience Act, you can't run software with known CVEs. And so they're kind of forcing everybody to run newer kernels.

Jonathan Bennett [00:07:01]:
or use actual LTS kernels. It's, yeah, it's kind of funny. It's been fun to watch.

Ken McDonald [00:07:06]:
And probably about the time they started doing that's when the number of CVEs started actually climbing.

Jonathan Bennett [00:07:14]:
And then of course you do have the AI tooling has made it a lot easier, one, to find bugs, and two, to sort of draw a line between here's a bug and here's the way that you might be able to exploit it. So you can just, you can set the tooling loose on it and it'll find stuff. And we're at the point now to where the AI tooling is finding real things. It's not hallucinating everything.

Ken McDonald [00:07:33]:
And hopefully it's also finding bug fixes or helping with finding bug fixes.

Jonathan Bennett [00:07:39]:
Yes, it is not as good at that, but that is getting better as well. The problem that I still find with having the AI do bug fixes is it tends to be really verbose in the comments, like more so. than it should be. And it has a tendency to write too much code for the bug fix. Like something could be a one-line change and the AI will want to extract this into a function and then fix it inside the function. And so you end up with like a— I saw this just the other day. You end up with like a 45 or 50-line fix when it could have been 1 or 2 lines. Yeah, it's overeager.

Rob Campbell [00:08:19]:
I didn't catch, did you guys, the story last week about Linus using AI to fix a bug in the kernel?

Jonathan Bennett [00:08:26]:
I think we did. I think we covered it, if I remember correctly. But yeah, he, he, he, there was a problem that ended up being one of those one-line problems, but was, as many times bugs are, it took a while to find out exactly what the one line was, like where were things going wrong. And he did not want to have to fight with it himself. So he had the AI, you know, it's like, okay, I think the pattern that he was using was, hey, you know, Claude or AI, whichever tool he's using, Here's the problem I'm seeing. Go to in the code where you think this could be caused and add debugging code and then reboot and get the problem to show up again. Okay, here's what the debugging code showed. Go to where you think the problem now is and add debugging code.

Jonathan Bennett [00:09:09]:
And he said he had to go through that loop about 12 different times before they finally honed in on the spot.

Rob Campbell [00:09:13]:
Well, the funny part about that story, if you touched on it last week, was how AI basically told him, It's impossible to fix. And he was persistent.

Jonathan Bennett [00:09:24]:
Yes. Yes.

Jonathan Bennett [00:09:26]:
Which is funny.

Ken McDonald [00:09:27]:
So the AIs aren't as stubborn as some of us are.

Rob Campbell [00:09:30]:
Well, it's funny. I've never had AI tell me anything wasn't possible. It just kept giving me wrong answers over and over again.

Ken McDonald [00:09:36]:
Yeah.

Jonathan Bennett [00:09:37]:
And maybe he's using— I guarantee you that Anthropic and OpenAI and all of those companies are just like, Mr. Linus Torvalds, please use our Frontier model, right? All the tokens you want are yours. Please just, you know, every once in a while mention our name. We would thank you, right? Like, that's got to be the attitude. So he's got access to, you know, Frontier models, right? He's using—

Rob Campbell [00:10:03]:
I'm sure.

Ken McDonald [00:10:03]:
Multiple Frontier models.

Jonathan Bennett [00:10:04]:
Yeah, yeah. But like, he's got Fable 5. He can just— I guarantee you they give him unlimited access to Fable 5 and he can just turn it on. And you and I, we would not use Babel 5 for bug checking code because that gets expensive. So there you go. All right. Let's take a look at Chromium. What's new in Chromium, Ken?

Ken McDonald [00:10:31]:
Well, Jonathan, this week, Bobby Barisal, Michael Larabelle, and Saurabh Rudra wrote about Chromium developers adding experimental Flatpak packaging support for Linux. Now, Michael says this is an exciting development. According to Surov, it's a small addition, basically a commit sitting behind a disabled build flag, but it's the kind of change worth keeping an eye on if you've been wanting an official way to run Chromium or even Chrome through Flatpak on Linux. Google's browser team member, Tom Anderson submitted the patch explaining, add experimental Flatpak packaging in chrome/installer/linux to facilitate testing restricted sandboxing configurations and extending existing XDG portal support. This is not a commitment to officially support Flatpak packages. Now the patch does map app IDs for both Chromium and Google Chrome. In the case of Chromium, it looks like it's going to be org.chromium.chromium. And of course, Google Chrome would be com.google.chrome.

Ken McDonald [00:11:54]:
So a Chrome Flatpak could realistically follow the same path. Currently, if you want to install Chromium as a Flatpak, The community-maintained build on Flathub and ungoogled Chromium are the most accessible options. According to Bobby, it would also give Linux users one more straightforward way to install Chromium or Chrome alongside the existing unofficial Snap or the deb and RPM options. Bobby also points out Flexpak's downsides. Flatpak apps tend to take up more disk space than traditional packages since they often ship their own libraries instead of sharing what's already on the system. I do recommend reading the articles written by Bobby, Michael, and Surov that are linked in the show notes for all the details that they share.

Jonathan Bennett [00:12:49]:
Yeah, interesting to see this. So this is a community effort, right? This is not anything from official Google.

Ken McDonald [00:12:56]:
Correct. This is to the Chromium project.

Jonathan Bennett [00:13:00]:
Well, okay. But still, the Chromium project is primarily Google. So I'm trying to draw a line between the Chromium project.

Ken McDonald [00:13:11]:
It's not to Chrome itself.

Jonathan Bennett [00:13:13]:
I understand that. But Chromium is also primarily Google. It is the open source project, but there are a lot of @google.com email addresses that write code for that as well to include Tom Anderson's.

Rob Campbell [00:13:27]:
Either way, I can appreciate them going to a real, like, acceptable universal package manager as opposed to this, you know, Snaps Ubuntu-only thing that they've been doing. Oh, that's nice to see that on Flatpak or potentially on Flatpak.

Jonathan Bennett [00:13:45]:
So Tom Anderson is thomasanderson@chromium.org. I don't know if he is a Googler or not. Oh, interesting. One of the CC names is Rafael Kubo da Costa, kubo@igalia.com. Another name that we recognize and follow. A lot of people at Chromium.

Jonathan Bennett [00:14:14]:
Yeah.

Jonathan Bennett [00:14:14]:
So unclear whether this is coming down from Google up above or is more community-led through Igalia. I don't—

Ken McDonald [00:14:22]:
or maybe just a personal project for Tom.

Jonathan Bennett [00:14:27]:
Maybe. I bet somebody's paying for it. I would suspect.

Ken McDonald [00:14:33]:
Which would be even better for him.

Jonathan Bennett [00:14:35]:
Sure. Yeah. No disagreement there. We like when people are willing to pay for open source. Makes everybody's— it's kind of nice for open source developers to be able to pay their mortgages. It works out really well. I must say, I'm a fan of it. I'm in favor of it.

Jonathan Bennett [00:14:51]:
All right. We're going to take a quick break and then we're going to come back and we're going to talk more about Flatpak because there is more going on in that world, more around funding too. So don't go anywhere. We'll be right back. So I teased it. There is some news about Flatpak. And that news is that the Sovereign Tech Agency is doing some investing into Flatpak. This is a German organization and they are pushing more than half a million, more than €500,000 over the next 2 years to get Flatpak better sandboxing and a few other things that they are working on.

Jonathan Bennett [00:15:33]:
I think we've talked about this before, but Sovereign Tech Agency has previously done things with GNOME and some Flatpak. One of the main things that they're doing with Flatpak this time around is making it work better with Pipewire, getting the portaling working a little bit better so that you can run something in Flatpak and be able to get your PipeWire connected to it with the appropriate permissions. I think there'll be a pop-up that asks if you want to do this, that sort of thing. They're also doing some network isolation features in Flatpak and a new portal for spell checking and writing assistance, all kinds of interesting things, even looking into a password autofill for your Flatpak applications. So really taking the Flatpak experience and sort of making it a modern and polished experience for the Linux desktop, doing it securely and able to bring some of these modern conveniences. I mean, spell check's been around for forever, but I assume this will mean things like LLM-powered spell checking now is on the table and those sorts of things. But yeah, a really, really interesting thing to see, particularly this group out of Germany working with Flatpak and taking a look at the sandboxing inside of it. I was particularly interested because something I've been tracking for forever is OBS and being able to properly do video streaming through PipeWire with OBS on Linux.

Jonathan Bennett [00:17:08]:
And one of the things that's been missing there for forever is the proper portal support. So maybe this finally gets us a step closer to that. Unfortunately, I went diving today, earlier today, at like the OBS 33 and OBS 33.1 to-do list, which they do actually have publicly published. And there is a Linux Pipewire item on there, but it is not for the thing we are waiting for. Adding support for a couple of different video codecs. So, I mean, nice to see that people are aware that it exists and they're working on it, but still not the big one yet. Not the one that we're all waiting for.

Ken McDonald [00:17:51]:
Bad. Yep.

Jonathan Bennett [00:17:52]:
Eventually, one of these days.

Ken McDonald [00:17:59]:
I like that wizarding, but I'm traveling in this system. I don't need a login.

Jonathan Bennett [00:18:07]:
Yeah, fun stuff. All right, Rob, I saw this story, multi-kernels. I like this idea. I want this to be a thing. What's, what's going on here?

Rob Campbell [00:18:20]:
All right, so if you think running the Linux kernel is good, what would you say to running 2 Linux kernels?

Jonathan Bennett [00:18:29]:
Even more better.

Rob Campbell [00:18:31]:
So about a year ago, I'm pretty sure we talked about an interesting project that wanted to let multiple Linux kernels run side by side on the same physical computer. I guess you can do that in a VM, but that's a much different thing than what we're talking about. So at that time, it was mostly a proposal and some early code. Now, Multikernel Technologies has reached a major milestone with first public release of Multikernel Linux Tree called MKLinux 7.0-MK2. The basic idea is that one physical server can run several independent Linux kernels at the same time. That may sound like virtualization, as I mentioned earlier, But also, as I mentioned, it's not quite the same thing. With a virtual machine, you normally have a hypervisor dividing the hardware between several virtual computers. With containers, the applications are separated, but they all share the same Linux kernel.

Rob Campbell [00:19:44]:
Multikernel takes a different approach. One Linux kernel starts as the host and manages the system's processors, memory, and PC devices. It can then use Linux's existing kexec technology to start additional kernels. Each of those kernels receives its own dedicated processor core and memory and runs directly on the physical hardware, not inside a traditional virtual machine. That could allow a server to run a database under one kernel and an AI or GPU workload under another. I wonder if maybe that could be used for containers. You could actually have different kernels running different containers. Each workload would have its own kernel and dedicated resources, reducing the noisy neighbor problem where one application affects the performance of another.

Rob Campbell [00:20:43]:
It could also allow organizations to use different kernels for different jobs, a real-time kernel, could run on a real— you could run a real-time kernel while ordinarily ordinary applications continue running under a general-purpose kernel on the same machine. There are some potentially interesting security benefits as well. And I know we might— I mentioned all these, but it's been a while, so I'll keep going, mention them again. For example, a sensitive application could be placed on its own kernel instead of sharing a kernel with every other container on the system. The company is also working on live kernel updates where a new kernel could potentially take over without shutting down the entire server. Of course, this is not something most of us will install on Linux desktops next week. The first release only supports x86-64 hardware, and this is primarily aimed at cloud providers. AI infrastructure, large servers, embedded systems, and organizations operating their own hardware.

Rob Campbell [00:21:48]:
There are also plenty of questions still to answer about hardware compatibility, resource management, security isolation, and whether the performance gains justify adding another new layer of complexity. But this is why the public release matters. Last year, multi-kernel was an interesting idea, and now it's becoming It's becoming more than that. You know, today there's a public Linux kernel tree source code management tools, something developers can actually download and test. It may never replace virtual or containers, and it probably, it's probably not supposed to. Instead, it could become another option for specialized workloads. You know, it's still early, but Linux may be moving from one kernel managing an entire computer to several kernels. And, you know, while I was doing this, it's not in my notes, but one thing I just thought of could be a use case is, you know, for gaming, for the kernel level anti-cheat.

Rob Campbell [00:22:55]:
So just think about it. You know, one scenario people are like, well, maybe you can provide a closed kernel. that you have to use to allow the kernel anti-cheat. And people are going to be against that. And you can't ever really have a true secure kernel anti-cheat using the current kernel. But maybe you could have an additional closed kernel that works with anti-cheat. So that way, kernel-level anti-cheat games could still work on Linux. I don't know if that's feasible, possible, a good idea or not, but it might be one way to bring the rest of the games to Linux.

Ken McDonald [00:23:39]:
Hmm.

Jonathan Bennett [00:23:40]:
It could be. This is interesting to look at. I'm reading the Linux kernel mailing list message on it right now. And then they've got links over to multikernel.io is apparently where they're working out of. Yeah, it actually, I've always found these to be like interesting ideas of doing multiple kernels. I've seen some crazy things over the years. Like I think once upon a time that you could run the Linux kernel as a userland program from within Windows, some crazy things like that. Just, you know, I don't know that any of them were practical, but just the fact that you could was neat.

Jonathan Bennett [00:24:19]:
This feels immediately to me kind of like that, that like it's just interesting because you can. And then there may be some performance reasons to do it. So yeah, I'm reasonably excited about this. I think it's very cool.

Rob Campbell [00:24:34]:
Yeah, I think the security, maybe the gaming scenario, I think some of those could be some of the—

Ken McDonald [00:24:39]:
Did you look over the tests that he had done in his release announcement?

Jonathan Bennett [00:24:48]:
I saw over at multikernel.io, there is a There's a series of tests and the amount of time that things took. And yeah, it looks pretty, pretty impressive for some of these, like, double performance cases.

Ken McDonald [00:25:07]:
But yeah. Yeah.

Jonathan Bennett [00:25:12]:
Really pretty interesting. kexec is something else I've not ever really played with, but it's always been interesting. I need to figure out— I need to try doing like a kexec reboot and just see how much faster it is. I wonder if there are any distros that do kexec reboots by default. It would be fun.

Rob Campbell [00:25:30]:
Make one.

Jonathan Bennett [00:25:32]:
No thanks. I have enough on my plate.

Rob Campbell [00:25:33]:
Oh my goodness. Maybe you could make a utility.

Jonathan Bennett [00:25:41]:
Yeah, I did see at least a script or two. So you can do it from within other distros like Fedora and such. It's just, you know, it's, it's, you know, if you're, if your thing is like speed, we want this to be super fast, like Kexec reboot. Yeah, totally.

Ken McDonald [00:25:56]:
I can see where it could come in handy if, depending on if you're a developer, uh, working on a, uh, creating a video or, uh, audio project.

Jonathan Bennett [00:26:11]:
Well, I mean, even if you're working on drivers, And you need to be able to, you know, swap your kernel out really quick to be able to do tests. Anyway, we've got, we do have some news about audio stuff. And this one was not on my radar until Ken picked it up. And so I was pretty excited to see that he's going to talk about it. We're going to talk about the new Ardour release. We're going to first take a break though, and we'll get to it right after this.

Ken McDonald [00:26:36]:
Well, Jonathan, you're absolutely right because this week, Bobby Borisov and Marcus Nester wrote about the latest version of the open-source digital audio workstation that you and I both love, Ardour version 9.8. It introduces initial support for musical keys and scales, improved recovery of recordings after crashes, enhancements to clip recording, and many fixes. Now, according to Bobby, the headline addition is the new keys and scales functionality. Ardour can now visualize notes that fall outside a selected scale and optionally prevent users from creating them while composing or improvising in a specific musical key. According to Marcus, Ardour 9.8 also brings improvements to Session recovery for audio recordings in case the system crashes while Ardour is recording, keeping the data loss to 5 seconds tops. Improvements to clip recording guaranteeing at least a 2-bar count-in with a countdown displayed on the screen in the clip editor, and a new option in MIDI Tools to create arpeggios. The MIDI Tools panel has been moved into a scrollable area, allowing the editor to remain usable at smaller sizes. Other improvements include latching the record enable control when using a transport master and translating startup profiling messages.

Ken McDonald [00:28:21]:
You can find even more details by reading Bobby and Marcus's Markus's articles that I have linked in the show notes.

Jonathan Bennett [00:28:30]:
Yeah, super cool. I gotta pull my stuff back out and play with Ardour again with the live music making thing.

Ken McDonald [00:28:36]:
What version are you currently running?

Jonathan Bennett [00:28:39]:
I think it's 9.7, I think is what I'm on. One of the— there's been several 9.7 releases. Do they do some bug fix releases?

Ken McDonald [00:28:51]:
But yeah, I think I'm running a 9.7 version that came out with Ubuntu Studio 24.06 or 26.04.

Rob Campbell [00:29:03]:
Yeah. I don't know.

Jonathan Bennett [00:29:09]:
I probably, I probably also have like an old 8.something or other installed. It seems like you very easily get a bunch of different Ardour installations on the same computer. I think probably because I've got one through the package manager. And I think package manager on Fedora, they even have like, you can install the 7-dot series. They have like Ardour 7, or you can install Ardour 8. And then, you know, I also have the subscription to Ardour. So I'll download one from there and it'll automatically clean up if you remember to tell it to do so. So I guess one could—

Ken McDonald [00:29:42]:
If you don't, it leaves them.

Jonathan Bennett [00:29:43]:
One could argue about how automatic that is. But anyway. No, during the installation script, it'll look for some that are left behind and offer to clean those up for you. But I think now when I go to run Ardour, it gives me at least 3 different options of different versions, which, oh, because I have some Flatpak as well. That's the other way that you get them installed. You do Flatpak install.

Rob Campbell [00:30:03]:
Why so many though?

Jonathan Bennett [00:30:05]:
Because I enjoy the program and I fiddle around with it and be able to talk about it on shows like this.

Ken McDonald [00:30:11]:
And in some cases, he uses it for Mint. For recording shows like this.

Jonathan Bennett [00:30:15]:
Not this one anymore, but for FLOSS Weekly, I still, well, I record with OBS. I do the audio edit inside of Ardour. Works really well, particularly if we have audio problems. Ardour has the toolkit to be able to go in and clean them up and fix it. Really has been the way to go. All right. Let's talk about Christmas.

Ken McDonald [00:30:41]:
So— Already?

Jonathan Bennett [00:30:42]:
Already. No, it's not too soon. I wish it were sooner.

Rob Campbell [00:30:47]:
Halloween first.

Jonathan Bennett [00:30:49]:
Yeah. That particular note has special meaning in my family because one of my family members shares a birthday on Halloween. But no, we are talking about, actually we're talking about kernel 7.4 and it is on the schedule. You know, reading the tea leaves, looking at the calendar, probably going to come out the last couple of weeks in December. And looking at the sort of tea leaves of the Linux kernel mailing list and staging and how all of those things work, it looks like AMD is going to turn on HDMI fixed rate link, FRL, by default in 7.4. Which essentially means that we are all going to get as our Christmas present this year, a Linux kernel that supports HDMI 2.1 on our AMD cards. And that particularly makes me happy because that means that I can go dig out my DVI to HDMI dongle that has caused me other problems and throw it away and just use HDMI to connect my TV to the, to the computer, and I will once again have VRR and high refresh rate and HDR and all of those things that you're supposed to be able to do with HDMI 2.1 that I've not been able to do for a very long time. Uh, I'm looking forward to it.

Jonathan Bennett [00:32:14]:
It will be very nice. Um, and for those that may not remember the, the issue here, AMD had all this working and the HDMI Consortium which is, you know, essentially the mob, the tech mob, came and said, you know, you can't do that without paying us a whole bunch of money. And AMD was like, we're not paying you money for our Linux drivers. We already paid you money for our hardware. And that's just kind of where it all sat. And it's unclear what happened. You know, there have been theories that Valve stepped in. Although, in thinking about this, I'm not sure that Valve is a bigger company than AMD.

Jonathan Bennett [00:32:52]:
So it may just be that AMD put pressure. I don't know. But anyway, the HDMI Consortium apparently backed down and AMD is pushing patches once again and 7.4 is where it's going to land. So Merry Christmas, we hope.

Ken McDonald [00:33:12]:
Let's get through Thanksgiving first.

Jonathan Bennett [00:33:16]:
It gets closer, you know, consumerism. Christmas gets earlier every year.

Rob Campbell [00:33:20]:
Let's get past, for those in the US, let's get past Labor Day first.

Ken McDonald [00:33:24]:
So it's Hello Mass? Indeed.

Rob Campbell [00:33:29]:
Uh, that's pretty cool.

Ken McDonald [00:33:30]:
Start celebrating the rest of the last quarter of the year, basically.

Rob Campbell [00:33:35]:
It's always depressing when there's features out there, hardware features that work on other systems and not ours.

Jonathan Bennett [00:33:43]:
Indeed.

Ken McDonald [00:33:43]:
And here I thought it was just because I had an older system for a long time.

Jonathan Bennett [00:33:48]:
Yeah. All right. So I said it sort of off the cuff. I bet you AMD is bigger than Valve. This is an AI overview, but it's probably pretty accurate. Um, Valve is estimated private valuation $8 billion, billion with a B, a bravo, $8 billion. Uh, AMD's actual market share, because they are a traded company, is $760 billion with a B. So yeah, AMD is bigger than Valve.

Ken McDonald [00:34:22]:
By a smidgen.

Jonathan Bennett [00:34:24]:
Several smidgens. Yeah, AMD has some, has more weight to throw around than just Valve does. So now maybe they did work together on this. I don't know.

Ken McDonald [00:34:37]:
I bet they weren't the only ones behind trying to get the HMDI Alliance to—

Jonathan Bennett [00:34:43]:
I know there were a lot of us that were just Irate over that. Yes. I'm never buying anything with an HDMI port in it again.

Rob Campbell [00:34:55]:
Ah!

Jonathan Bennett [00:34:55]:
Good luck with that, but—

Rob Campbell [00:34:57]:
And they don't have to make them anymore eventually.

Jonathan Bennett [00:34:59]:
Yeah. Starve them. Oh, all right. Shall we continue on? I think Rob is up next.

Ken McDonald [00:35:07]:
Sure. I always like to hear what Rob has to say.

Rob Campbell [00:35:11]:
I know you do, Ken. That's why I'm here for you.

Jonathan Bennett [00:35:13]:
So what's the big update?

Rob Campbell [00:35:18]:
An update for you. OpenSSL 4.0.2 has been released with fixes for 11 security vulnerabilities along with several other bugs. An OpenSSL point release may not sound like exciting Linux news, but with my background in IT and cybersecurity, it gets my attention. OpenSSL provides many of the encryption and certificate certificate functions that we depend on every day. Despite the name, modern systems generally use TLS rather than the old SSL protocol. However, OpenSSL still does much of that work behind the scenes. When you connect securely to a website, validate a certificate, use a VPN, or run an application that encrypts data, OpenSSL may be involved somewhere in that process. That means a vulnerability in OpenSSL can affect far more than one program.

Rob Campbell [00:36:18]:
Version 4.0.2 fixes problems involving QUIC client to trigger a— or QUIC DTLS certificate management and encrypted messages. The most severe vulnerabilities are rated moderate.

Ken McDonald [00:36:35]:
So this is—

Rob Campbell [00:36:36]:
it's not another Heartbleed. bleed-level emergency, but moderate doesn't mean it's not important. One vulnerability could allow a malicious QUIC client to trigger a double-free error on a server. Others could consume excessive amounts of memory and potentially cause a denial of service. You know, not every Linux system will be vulnerable to every issue. Some require specialized applications or unusual configurations. 11 CVEs does not automatically equal 11 exploits, exploitable vulnerabilities on every computer. But the bigger challenge is knowing where OpenSSL is being used.

Rob Campbell [00:37:18]:
It may be installed as an operating system package, built directly into an application, including in a container, or bundled with software from a vendor. So updating the OpenSSL package on a host may not fix every private copy hiding inside every other application. That is why software inventory and vulnerability management matter. You know, we need to know which versions are installed, which applications use them, and whether affected services need to be restarted after updating. Most Linux users should install a security update provided by their distribution rather than manually replacing OpenSSL. Distributions often backport security, so the corrected packages may not be numbered 4.0.2. Cybersecurity is not always about reacting to the next Heartbleed. More often, it is about finding an important update, understanding where it applies, and installing it before someone finds a way to make it much more of an exciting issue.

Rob Campbell [00:38:23]:
And with, you know, OpenSSL being the thing that encrypts stuff, well, you want to keep your stuff encrypted to keep yourself safe. So yeah, might as well update.

Jonathan Bennett [00:38:36]:
Yeah, something you do see sometimes is even when it's a moderate issue, when there's multiples of them in the same multiple problems together, you can chain those moderate issues together and get something pretty critical, get a real problem as a result of it. So yeah, good to see. Good to see this continuing to fix, this continuing to roll out.

Rob Campbell [00:38:57]:
Encryption is a critical part of the chainsaw.

Ken McDonald [00:39:01]:
Especially since the total list came to, by my count, 11 CVEs they had patched there.

Jonathan Bennett [00:39:10]:
Yeah, that sounds about right. OpenSSL is sort of the granddaddy of the SSL projects, right? And then you've got LibreSSL and BoringSSL and Amazon's SSL, AWS-LC, excuse me, is what they call it, are all forks of it. But OpenSSL is sort of the original, is still around, isn't it?

Ken McDonald [00:39:36]:
And still used.

Rob Campbell [00:39:38]:
Yep.

Jonathan Bennett [00:39:39]:
Yeah, so LibreSSL is an OpenBSD fork. BoringSSL is the Google fork. And yeah, it looks like they all still sort of cooperate. I haven't heard about, I haven't heard about these other ones for a while. Seems like OpenSSL is still, is still the one reigning champ as far as I can tell.

Rob Campbell [00:40:01]:
Yeah, right.

Ken McDonald [00:40:02]:
I'll just hope that I see the patches to it show up on my Ubuntu 26.04 system soon.

Jonathan Bennett [00:40:12]:
It would not surprise me if they're already there, actually. A lot of these releases get leaked.

Ken McDonald [00:40:20]:
Pushed out way before they published?

Jonathan Bennett [00:40:22]:
Yeah, leaked is not the right word, but they'll get information about them before the announcements. And so they are ready to go. It's kind of a coordinated release. So probably already ready for you.

Ken McDonald [00:40:36]:
And probably live patched.

Rob Campbell [00:40:39]:
Probably already updated.

Jonathan Bennett [00:40:43]:
Somebody offers live patching for it, I'm sure. There's a couple of different companies out there that do that.

Rob Campbell [00:40:48]:
Ubuntu has live patching.

Ken McDonald [00:40:50]:
Yep. Especially if you have Ubuntu Pro.

Jonathan Bennett [00:40:52]:
For the kernel, yeah. Yeah. So, yeah, I mean, you probably don't need live patching for OpenSSL. You probably can afford on your desktop at least to do some restarts. Right. It's not like you're a—

Ken McDonald [00:41:05]:
I prefer to do restarts.

Jonathan Bennett [00:41:08]:
Yes. Indeed.

Ken McDonald [00:41:09]:
Especially when I look and I start seeing my memory usage climbing up to 38, 30%.

Rob Campbell [00:41:17]:
Hitting your top 2 gigabits you got.

Jonathan Bennett [00:41:20]:
Yeah, you don't need to restart. You just need to close some browser tabs, Ken. You have too many browser tabs.

Ken McDonald [00:41:26]:
I did that, but I've also got a, uh, VM running with a couple of servers acting as a server for Plex so I can migrate my Plex system up to Ubuntu 24.04 on that bare metal system.

Jonathan Bennett [00:41:50]:
Well, you know what's the new hotness right now is 26.04.1. That's one of their long-term support releases, isn't it?

Ken McDonald [00:41:59]:
Yes, I could even talk about that if you'd like.

Jonathan Bennett [00:42:02]:
Well, let's have Ken do that.

Rob Campbell [00:42:04]:
I'm curious to find out more.

Ken McDonald [00:42:05]:
Well, and in fact, Jonathan, this week Bobby Borisov and Markus Nister also wrote about the first point release in the Ubuntu 26.04 Resolute Raccoon long-term support series. Now, the Ubuntu 26.04 .04.1 LTS ISO images include security patches and software updates released since April of this year. For those who want to deploy it on new computers without downloading hundreds of updates from the repositories during or after installation. Both Bobby and Markus agree this first point release is also usually especially important for users still running Ubuntu 24.04 LTS. If you are currently running Ubuntu 24.04 LTS, Update Manager will offer an automatic upgrade to Ubuntu 26.04.01 a couple of weeks after the release. This will allow Canonical time to prepare planned backports to address regressions in a recent version of Rust Core Utils. According to Bobby, Ubuntu Desktop, Server, Cloud, and Core receive 5 years of support, standard maintenance calculated from the original Ubuntu 26.04 LTS release, while the official flavors such as Kubuntu, Ubuntu Budgie, my favorite Ubuntu Studio, Lubuntu, Xubuntu, as Rob likes to say, and of course Ubuntu Cinnamon received 3 years. According to Marcus, the next point release, Ubuntu 26.04.2 LTS, is planned for February of 2027 and will use Linux kernel 7.2.

Ken McDonald [00:44:06]:
It will also use the Mesa 26.2 graphics stack from the upcoming Ubuntu 26.10. Yes, Jonathan, stonking stingray release, which is due out in October of this year. Now, both Bobby's and Marcus's articles include links to the official website if you want to download the ISO images for new installations.

Jonathan Bennett [00:44:35]:
The internet says that that is indeed Xubuntu. Xubuntu with an X.

Ken McDonald [00:44:41]:
Not Z.

Jonathan Bennett [00:44:42]:
Not a Z.

Rob Campbell [00:44:44]:
Like xylophone with an X, not a Z.

Jonathan Bennett [00:44:49]:
Like xylophone.

Ken McDonald [00:44:52]:
So it's very likely that if I've updated to that with the last update I did, you know, I've already got those OpenSSL fixes.

Jonathan Bennett [00:45:02]:
Yeah. And with Ubuntu, the point releases like that, it's just essentially a rolling release. You just update, do the update, and it pulls out the new packages in. They do probably a new ISO for the .1 release is really what this means.

Ken McDonald [00:45:18]:
Yep. And then they'll do another ISO with the .2 release. So wait till Ubuntu 26.04.4. then download the ISO and do a new installation from it.

Jonathan Bennett [00:45:36]:
That's going to be a while.

Ken McDonald [00:45:38]:
Yes, it is.

Jonathan Bennett [00:45:38]:
A couple of years. Let's see. 2604.2 is planned for February. That's what's that, like every 6 months, something like that?

Ken McDonald [00:45:51]:
Approximately, as long as they don't run into any issues with updating.

Rob Campbell [00:45:58]:
Yeah.

Ken McDonald [00:45:58]:
Or any regressions.

Jonathan Bennett [00:46:01]:
Indeed. Indeed. All right. We've got one more story and it is not about Ubuntu, but about Debian being dragged into the future. This is my take on it. Dragged into the future kicking and screaming. And this is Debian's vote over LLM usage within the project. And they did a Debian general resolution and there were like 9 different choices.

Jonathan Bennett [00:46:35]:
And it was, so here were their options when everybody voted. It was ban LLM contributions from Debian via the social contract, allow AI-assisted contributions with conditions, reject LLMs as far as practical and update the code of conduct, Accept AI contributions for Debian-specific work. Responsible use of generative AI. A cautious approach to generative AI. Choice 7, Debian is created by humans. 8, avoid the use of LLM. Climate destruction is a deal breaker. Or 9, none of the above.

Jonathan Bennett [00:47:16]:
And of those choices, the— Drum roll, drum roll. Drum roll. Yeah, they went with number 5. responsible use of generative AI. Now, the problem, as one often has with a statement like that, is who gets to define what responsible means in this case? That's a— yeah, the jury is still a little bit out on that. But there is quite the statement now from Debian. And the, uh, let's see, I'm looking for the actual, um, looking for the actual statement here. Uh, they did, of course, of course, the nerds at Debian did all kinds of math with the voting.

Jonathan Bennett [00:48:05]:
That's hilarious.

Rob Campbell [00:48:08]:
Who got to vote for this? Anybody, or was this like a board or group or?

Jonathan Bennett [00:48:14]:
It looks like there were 250 to 300 votes, so probably not everyone. I'm not sure exactly who gets to vote in Debian. It may be the Debian maintainers. I'm not 100% sure.

Rob Campbell [00:48:34]:
Oh, it sounds like a bigger group than some of these others probably had when they made their small group votes on AI.

Jonathan Bennett [00:48:45]:
It is Debian developers. Yeah, so this is a group, the vote of Debian developers. And I was trying to see which one came in second. It looks like a fairly close—

Rob Campbell [00:49:03]:
Is it a complete different swing or is it a trend? From one end to the others. I'd be curious.

Jonathan Bennett [00:49:12]:
Looks like option 6 was the next. So either a responsible approach. Second up was a cautious approach. And then 4, 274 was accept AI contributions for Debian-specific work. So essentially the accept them, Won the day quite handily, it looks like. I wonder if I can tell how many people voted for— number 1, it looks like, was a pretty low vote. Only 100 and change voted to ban it outright. Yeah.

Jonathan Bennett [00:50:01]:
And I'm not sure that I am reading this 100% correctly. Dropping option 3. It looks like option 3 was the least popular, which was reject LLMs as far as practical and update the code of conduct. Yeah. So the— and I suppose that makes sense. The least popular option was to entirely outlaw them from the project. All this to say, I think it's inevitable. I have seen here, I'll bring you guys back in.

Jonathan Bennett [00:50:38]:
I've seen a couple of efforts to go out and fork projects when AI started getting added to them. And there are some people that are out there going like, we want only human, a version of VI that's only human-made. We want a version of this project and that project that's only human-made. And it's like, If you want to, sure. Like, it's open source. You get to do that if you want to. You can absolutely fork it at that point, but you're going to fall so far behind because you can just, you can write code so much faster. Now, obviously, you want to have some standards so that you're not just pulling in everything that everybody's a robot thinks is a good idea because that's too— I had to review some code earlier today and I was like, what?

Ken McDonald [00:51:23]:
Where did this come?

Jonathan Bennett [00:51:24]:
Who thought this was a good idea? It's like, oh yeah, that guy used the LLM and— We pulled it in before we should have.

Rob Campbell [00:51:30]:
It'd be interesting to see a comparison, somebody that, one that forked because they wanted human only. And then, you know, 10 years down the road, let's compare where those 2 are, where the human only and the one that has responsible AI.

Ken McDonald [00:51:46]:
Just go back and look at code you wrote from 10 years ago and tell me how much different from an AI-written code it is. Sounds to you now?

Jonathan Bennett [00:51:58]:
Let's see, what was I doing 10 years ago? I was writing okay code 10 years ago. I would have been doing probably at that time mostly C code. That would have been when I was working a lot with FWNOP. And so that was paying a lot of attention because that was a security product. I'm still proud of some of the code that came from my fingertips at that particular point in life.

Rob Campbell [00:52:20]:
Well, I would say from my perspective—

Ken McDonald [00:52:23]:
But I mean, just looking back at it today. Yeah, right.

Rob Campbell [00:52:27]:
If I look back at mine, you know, from 10 to 20 years ago, I don't know that I'm that much better today than I was then. Or, but what I would see if I compared that to AI is how much more I could have coded. You know, if I think about the weeks, months I put into coding things back then when I could do the same thing with some AI assistant in, you know, a week, a few days.

Jonathan Bennett [00:52:58]:
But so here's, here's an interesting take that I've got on this. I am glad that AI did not exist back then because I had to learn some lessons the hard way, and I am a much better AI coder now because I understand how things work under the hood, I am very glad to have learned C the hard way.

Rob Campbell [00:53:20]:
If you want to see, hear how AI works under the hood, I'm going to plug Steve Gibson here. He's had some good series lately, really deep diving into kind of AI under the hood.

Ken McDonald [00:53:33]:
Well, Steve's a good one to go to to learn how a lot of things work under the hood.

Jonathan Bennett [00:53:38]:
Yeah, that's something he's really particularly good at. breaking it down so that even, and particularly just listening to him, like that's something that's difficult to do too. And he doesn't have a whiteboard that he uses. No overhead, no transparencies, no PowerPoint presentation. So he's pretty good at that.

Rob Campbell [00:53:58]:
It was after their DEF CON trip, I think while flying there, he was reading a white paper or something, something about it.

Jonathan Bennett [00:54:06]:
Yeah, unfortunately the guys went to Black Hat. And I went to DEF CON. And so we missed each other by about a day. I was like, hey, we're here, you're here. And they're like, you're flying in the day we're flying out. I'm like, oh.

Rob Campbell [00:54:18]:
Not at DEF CON, but yes.

Ken McDonald [00:54:19]:
But going back to your original question about who's going to define responsibility, my recommendation is let Noah Webster define it.

Jonathan Bennett [00:54:31]:
Yes, sure. But that's also not actually an answer.

Rob Campbell [00:54:38]:
I mean, really, I think if you take a look at the other answers comparatively, you could definitely narrow it down what people are thinking responsible is because it's, you know, more than this answer, less than this answer. So it's somewhere in between one of those answers at least.

Jonathan Bennett [00:54:57]:
Well, I mean, so I think, I think the real answer there is they want high-quality code contributions the exact same way that they wanted high-quality code contributions before AI was a thing. And it's just, you now have a new tool. But if you let the new tool allow, you know, if your use of the new tool results in lower quality or other problems with your contributions, well, then you're not being responsible with the new tool.

Rob Campbell [00:55:23]:
I think maybe that's really what it boils down to. Keep a person in the loop and still have quality code.

Jonathan Bennett [00:55:30]:
Exactly. Exactly. It was, I mean, let's be honest, it was possible to write bad code before there were AI.

Rob Campbell [00:55:37]:
Yeah, I wrote some, I wrote some really bad code back in the day.

Jonathan Bennett [00:55:42]:
Yeah, me too. Me too.

Rob Campbell [00:55:44]:
I was, I was great at writing code that had SQL injections all over the place. And I was just—

Ken McDonald [00:55:51]:
Was that intentional?

Rob Campbell [00:55:53]:
No, I was just lucky no one took advantage of them until one day. Um, I had somebody, I don't know, call them an extortionist, call them a white hat. Whatever. He found these online and sent me an email and showed me some of my database stuff. I'm like, whoa. And he's like, well, I'll give you— pay me some money and I'll tell you. I said, I'm just a small guy. I gave $50, $25 now, $25 after.

Rob Campbell [00:56:22]:
And then he told me all the things. So it was relatively cheap and I learned something. I learned the lessons.

Jonathan Bennett [00:56:30]:
Absolutely. And you didn't have to write up a, what would they call that now? A database breach. You didn't have to write up a breach report and publish it. Joys of modern living.

Ken McDonald [00:56:49]:
Here's a suggestion, especially from an old man who had this done during his education is make them understand how to do it themselves before giving them the tool.

Jonathan Bennett [00:57:06]:
Yeah, absolutely. I'd agree with that.

Ken McDonald [00:57:09]:
Like, I had to learn the multiplication table before I could use a calculator.

Rob Campbell [00:57:15]:
I had to learn a hammer before I had a, um, whatever.

Ken McDonald [00:57:20]:
Uh, how many thumbs did you lose?

Rob Campbell [00:57:24]:
You had an air thing. I'm a jabberer. I completely forgot what they're called, but—

Ken McDonald [00:57:29]:
You had to learn how to use a hammer before you could use an air hammer?

Rob Campbell [00:57:34]:
I had to learn to use a screwdriver before I got a power drill. There you go.

Jonathan Bennett [00:57:39]:
Did you also do the old school crank drill?

Rob Campbell [00:57:45]:
I never had one of them.

Jonathan Bennett [00:57:47]:
I would like to have one of those. Those are cool tools.

Ken McDonald [00:57:50]:
Especially when you need to be real careful when you're drilling into something.

Jonathan Bennett [00:57:56]:
Uh, I mean, it depends on what it is. There are some tools they make now that allow you to be really careful when drilling into something, more, even more precise than those old tools were. But yeah, for, for sure. I mean, it's kind of a, it's kind of a similar deal, right? Like, I appreciate the antique tools, I would like to be able to use them, but I'm not gonna, I'm not gonna do a big project that way. I'm gonna go to my DeWalt tools and, you know, brand names.

Rob Campbell [00:58:16]:
That's a perfect analogy here. I had to use a plastic hammer before the metal hammer. Thanks to your wife there. But yeah, when I was a little kid, you know, just a little guy, I had that little plastic hammer and the plastic pegs and yeah.

Ken McDonald [00:58:33]:
Well, isn't that why as parents we buy those toys for the kids to play with?

Jonathan Bennett [00:58:42]:
I mean, on a certain level, that's what play is. It's learning how to do the real thing on a scaled-down environment where there's not as much risk.

Rob Campbell [00:58:49]:
Yeah, that's why I play those first-person shooters.

Jonathan Bennett [00:58:52]:
Preparing for the zombie apocalypse. Absolutely. Those skills are totally going to come in handy one of these days, Rod.

Ken McDonald [00:59:00]:
Especially when they're coming at you and you don't have that gun in your hand.

Rob Campbell [00:59:05]:
I'll just, I need a mouse in my hand because I don't know how to aim with a real gun.

Ken McDonald [00:59:12]:
Then you need to get to the arcades where they've got these—

Jonathan Bennett [00:59:14]:
I'll just take a mouse and I'll throw it at them. Oh my goodness.

Ken McDonald [00:59:16]:
Live simulation set up for shooting.

Rob Campbell [00:59:19]:
We are descending into madness.

Jonathan Bennett [00:59:21]:
All right, we're going to take a break and try to collect ourselves. And then we're going to come back and we've got our command line tips and then the wrap-up at the end of the show. Don't go anywhere. We'll be right back. All right, Rob's got the first command line tip. What are we looking at?

Rob Campbell [00:59:36]:
I have my command line tip. And for those watching right now, you're looking at me, but I'm going to show you the command line tip, which is Linecast. For those watching, uh, Linecast, you can view various things on it. It's kind of interesting. First one I'm going to show you is Linecast Space Radar. And for that, it picks up my area where I'm at, and it's showing basically— it showed me a radar where the clouds are, and it's pretty clear around where I am. So I mean, not a, not a lot of clouds to see there, but fortunately it's not completely clear skies. So I do have something that you can see for those watching.

Rob Campbell [01:00:19]:
And then we got, uh, what else we got? Weather. Yeah, weather's another one. So Linecast Weather, um, shows you basically forecast, highs, lows, a little graph across the screen of the temperatures, times of day. And fun stuff like that. And then there's also Sunshine. Linecast Sunshine is another one, and basically it's the, the day-night cycle. Uh, Linecast, I think, Map was another. And there's no Maps.

Rob Campbell [01:01:00]:
Well, yeah, there we go. Maps. Linecast Maps. And that's showing a map that I can zoom out or I can scroll around. I guess that's not a very great map, but there are a variety of things. There's a dozen maybe different linecast things. I thought the radar one was kind of the coolest, but there's even more than just that you could do with it. So yeah, a fun little command line tool to Do stuff.

Jonathan Bennett [01:01:35]:
Yeah, that's actually really cool. I like that a lot. That's really neat. I like the mouse support inside of the terminal too. That's really cool.

Ken McDonald [01:01:47]:
Yeah, there's occasions where mouse support inside the terminal is handy.

Jonathan Bennett [01:01:50]:
Mm-hmm.

Rob Campbell [01:01:55]:
Yes.

Jonathan Bennett [01:01:55]:
And scroll, the scroll bar works and it is the time control. See, there's—

Ken McDonald [01:02:02]:
it's cool.

Jonathan Bennett [01:02:03]:
I like that a lot.

Rob Campbell [01:02:04]:
What's this moon one? There's also moon. What is that? Oh, this one's kind of neat.

Jonathan Bennett [01:02:09]:
Phases of the moon.

Rob Campbell [01:02:11]:
Oh yeah.

Jonathan Bennett [01:02:12]:
Oh, here's— I don't know what that is, but this is what the moon looks like now.

Ken McDonald [01:02:17]:
Yeah.

Jonathan Bennett [01:02:17]:
So it's— I wonder, I wonder if last night it would have shown the, uh, the, the, the live view, the live render of the eclipse. Lunar eclipse.

Rob Campbell [01:02:28]:
I don't know.

Jonathan Bennett [01:02:29]:
That would have been cool.

Rob Campbell [01:02:30]:
Yeah, I guess go back. There's a tides, uh, location. Uh, I guess that's getting about to most of it. So I guess let me, let me just quick, quick, let's see what tides is. I have no tides here. I mean, I guess there are tides. There's just not much to look at when I go to find a tide here in Minnesota, uh, because there's no tide station within 100, uh, Yeah, I guess there's just no tides around here. Um, sorry, I can't show you that one.

Jonathan Bennett [01:02:59]:
Yeah, you gotta, you gotta live on the ocean to be able to really get tides. I don't think, I don't think lakes count for tides.

Rob Campbell [01:03:06]:
Yeah, I mean, the moon's still pulling on it. It's just, I guess it's not really doing anything. It doesn't have anywhere to pull from.

Jonathan Bennett [01:03:12]:
Yeah, it doesn't have enough room to get up speed. Uh, all right, it's a, it's a cool tip though. I'll have to remember that one. I like that quite a bit. Okay.

Rob Campbell [01:03:21]:
It was a pip install.

Jonathan Bennett [01:03:23]:
Or you can run it with UVX, which is actually really cool. We've talked about UV and UVX, haven't we?

Rob Campbell [01:03:29]:
I had not heard of that. So when I saw that—

Ken McDonald [01:03:32]:
We may have mentioned it as a way to run other things, but I don't think we've actually covered what UV and UVX are.

Jonathan Bennett [01:03:39]:
Hmm.

Rob Campbell [01:03:40]:
I wasn't familiar with them. So I did not even—

Jonathan Bennett [01:03:43]:
If it's not on the list, we'll have to do that here coming up soon because that is actually pretty cool. So Ken, what do you have for today?

Ken McDonald [01:03:51]:
Well, this week I'm sharing a script that I've written that combines my last 3 commands that I command line tips into a function that will mount or unmount one of my cloud drives. Let me go ahead and bring up my screen. Here's the script itself. As you see, the script actually contains 2 functions. This is the main function. It basically acts to toggle between either creating the mount point and mounting one of my cloud drives that I have, or unmounting it and removing the mount point using the fuser mount options or the make directory to make the mount points and rclone mount. Which I covered last week.

Jonathan Bennett [01:04:45]:
Mm-hmm.

Ken McDonald [01:04:47]:
And then I've got a second function that I use to help with doing tab completion with the cloud mount function, the main function. And what this does is it basically takes and creates the options that get displayed. When I do a double tap. For example, let's say I take and type cloud mount. Are y'all able to see the very bottom line?

Jonathan Bennett [01:05:26]:
Yes, we can see your prompt.

Ken McDonald [01:05:30]:
Okay. So if I type cloud mount down here, then there's a 3rd line which goes back to the very first one I Demonstrated, uh, the complete command, which lets it do that. So now say I want to do a Dropbox. I copy that in there, hit that, and it mounts it. And I can confirm that it is mounted. By typing, doing a list of the directory. And if I want to unmount it, I just do that. And now if I try to do a list, it does that.

Jonathan Bennett [01:06:22]:
Cool.

Ken McDonald [01:06:24]:
And I'll post that in the show notes.

Rob Campbell [01:06:27]:
Why don't, why don't you publish that to GitHub? People just download it.

Jonathan Bennett [01:06:33]:
It probably makes sense as like a GitHub gist or something. Yeah, you can put it in the show notes too. That's cool.

Ken McDonald [01:06:39]:
Because I was debating on whether or not to put my whole list of functions on GitHub and making it public.

Jonathan Bennett [01:06:48]:
Yeah, absolutely. That'd be cool. Be a good tool to get to. All right. I've got a quick one to cover. I was looking through things that we have not ever talked about. And one of the ones is the size and readelf commands, which are all about taking a look at a binary and figuring out what is going on inside of there. So let's see if we can do a quick screen share here.

Jonathan Bennett [01:07:20]:
Sure. So let's just say we want to look at Git. And of course, which tells us where Git is at. And then you can do size and then that location, /usr/bin/git. And size is going to tell you essentially that binary, the size of the different regions inside of there, which may not be very useful. But there is another command that goes a little bit deeper. Along with that. So there are a few different flags that you can do with readelf.

Jonathan Bennett [01:07:59]:
Like the -h will give you information about the headers. So this Git is an ELF64. It is little-endian. We are on technically a Unix System V machine. even though it's Linux. It is AMD x86-64, some various things like that. You can do a -l and get information on the headers and then also the segments. Yeah.

Jonathan Bennett [01:08:33]:
These 2 functions useful, you might ask, what are they good for? I would say that the main thing is if somebody gives you a file and you don't know what it is and you don't want to just blindly execute it, well, You can run the size command, you can run readelf and get at least a little bit of information about what's in there. I've got a link in the show notes off to actually a Linux Journal page from 1995, a long time ago, but still very apt and appropriate. And they've got some, I think they've even got a demo of like compiling a very simple C program. And then running it through these tools to take a look at the results on the other side. And so super useful for essentially understanding how executables work and beginning to learn your way around what happens when you run that program from the command line. So cool stuff. All right, I think that is it. I know the guys have a couple of things that they want to plug.

Ken McDonald [01:09:38]:
We'll let—

Jonathan Bennett [01:09:39]:
We'll let them do that. We'll let Rob go first. What are you looking for in the world, Rob? What do you want to let folks know about?

Rob Campbell [01:09:46]:
All right. So I actually have something a little besides my usual. I'll start with my usual. For those who want to come connect with me, you go to my website, robertpcampbell.com. There's links to my LinkedIn, my Twitter, my Bluesky, my Mastodon, and a place to donate coffee. But also on that page, if you're interested, there is a place, if you scroll down or click the memoir, to, uh, buy a copy of my new book. It is, uh, it's a story about me, trailer park to technology leader, from rags to riches is crossed out, my dream job. Um, and it's, uh, it is, uh, about my path from being a poor child to, uh, To become a technology leader.

Rob Campbell [01:10:35]:
There is even a chapter on there on how, on the start of the Untitled Linux Show. So there's even that in there if you want to buy it just to read that chapter. But now there's a lot of good, I think there's a lot of good stories about my life. But, you know, I'm biased. I, I like my life. But anyway, um, yeah, so if you want to check it out, go to my website, search for it on Amazon. It's available on Amazon. Or go to my website, click the link, buy on Amazon.

Rob Campbell [01:11:10]:
And, um, it is available on Kindle, softcover, and hardcover.

Ken McDonald [01:11:17]:
Cool.

Jonathan Bennett [01:11:18]:
I will, I will have to start introducing you as Rob Campbell, my published friend.

Rob Campbell [01:11:25]:
And I'm debating on doing an Audible or not. I don't know if I want to pay anyone to do it. So I don't know if I want to read it all out either, but I'm thinking about it. Maybe a Christmas release.

Jonathan Bennett [01:11:38]:
Yeah, that'd be fun. Cool. That's neat. I'll take a look at it. Very cool. All right, Ken, you have something big too.

Ken McDonald [01:11:49]:
Yes, I do. And I want to invite everybody to join Markus Nestor since he's inviting everyone to join him in celebrating Linux's 35th birthday. And I've got a link to the article in the show notes. So, but I definitely recommend reading. And Linux, happy birthday.

Rob Campbell [01:12:15]:
Where is he? Happy birthday. Where's he having the party that we can join him at?

Ken McDonald [01:12:21]:
Well, go to his website to find out.

Rob Campbell [01:12:23]:
Oh, okay.

Jonathan Bennett [01:12:25]:
I wonder if there is a party somewhere.

Ken McDonald [01:12:27]:
There's always a party somewhere.

Jonathan Bennett [01:12:29]:
Well, there's a— yeah, true.

Rob Campbell [01:12:32]:
It's always Saturday somewhere.

Jonathan Bennett [01:12:35]:
No, it's not. That's not actually true. I guess that doesn't—

Rob Campbell [01:12:38]:
I guess the 5 o'clock somewhere does not work the same with days of the week.

Jonathan Bennett [01:12:42]:
No, not quite. Not quite.

Rob Campbell [01:12:45]:
Hey, I like a lot of time travel books. So in those scenarios, it's always Saturday somewhere.

Jonathan Bennett [01:12:51]:
It's always Saturday on some timeline. Oh, that's great.

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

Jonathan Bennett [01:12:56]:
Awesome. Thank you guys both for being here. It's been a lot of fun. The one thing that I will plug is, of course, over at Hackaday, you can find, and that's it.

Rob Campbell [01:13:04]:
That's the logo right there.

Jonathan Bennett [01:13:06]:
It was where Floss Weekly lives. And we have a lot of fun with that. I had to take a couple of weeks off for my travels, but we are back and had a great interview this past week and another one coming up. So make sure and go check that out. Other than that, just want to say thank you to everybody that's here. We appreciate it. Whether you watch us live or on the download, the audio or the video, we appreciate you being here. And we will be back next week on the Untitled Linux Show.