XIO

xWire

Posts from every feed QUEST has found across the web — blogs, news, podcasts, channels and more.

LWN.net comments

This feed contains the text of all comments posted to the LWN.net site.

Rust and massive binaries

I think dynamic linking has no real leg to stand on once you realise how bad the correctness story is for dynamically linked updated libraries, especially in languages like C++ and Rust that do have generics that do have to end up "on the wrong side" of the link boundary even in the dynamic linking case. Sure, it is convenient for the kind of security theatre the long term support distros like to perform but in practice if you want to guarantee the code actually behaves as written dynamic…

Yay finally

This is also an issue caused by the giant dependencies so many here seem to love so much. If you have one giant dependency you have to replace it all as one giant change, if you have lots of small ones it is easier to spread that out and it naturally spreads out since those don't all do their breaking updates at the same time (and many don't ever have breaking updates).

It's all about the build "environment"

The most interesting use-case for reproducing with a different package set is probably pure shared runtime data packages like ca-certificates and tzdata where there is a high likelihood that they do not have any influence on the build but nobody wants to run outdated versions.

Bounded integers make other analysis easier

On the other hand a lot of those are probably more readable as enums in idiomatic Rust. There are not actually that many cases where you have bounded integers with possible values being that limited (i.e. small single digit number of them or low double digits) that actually have no higher level named meaning for each option.

Bloatware

Also, it is not as if the kernel doesn't use plenty of threads itself. On my 24 core system right now at moderate load (load average under 20) I have about 4.2k userspace threads and 1k kernel threads (with ~450 processes).

Minimal traits needed for pattern types to be useful

I think that's beyond the minimal, personally; pub struct BoundedU32<const MIN: usize, const MAX: usize>(pub u32 is MIN..MAX) is enough of a wrapper to avoid that problem for generics (you work with the wrappers, not with the raw pattern type, and the wrappers can implement a base type function for you), and you point out the other workaround (type annotations) yourself. Remember that the goal of the minimal set is to have the bare minimum needed to be able to use these types at all, not to…

AI could help

Yes, I've used a formal term informally. That's a thing that we humans do when we try to explain something to another human. No, you used a formal term incorrectly. Between us humans, this is frowned upon as it shows that the user of the term either does not care about expressing himself clearly, or that he has succumbed to Dunning-Kruger’s and simply has no idea what he’s talking about. In both cases there is no point in taking such human seriously.

Yay finally

IME it was mostly removal of stuff that had been firing -Wdeprecated since at least 5.15, usually even longer. Some classes were replaced, but the API was pretty much the same (IIRC, these cases were mostly just redoing the class hierarchy). I think events also moved from direct member access to methods (also having said methods available in Qt5). But we ported years ago, so my memory might be inaccurate. The worst for us was the reworked plugin sets because we repackage Qt into our binaries…

Minimal traits needed for pattern types to be useful

I'm thinking of the type inference. Without this let sum = (bounded.into() + bounded.into()).try_into()?; needs manual annotations and generic code would have trouble specifying it. Having Bounded::Over allows generic code to annotate this reliably. Yes, Bounded is probably a poor name for it given its association with range restrictions. But the concept is applicable to u32 is ?is_even or whatever a well.

Bloatware

>There are 45 processes/threads associated with my ~2wk-old running firefox instance Lucky you. Running for 5 hours, currently 3 tabs open, but 13 processes and 348 threads total (as per /proc/N/task/M, not about:processes). "death by a thousand cuts" is the idiom I am thinking of.

Continuations

The Mach kernel used in XNU has had continuations for a while, where you simply state a function and pointer to pass into the function upon being switched in from after a sleep... it would be a lot of restructuring for drivers and code, but is a tried and tested paradigm that I think could be cleaner than other things proposed https://lkml.iu.edu/9704.3/0282.html It seems to have been discussed a while ago

Two more interesting paragraphs

> Supposedly Chainguard didn’t just break the embargo, but also actively tried to use their “early fix” to gain new customers by searching the web for companies that use PHP and emailing them security contract offers? I saw someone claim they were reaching out to people, but I haven't seen any evidence of that. Perhaps I am being too optimistic by hoping that they are better than that. Regardless, breaking the embargo is bad enough, even if it was done with good intentions, i.e., helping…

Bloatware

> Threads in one process have a secondary price, namely in userspace. The glibc default is 8 MB or so per thread. There are 45 processes/threads associated with my ~2wk-old running firefox instance. Even assuming each uses the full 8MB of that stack (which they very much don't), that's a total of 360MB... compared to 21.2GB VSS for the primary firefox process alone. Meanwhile, of that 21GB VSS, only 1.7GB is actually resident. Stack space isn't even a rounding error.

AI could help

What "argument from ignorance"? Yes, I've used a formal term informally. That's a thing that we humans do when we try to explain something to another human. Maybe they should update your instructions to include that, too ;-) Saying that one learned something valuable by doing X Nobody learned anything valuable there, it's just another worthless bash quirk. Using non-standard bash extensions in shell scripts is something that should be avoided. And not even standard shell arithmetic can be…

Bloatware

>The glibc default is 8 MB or so per thread Yeah, but it's only virtual memory address space allocation, not resident size, unless the thread actually uses it, right?

Bloatware

>But if I have 20 threads on a program for whatever reason I'm not going to worry about it. Threads in one process have a secondary price, namely in userspace. The glibc default is 8 MB or so per thread. (pthread_attr_setstacksize) Maybe memory is not scarce enough for you yet, but I am going to lean on the article's introductory paragraph for best judgement: "Memory has always been a scarce resource in computing systems, but [and!] the problem seems to have worsened recently."

Yay finally

I’m pretty sure that whether such upgrade is straightforward or not depends on your actual code, i.e. when you are using features that were removed or extensively changed in Qt6, or when you created your own widgets or other components which need to be rewritten for similar reasons? Not to mention it also takes time away from developing actual user-facing features, of course.

zram?

Killing zram would also kill zram use cases that are not related to swapping, so I don’t think the plan is to remove it entirely, just to replace one current use case for it.

tainting on bind/unbind via sysfs

Using sysfs to bind and unbind devices from a driver now marks the kernel as tainted Hoping this gets reverted or modified since it will taint anything that uses vfio-pci. (LLMs are great for quickly surveying users of an ABI before pushing potentially disruptive changes, btw.)

Minimal traits needed for pattern types to be useful

I don't think that forms part of the minimal needed set; I don't see what it gets you that you can't get (unergonomically) via From and a private trait in your own crate. You need TryFrom and From otherwise you can't convert between the pattern type and its base type, and you need the conditional implementation of Copy otherwise your wrapper around the pattern type cannot itself be Copy. But the extra trait you're proposing is only useful if there's a way to handle pattern types generically in…

Bloatware

> But if you have a real need to ensure that data is forced to disk -- and you do not if all you're writing is a JSON file with user prefs -- then use aio_fsync. Last I heard, nobody really liked AIO. Has that changed? Also not going to be portable. > But, even in C, I disagree with that manpage. Almost no normal application should be generating fd numbers over 1023. No, that's ridiculous. There's only 3 good limits: 0, 1, unlimited. Stuff breaking because of too many handles isn't reasonable.…

Yay finally

The problem is this: Qt 5 reached its official End of Support (EoS) on May 26, 2025, meaning the Qt Company no longer provides free community updates, public bug fixes, or standard security patches for Qt 5. Distros already started removing KeepassXC from the repos due to this.