The problem comes in when you need to flip a flag that isn't set in the default kernel build for compatibility with your hardware and configuration.

Exactly, then you are depending on that third party (be it MS, Apple, Valve, Debian, etc) to care enough about your obscure setup to support it.

Well if you walk backwards 10 paces and look at the big picture here, what MS did enables anti-cheat attestation via TPM, and that in turn can act as a feature that structurally - via the market - reduces the appeal of Linux.

Signing your own custom-built kernel (if you need to adjust flags etc., like I do) won't result in a certification chain that will pass the kind of attestation being sketched out by the OP article here.

Yes because you’re trying to communicate that trust to other players of the game you’re playing as opposed to yourself.

It’s why I hate the term “self-signed” vs “signed” when it comes to tls/https. I always try to explain to junior developers that there is no such a thing as “self-signed”. A “self-signed” certificate isn’t less secure than a “signed” certificate. You are always choosing who you want to trust when it comes to encryption. Out of convenience, you delegate that to the vendor of your OS or browser, but it’s always a choice. But in practice, it’s a very different equation.

It is however integrity on behalf of a third party, and possibly antagonistic to the user.

When I had a problem with video handoff between one Linux kernel and the next with a zfsbootmenu system, only Gemini was helpful. ChatGPT led me on a merry chase of random kernel flags that didn't have the right effect.

What worked was rebuilding the Ubuntu kernel with a disabled flag enabled, but it took too long to get that far.

The shorthand makes inline style more ergonomic, so you can see the wood for the trees, rather than long strings of style attributes in your markup.

Inline style is the thing. That's what tailwind is enabling in a readable way. And inlined style is what makes style more maintainable and less susceptible to override rot.

The separation between form and function is always a bit illusionary, but particularly so with CSS. Almost all markup is written to look a specific way, not a configurable way.

Some induction ranges use magnetic dials for control to solve this problem.

I like these. Also some way to rotate the pot while holding modifier key would be pretty cool.

So you would replace an obvious and one handed control with an arcane two handed gesture? Why?

Cool is generally bad in UX design.

If that removes the knobs that are can be lost and cost significantly to implement - yes.

Maybe it can be implemented in a single hand gesture. But the point is pot or pan can be control interface itself.

This would be more credible if it stuck to computational primitives and didn't bring in "reasoning" or "decision manifold".

Stick to the math, and make an argument that the hardware behaviour drifts outside documented bounds, taking into account the existing non-determinism in the system, e.g. CUDA thread atomics, or batch sizes and layouts if you're layering concurrency on top.

Try tailwind. Very amenable to LLM generation since it's effectively a micro language, and being colocated with the document elements, it doesn't need a big context to zip together.

Tailwind CSS has also been super useful. A vocabulary for style colocated with the elements works far better than an ever growing list of continuously overidden rules.

Who said anything about removing the government? Has the government been removed? Is there any sign it will be?