Chernobyl

But that was a really old tech, the plants built after 1990s shouldn’t allow this scale of pollution even if all the stops are pulled and everything breaks in the worst way possible

This is the ideal rendition, I would say. On a related note, I just love it when there are backspaces in my filenames

There are many regexes that validate email, and they usually aren’t compliant with the RFC, there are some details in the very old answer on SO. So, better not validate and just send a confirmation, than restrict and lock people out, imo

and which of these two you are going to get paid more for

It looks like exactly 4 characters are missing, so public and static would fit, but I never saw static instead of public static, so I think you’re right. On the other hand, I don’t use Java anymore and couldn’t be bothered about such details

Depends on what was the course about. If it’s about computation, then sure. If it’s about OOP or architecture design (this one I wouldn’t expect, unfortunately, but would be nice if it was taught somewhere), then the point is not just to run something.

I mostly come to prefer composition, this approach apparently even has a wiki page. But that’s in part because I use Rust that forbids inheritance, and don’t have such bullshit (from delegation wiki page):

class A {
    void foo() {
        // "this" also known under the names "current", "me" and "self" in other languages
        this.bar();
    }

    void bar() {
        print("a.bar");
    }
}

class B {
    private delegate A a; // delegation link

    public B(A a) {
        this.a = a;
    }

    void foo() {
        a.foo(); // call foo() on the a-instance
    }

    void bar() {
        print("b.bar");
    }
}

a = new A();
b = new B(a); // establish delegation between two objects

Calling b.foo() will result in b.bar being printed, since this refers to the original receiver object, b, within the context of a. The resulting ambiguity of this is referred to as object schizophrenia

Translating the implicit this into an explicit parameter, the call (in B, with a a delegate) a.foo() translates to A.foo(b), using the type of a for method resolution, but the delegating object b for the this argument.

Why would one substitute b as this when called from b.a is beyond me, seriously.

Even if it is not their fault, what people see is that they provide bad quality service. Very low percentage ofthem will care to read details when Netflix publishes a post-mortem of an issue, assuming they even do.

I would argue that you mentioned events that were rare and much prepared (also omit failed attempts), while what is required for any resource extraction must be mass-available. On the other hand, I don’t think any space resource mining will be reasonable, as I expect it to require more resources than provide.

I feel like ‘a half is one-third more than a third’ is ambiguous and same as in ‘X is N% more than Y’ one may use X or Y as 100%

I’m sure that one interpretation is more common, but I don’t think that it is exclusively correct

I’m afraid it’s DLC only content, and requires a lot of macro-transactions

Only surviving ones

They can also use vague AI-generated ‘meme’ and ask what memes do you see. But they will need to use older and dumber models, current ones make stuff too specific.

What I mean is something like this:

Makes me wonder if that fascist regime would’ve fallen by the end of the 20^th century like the other fascist regimes in Europe

Now trending 📈

Would be interesting to take a look through such a window.

But we could put ads during the new moon 🌑→🌚

Got it. I agree that their drivers are (were?) of exemplary bad quality

But I don’t think that it is realistically possible to drop all the proprietary firmware blobs, and if it’s not maybe it’s better to not actively sabotage something to ‘avoid those being feasible’?

Early returns improve readability in that they make it simpler to read, but I also find them decreasing readability in that you may miss an early return and wonder why is execution not hitting the line you expect it to

What’s the reason to avoid binary blob drivers being feasible? Is that about not being able to use non-free binary blobs in kernel? I don’t quite understand what it even is about