Given the high percentage of the population in SA who has already had an infection, there's probably a significant chunk of people in finding 1 who also already had natural immunity. That's probably going to make it difficult to use these results to compare vaccine-based immunity to natural immunity, right?

I understand the convenience argument, but with current battery technology this would not be sustainable. All those batteries require rare earth materials and add more waste to our daily lives as they have limited lifespans.

Podman allows you to run containers without root privileges, in case you aren't aware. But maybe you mean something else?

I wasn't aware of that. Thanks for bringing it to my attention!

Anyone have a ELI5 version of the architecture of lockless buffer? I'm trying to wrap my head around how something like this can operate without locks and I just can't grock it.

I'm not familiar with the Linux ring buffer specifically. It is presumably a multiple producer single or multiple consumer circular buffer, though.

Single producer single consumer circular buffers can be made pretty easily without locks. The producer writes to the buffer then atomically increments the head pointer. The consumer reads the buffer and then atomically increments the tail pointer.

Multiple producers get tricky without locking because they need to coordinate with each other enough to not write over the same part of the buffer. This can still be done via atomically incrementing a head pointer, though. The trick is that the increment has to happen before writing to the buffer rather than after. The buffer therefore needs to have a marker in it to indicate that it's ready to be read. A producer allocates the buffer with the atomic increment, writes it's data at it's leasure, then marks it ready to be read. The consumer looks at both the head pointer and the markers to tell how much data can be read.

Multiple consumers can be implemented by simply maintaining a tail pointer for each consumer. In order to be truly lock free, though, producers can't be blocked by slow consumers. Instead, producers simply write as fast as they want, and consumers do their best to keep up. A consumer can detect when it falls too far behind if you use counters rather than pointers or indexes; rather than wrapping around on increment, you wrap around on access to the circular buffer. That way, you can tell when you've fallen behind when your counter is more than the buffer size behind the head counter. You can either use 64 bit counters and never worry about roll over, or you can use a smaller data type for the counter and then size your buffer to be a power of two so that integer rollover doesn't cause a discontinuity.

For what it's worth, Alexa does ask for feedback about the accuracy and helpfulness of it's answers now.

The legacy of this one guy and his cult of personality is pretty amazing. I think this would make a fascinating Paul Thomas Anderson movie.

I've had this issue as well and found that it makes using an IDE almost mandatory for large code bases.

Liberal use of the word "lit" when describing the latest and greatest framework always works for me.

One reason to use containers over VMs is that building, updating and extending containers is far easier and more maintainable than full virtual machines.

Containers give you the ability to layer the pieces you need on top of each other, so you are only responsible for the parts that you maintain. No need to rebuild an entire VM image every time one piece of the stack is updated.

Distribution of containers is also far more efficient than full virtual machines (especially important in a highly distributed environment).