PowerShell. You can get it for both windows and Linux. And it actually works with all Ctrl+shift+arrow combinations.

Being leased for their life time is called owning.

Land can be inherited like any other property.

There is private land.

Mobile firefox allows installing add-ons. Unlike mobile chrome.

Yes. Kilo means thousand. However in some contexts, a single calorie is the same as a kilocalorie. Don’t ask me why.

There are 2 calories, the small one and the big one. And the big one is exactly the same as a thousand of the small ones.

It also needs like 30 minutes to load a single comment of a PR.

If I wasn’t forced by my job. I would stay as far away as possible from bitbycket.

If it has three letter variables, chances are it was also written by someone that doesn’t want to code either

Ah, just kill half the humans. That will make water consumption go way down. Follow me for more resource-saving tips

I haven’t done the experiment, I’m curious to know if you can take a random binary compiled for Linux 10 years ago run on the latest version of popular distros. See in which ones it runs.

Rust doesn’t have “safe” and “unsafe” modes in the sense your comment alludes to.

You can just do the little unsafe thing in a function that guarantees its safety, and then the rest of the code is safe.

For example, using C functions from rust is unsafe, but most of the time a simple wrapper can be made safe.

Example C function:

int arraysum(const int *array, int length) {
    int sum = 0;
    while (length > 0) {
        sum += *array;
        array++;
        length--;
   }
}

In rust, you can call that function safely by just wrapping it with a function that makes sure that length is always the size of array. Such as:

fn rust_arraysum(array: Vec<i32>) -> i32 {
    unsafe{ arraysum(array.as_ptr(), array.len() as i32)}
}

Even though unsafe is used, it is perfectly safe to do so. And now we can call rust_arraysum without entering “unsafe mode”

You could do similar wrappers if you want to write your embedded code. Where only a fraction of the code is potentially unsafe.

And even in unsafe blocks, you don’t disable all of the rust checks.