Take it with a grain of salt, as I am not an expert, but it looks like China would prefer an 'independent' country that is ruled by Chinese government in secret. That way they don't need to fix and repair all the shit, and can only spend bare minimum of effort needed to keep slaves citizens alive
There is some danger that common usage and widespread sloppy coding will establish a de facto standard for e-mail addresses that is more restrictive than the recorded formal standard.
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
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
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):
java
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.
Later: short summary of the conclusion of what the committee does (read 307 minutes)