On windows if you don’t disable bitlocker, then login at least once to your outlook.com account so it can backup the key.

That's not a bad idea, but if you are going to be using Linux then I'd recommend exporting the key and, for example, saving it in your password manager and/or on a USB stick (preferably after encrypting it). That way you can easily decrypt the partition using dislocker. Also, personally, I do not want to my encryption keys to shared with Microsoft, but that's just me ¯\(ツ)/¯

"Free" and "libre". But this has only ever referred to the software itself, not to the hardware needed to use it.

That should be obvious, since otherwise almost no OSS would be FLOSS. After all, you have to buy a PC or another device to run it

What does reminding Windows involve? I also dual boot btrfs, but Windows never sees my btrfs since it's on a LUKS encrypted partition, so I am not familiar with needing to do this

To be honest, they didn’t make it easy to find

While WinRAR is pretty great, it has also had several severe security vulnerabilities over the years, including one last year:

https://en.wikipedia.org/wiki/WinRAR#Security

Which isn’t quite what you’d expect from “perfect” software

I use Mega(sync) to keep my various PCs in sync. Before that I used SpiderOak for a number of years, but the service started degrading at some point, which forced me to switch.

While committing to a git host is not a bad idea, it doesn’t cover all the stuff you might want to sync in my experience

The way to really optimize Python code, is by reducing the amount of Python code in your program, since Python itself is dog slow. Instead, you want to offload as much of the work as possible to modules written in compiled languages. So completely switching to Rust, or another compiled language, is simply taking that strategy to its logical conclusion

I believe that it is useful in a few places. cppreference.com mentions templates as one case:

Trailing return type, useful if the return type depends on argument names, such as template<class T, class U> auto add(T t, U u) -> decltype(t + u); or is complicated, such as in auto fpif(int)->int(*)(int)

The syntax also matches that of lambdas, though I'm not sure that adding another way of specifying regular functions actually makes the language more consistent, since most code still uses the old style.

Additionally, the scope of the return type matches the function meaning that you can do

auto my_class::my_function() -> iterator { /* code */ }

instead of

my_class::iterator my_class::my_function() { /* code */ }

which is kinda nice

Astral clearly are using semantic versioning, as should be obvious if you read the spec you linked.

In fact, one of the examples listed in that spec is 1.0.0-alpha.1.

ETA: It should also be noted that ty is a Rust project, and follows the standards for versioning in that language: https://doc.rust-lang.org/cargo/reference/manifest.html#the-version-field

Thanks! And yeah, with Markdown you need an empty line for it to actually add a paragraph break.

Though I just learned that you can also end a line with two spaces or an \ to get a line-break

Please consider adding paragraph breaks to your posts; a wall of text like this is not pleasant to read

A single underscore is just a naming convention, but double underscores triggers automatic name-mangling of the variable in question:

$ cat test.py
class foo:
        def __init__(self, x):
                self.__x = x

f = foo(1)
f.__x
$ python3 test.py
Traceback (most recent call last):
  File "/mnt/d/test.py", line 6, in <module>
    f.__x
AttributeError: 'foo' object has no attribute '__x'

However, much like private/protected variables in java, this is pretty trivial to circumvent if you want.

But I don't believe that you can argue that access modifiers are required for OO not to be shoehorned into a language, not when influential OO languages like Smalltalk didn't have this feature either. Java just happens to be closer to C++, where public/private/protected is much more rigidly enforced than either Java or Python