Wine can actually beat native in latency, since it’s a pretty thin translation layer and windows is … windows.
I’d give it a shot just in case.

Efi spec states it must be safe to delete all variables. It’s only motherboards not adhering to the spec that are affected, effectively faulty hardware.
If you do this on a mb from that era chances are nothing will happen, and if something does happen chances are it is recoverable. You’d have to have some truly bad luck on your choice of mb to have it be permanently bricked by that.

1:31 & 2:47

I think it says “honesty of these words”

Steadily improving. I set up my webserver with ech which is the next step, hiding even the domain. A solid chunk of the internet uses cloudflare as an intermediary, which also has ech and only leaves “someone connected to some cloudflare page at this time for that amount of data”.

As more places roll out deep package inspection, I’m sure in due time more randomization for package sizes will follow, making even the amount of data uncertain.

Most web metadata is at the http layer anyway and has always been hidden by https.

Oh my I must have recited it wrong from memory, my bad

Yep, exact copy of the first 35 lines from the 100,000 Digits of Pi website, the spaces are still in

Oh you want the code not rendered into html!
Drops the code in javascript when it is received from the backend.

genkernel is basically deprecated. You can use distkernel and supply your own config or config mods.

Yeah, I would expect it to be hard, similar to asking an llm to substitiute all letters e with an a. Which I’m sure they struggle with but manage to perform it too.

In this context though it’s a bit misleading explaining the observed behavior of op with that though, since it implies it is due to that fundamental nature of llms when in practice all models I have tested fundamentally had the ability.

It does seem that llms simply don’t use double spaces (or I have not noticed them doing it anywhere yet), but if you trained or just systemprompted them differently they could easily start to. So it isn’t a very stable method for non-ai identification.

Edit: And of course you’d have to make sure the interfaces also don’t strip double spaces, as was guessed elsewhere. I have not checked other interfaces but would not be surprised either way whether they did or did not. This too thought can’t be overly hard to fix with a few select character conversions even in the worst cases. And clearly at least my interface already managed to do it just fine.

I’d expect tokenizers to include spaces in tokens. You get words constructed from multiple tokens, so can’t really insert spaces based on them. And too much information doesn’t work well when spaces are stripped.

In my tests plenty of llms are also capable of seeing and using double spaces when accessed with the right interface.

This seems to match up with some quick tests I did just now, on the pseudonyminized chatbot interface of duckduckgo.
chatgpt, llama, and claude all managed to use double spaces themselves, and all but llama managed to tell I was using them too.
It might well depend on the platform, with the “native” applications for them stripping them on both ends.

Export the apk via adb and then install it from the file on future devices?

Also the norm tho, afaik

My bank had a device that was basically a simple android phone running the 2fa app. The phone app got updated through new versions and eventually got the drm treatment, but the old app keeps working because it is still running on those dedicated 2fa “devices”.
Naturally the bank is now trying their best to make people deregister the old “devices” and switch to only the “app”.

The old app has no internet permissions. It reads qr from the camera and shows verification as a 6 digit code.
The new app has internet permissions and is integrated with other apps so you can conveniently accept the request of your banking app in the 2fa app (on the same phone) with a single tap via an overlay. 2fa.

Yeah, on some fundamental level.
Most linux distros would be very moddable repairable off-the-shelf cars. LFS would be your diy project with various guides. And gentoo would be a parts garage with their own guides and precompiled kits of components, so you can either follow those sets and build a more off-the-shelf car or diverge at any point for any section and run wild. But also you can still use the machine shop of the store and they offer to custom build some consumables for you and keep shipping them.

You could use njal.la, who charge a flat 15$ without deceptive schemes and actually protect your privacy properly too.
To be fair namecheap legally can’t do what njalla does since namecheap is a primary registrar and njalla secondary.

In terms of activism I’d think both getting the cheapest option and donating 8$ a year to the eff or a similar group directly, or taking a njalla domain and donating 3$, would be cheaper than namecheap and also more effective at defending internet freedom.

In the underlying system there is no difference. A renewal is just a transfer/registration leaving the data unchanged.
All cost the same and add 1 year of lifetime to the domain.
Any other pricing is invented by that specific registrar and doesn’t reflect actual costs.

What a ripoff, .com has always been about 10$. The renewal being somehow more expensive than a new registration, while in actuality there is no difference in the process, really makes it obvious they charge what they think people will fall for.

$7.85 per year in 2012. $8.39 in 2021, $8.97 in 2022, and $9.59 in 2023, $10.26 in 2024, increases always in september.

Transfers, registrations, and renewals all cost the same and all charge the domain by 1 year. You can charge at any time for I think up to 10 years. Any registrar not passing that system on is being deceptive.

They aren’t even roping in people with prices below cost, they charge you a reasonable fee for the first year and then somehow bank on people not switching. Maybe they make the process really painful?

Either way why would anyone use them?

If it’s something outside packages, like say the filesystem, it should be similar to fix to what you did in the initial setup. You already have to know how to partition your system, so at worst you’d have to relearn that if you installed a very long time ago.

If you mean break some regular file, you can reinstall the package it belongs to or everything if you have the time.

Gentoo has a proper package manager (portage), so most things you can rebuild. If you fuck some config, you can probably rebuild and get the default files back.

If you break portage config somehow, you’ll probably have to start from scratch in essence. Though there too once you start to redo your setup you’ll likely run into the same issue and have to figure it out.

Because all distro-problems will be caused by you, the only escape is to understand the issue.

Any “rebuild” would just be you copying in all your old stuff and repeating all the settings, you could just as easily revert your settings till it works again and pinpoint what is causing it.

I have no specific automation for setting up a system from scratch (did it 2 more times on different systems but manual copy was good enough), but automating it wouldn’t be hard. Just dump all the commands I run during setup into a script, and add a few scp to pull in my own stuff (or I could even put it in an official gentoo repo and pull it in with one portage config file).
But why would I? I don’t regularly set up copies of my system, and this is the same as just looking at my system. It can’t break itself past what those config files and setup commands do. The system won’t diverge from your commands so there is no need to force reset it to your commands.

I suppose the fact I comment my package set (the config file that contains all the packages I have installed) with install reasons is the same as starting from scratch. I simply reevaluated all my installed packages when I wrote it.

In a way I did once “fuck my system”. I switched to wayland (end of '22, before it was cool) and wanted to remove all X flags from all packages (a global flag unset). So I endlessly figured out what packages really needed that flag, added exceptions, and after months still ran into occasional issues, instability, or the weirdest dependencies. Whenever I had any problem I started considering if it was somehow caused by that.
I knew it was stupid, I knew plenty issues it had caused, everyone was telling me it was in fact stupid. Basically I was test-running 200 packages at once under settings noone had ever intended. So my “rebuild” was just to remove that -x from my make.conf and rebuild all affected packages. (I may have even rebuilt the entire system just in case).

The only way I see you actually starting from scratch is if you

• Did something stupid from lack of knowledge or out of fun
• forgot about it
• couldn’t trace it back nor anyone else could figure it out
• it’s in something not logged (which I’m fairly certain doesn’t exist unless you explicitly turn it off)

The most “I’m fucked, rebuild everything” moment in my memory was me doing an update after half a year when kde6 was released. What happened was I had manually specified a bunch of kde system components (instead of stripping down the kde meta package via flags) and some were removed in kde6, so portage tried building a kde6 system with kde5 and failed in enough ways to generate like 5k lines of error.
I was unable to read that error, and while someone in the gentoo irc was able to, I would have had to “rebuild” my package selection otherwise.
Meaning leave the system running as is, remove stuff from the installed packages config until the update finds a valid config, add back stuff while it keeps working, and be left with in this case the packages that were removed, where I would have then checked them and seen they were removed in kde6.
This would have essentially been me “rebuilding my installed packages”, so “rebuilding the system”, but while still using that same system and with the final “apply” being a regular update using my fixed config. No need to throw everything away in the mean time, it may destroy my valid package state but the system doesn’t mind (it just stays outdated). I could have even updated only specific important packages and delayed the package rebuild for more months.

The main flaws here are me (adding stupid dependencies) and portage producing unreadable errors (to be fair there are so many ways to fuck up package configs it’s gotta be really hard to make every case readable and traceable to some sane cause).

Without fixing it I ofc could not have gone to a different system and copied over my stuff (automated or not) since that would also have refused to build all my selected packages.

It’s very controllable.
You start out with control over everything, but that also means you have to do everything and know everything. Then you can hand back that control by automating on your terms, and gentoo provides a lot of tools for that.
But you always have that confidence that when something is weird, you can go back, take the control, see what happens, redo the automation. Or keep it manual.
Gentoo won’t ever touch your config files (It proposes changes you approve), and if something happens you didn’t want you can always trace it back to your own mistakes.

I’ve never gotten the same feeling of being in control with any other distro. There is always that time it fucks up my ssh config, or breaks due to some oddity I chase back down to a decision by some maintainers.

It’s stable only based on your decisions and skill. It will make you a lot better at using linux. But also if you don’t have the time, or the will to keep automating and scripting and learning new things, then you won’t be able to use it and you’ll have a really bad time.

It does bring automation but only up to a still very manual level. You can’t go “fuck this shit mode” and turn it into opensuse with a config option. For example you can do your own kernel, or add a few changes to a default kernel and use it without init system, or follow a tutorial to pull default binaries and just have what most other distros have, but you won’t find an installer to check that as an option, you are forced to still understand what components you are putting in where, connecting how, automating with what commands and tools.

Also protip if you do your own kernel start with the binkernel config not the default the fresh kernel repo starts out on. You’ll never find all the footguns autoconfigured to make your system weirdly choppy. And recompiling stuff you forgot in a module then loading that into the old kernel usually works but can crash your system.
Change all the options, be my guest, but at least start from a working state so you have a chance of knowing what you fucked up and which flag you didn’t understand.