But one can detect and judge appearance much more quickly (instantly, in most cases) than personality. It seems much more efficient to select those you consider physically attractive first and then date to check for a compatible character, than the other way round. Just like (excepting bisexuals) most of us instantly disqualify 3.5 billion people as potential partners for being the wrong sex, even if they might have great characters.
So the future of F/OSS is all projects taking no outside contributions or requiring copyright assignment? How else will the core contributor(s) be able to sell a license to AGPL code they don't fully own?
Most of our solar system is pretty difficult to get to for humans (the overwhelmingly vast majority of those living today will never be in space), so why do you consider it as an available resource? It's like criticizing bacteria in a petri dish for failing to use the ample resources of a nearby supermarket.
The default for copyright is 'all rights reserved' though, so it would seem to me that it's in the software users best interest to hope it's enforceable, otherwise they can't use the software at all.
That's a strange take on Socrates, it makes him sound like he died (intended to die?) for our sins like some kind of Jesus figure. I doubt he'd agree with it.
Anyway, I suspect you mean 'in vain'. Veins are those little tubes in your body that the blood flows through, in generally in the direction of the heart. Since Socrates died by poison one could argue that he literally died "in vein" but this is probably not the interpretation you were going for.
I agree with you on the teams thing, and in my opinion it has a strong relation to two-party systems.
But the only 'toxins' it can get rid of are those you recently consumed, not the vague and unspecified toxins that the diet people claim build up in your body and must be purged.
Congratulations, your program is now thread-unsafe because you thought using a temporary variable is expensive :-p using mutable static variables is a terrible idea in most situations.
I'm asking because many of these "consent" dialogs allow you to "reject all" for cookies, but require an "object to all" for "legitimate interest" purposes. It wouldn't surprise me if these dialogs considered the "reject all" to apply only to cookies.
Perhaps using "American" (also) for South Americans is popular usage in (certain regions of) South America. You can't just declare that it's wrong just because it's not popular usage in Western culture (which is heavily influenced by the USA).
Volatile operations are considered a side effect and as such may not be reordered with other volatile operations. How is that not literally sufficient for the operations that GGP described?
> which especially on embedded systems creates bugs where the things like "read the status register THEN read the data register (which clears the status register when read)" those get re-ordered and suddenly your loop never exits because your status bit is never set.
Why are the embedded systems programmers not using `volatile`, which exists for this exact reason?
The current system has done a very good job keeping certificate authorities honest and secure by holding them accountable. Those who disagree can easily modify the trusted root certificates on their own devices to their liking.
The article presents several arguments why the proposed legislation would be worse than what we have now. Perhaps those who support these plans could try countering these arguments, rather than trying to force a "compromise" while accusing the other side of tyrannical behavior.
Some might argue that the government enforcing which websites are trusted looks a lot like a tyranny.
There are some people who think women should not be allowed to vote. Or that pi equals 3. Just because different opinions exist does not mean compromise is required. Sometimes it's perfectly okay to just tell someone to fuck off.
> as long as the same obfuscation is not widely used so that the inspection software can check for it.
I imagine there are only so many things you can detect with DPI before the network connection becomes (even more) prohibitively slow. And you can check for rot13 or base64 or common compression algorithms (but beware of zip bombs), but you can't check for properly encrypted data since it will appear as random bits.
I feel like writing Rust is a whole lot faster and less error-prone than writing something in C. But even assuming that it's slower, it's definitely much faster than writing C and doing formal verification. Naturally formal verification can help with other properties besides memory safety, and as far as I am aware Rust is still lacking a formal semantics so when you go all-in on formal methods C can reach a provable level of quality that Rust currently cannot. But very few people develop software that way.
That depends on how you define complexity. It is far easier to write a working program without memory leaks, various types of vulnerabilities, and undefined behavior in Rust than it is in C.
Compilers not allowed to violate the language spec when optimizing. But the spec may be fairly generous in its allowed interpretations, which may not match what a programmer may naively expect. C, with its many undefined behaviors and implementation defined behaviors, is especially dangerous.
My wife tells me that she really appreciates my deep voice at parties because she can always find me in a crowded room when I'm talking. Probably too situational to make a good evolutionary 'just so' story, but it's a nice minor advantage.
Oh, those features, you are talking about stuff that is included/excluded in libraries. Those have nothing to do with compiler extensions, they don't change the language.
I would disagree. For example, suppose we enforced XHTML. Even though it's a mostly dead standard that was never very popular, there are plenty of free and very functional validators around. You don't need to be a multi-billion dollar company to close your tags.
Similarly for JS, strict mode did not ruin the internet. Sure, there is a lot of old JS code around that may or may not run in strict mode. That is not because it is any harder to write correct JS in strict mode than it is in "sloppy" mode, but the "robustness principle" has just burdened us with a lot of legacy crap that wouldn't otherwise exist. I would argue that the web would be better if JS had been strict from the start.