jcranmer
Before the Acts of Union of 1707, England and Scotland were not united into one kingdom, but two kingdoms that shared the same king under a personal union.
Perfect hashing for switch tables is useful mostly for large, sparse switches, but hot large, sparse switches are rare, and the closest examples I can think of (e.g., parse tables) are themselves likely generated from other tools, which could itself be changed in lieu of the compiler. It really doesn't come across as a useful optimization to try implementing in a compiler.
The sender and the receiver both have a copy of the email. The receiver's MTA pretty much has to have a copy of the email for sane antispam to work. Email itself intrinsically leaks the sender, recipient, and time as part of the SMTP message, which means anyone with access to email server logs can recover this information no matter how much security and encryption you try to put on top of it, and that means that whatever three-letter agency you care about probably has access to all the information they want anyways.
The only meaningful difference in security is going to be whether or not the outgoing MTA is going to try to use (or even require) TLS on the MTA-MTA connection, and what level of encryption is applied to the at-rest email.
Personally, I'm not too fussed about a mail system administrator being able to read my email because of the BOFH principle... it's not worth the sysadmin's time to read my email, because it's just not interesting.
RGB is fine for specifying a color. I mean, there are issues with RGB colorspaces and whatnot, but if you need to pick the background of a page or the color of text, there's no real reason not to use RGB.
The problem with RGB is that it is really bad at color interpolation. You can't take the average of the red, green, and blue components of two colors and expect a usable color in the middle to come out. Instead, you need to move to a perceptual color space. CIELAB is the old perceptual color space of choice; Oklab is the new perceptual color space of choice.
Color interpolation is needed for things like gradients or information visualization, where you need to say things like "20% of the way between color A and color B".
The tl;dr is that doing git-style change-tracking of the legislation isn't as helpful in practice as you'd think (especially because a lot of the very basic change-tracking is already available in the existing tools that lawyers use!).
If you've got a statute like "no vehicles in the park," the fundamental issue is that you have to interpret "what is meant by 'vehicle'?" and no legal drafting is going to be good enough to actually cover all the possible cases well enough. The main difference between a common law and a civil law system here is that in a common law system, you have to cite the previous similar cases (because precedent is binding) whereas in a civil law system, you're merely using those previous similar cases as persuasive evidence. At the end of the day, it boils down to arguing for your interpretation.
And in my experience working on language standardization (which is closer to a civil law system than a common law system), it's fairly often that I have to resort to looking up not just when a change in the text occurred, but dive deep into the discussions of the paper proposing the change to understand what the committee thought it was doing with the change. The complexity of law is fairly similar--the changes to the law themselves often require understanding the legislative and interpretative history of the law to understand what the intent of the drafter was to be able to rule on how the law is extended to an unanticipated scenario.
Remember that all of the code in operation includes code like the microcontroller in your mouse, the hundreds of chips in your car doing things like keeping the engine running or "window goes up when I push the button," the DVD menu (which is actually Java code), not to mention all of the staid systems responsible for things like writing your paycheck every other week.
One of the striking features of the last decade or so of global politics is the willingness of middle powers to arm and fuel regional conflicts, so I think it entirely plausible that a world where middle powers like Saudi Arabia and Iran gain nuclear weapons is one where, say, the Sudanese Civil War involves nukes.
> No person shall be elected to the office of the President more than twice, and no person who has held the office of President, or acted as President, for more than two years of a term to which some other person was elected President shall be elected to the office of the President more than once.
The 'obvious loophole' is that the text doesn't constrain the number of terms anyone can serve, but instead constrains the number of times someone can be elected as president, so if you run as vice president for someone who agrees to immediately resign to let you be president, you technically don't run afoul of the rule.
(The more likely loophole, following from Trump v Colorado, is that nobody is actually allowed to declare somebody ineligible for president, so the constitution's strictures are meaningless in practice. It truly is a disgusting SCOTUS decision.)
The US only enacted term limits in 1951. Before that time, only two presidents had attempted to seek third terms (another two attempted but failed to secure even a nomination by a political party), and only one was successful.
And, quite frankly, the only president since the 22nd amendment who I could see wanting to run for a third term is Trump, who does seem to be campaigning for one anyways despite being constitutionally barred from it.
Nonetheless, even today, the vast majority of countries are not self-sufficient on defense infrastructure, and this has been true for most of the modern era. The most obvious deficiency is in naval terms: the number of countries who have enough of a navy that they can do something about "my shipping is being attacked by pirates" without help from other people is plausibly at most five (US, UK, France, Russia, China), and I have my doubts about half of those.
That said, a lot of people use nation state as a synonym for sovereign state, and Belgium is as much a sovereign state as the US is.
I'm not sure that's really true. Human social organization has, until around 10,000 years ago, been centered on small groups of people where everyone literally knew each other. The ethnographic studies on non-state complex societies generally tends to show a lot of kinship-based networks that developed, and even in state societies that are facilitating long-distance trade, trade patterns and introduction into new areas is heavily reliant on membership of these kinship groups. State societies generally deemphasize these kinship groups, eventually doing away with them like in modern society, but the mechanisms for developing social trust are based on a very centralized development of the legal system--the government essentially enforces that people have to be trustworthy, or they face the wrath of government otherwise.
Essentially, in short, the idea that humans have regularly been trusting people based on asking their close compatriots who they can vouch for doesn't seem to accurately model how trust develops in societies for most of human history--you either have vouching based on direct observation (in small societies), vouching based on identity (larger non-state societies), or centralized authority vouching for people (state societies, including today).
The broader issue is that users don't want to (and probably don't have the ability to) actually make any trust decisions; they much prefer to delegate all of the decisions on trustworthiness to somebody else. The PKI root CA system does have its flaws, but on the whole, I suspect that people like Mozilla are better stewards as to whether or not the person vouching for somebody else is trustworthy than the average or even the above-average user.
Had we been using DANE instead of WebPKI, the response to this sort of compromise would be "aw, shucks, someone proved to be untrustworthy and they're in such a critical role in the ecosystem that there's no way to route around this DNS provider being untrustworthy."
The first Iowa-class battleships were laid down in 1940 (so after WW2 started but before the US entered the war), and did see active service in the war. The British had two classes of battlecruisers that were laid down in WW1 that saw service in WW1, although they commissioned after the Battle of Jutland, which was essentially the only major naval action of WW1. It's debatable if you want to lump battlecruisers in with battleships, but considering that the main long-lead item of battleships are their guns and battlecruisers are essentially battleship guns on a cruiser, I think it's fair to do that here.
Aircraft carriers are not battleships, but I do think it is worth noting that except for Essex herself, all of the Essex carriers were laid down after the US entry in WW2 and these were the ships that formed the US assault in the Pacific in WW2.
The main problem with the x87 floating-point unit is that it only properly works on a weird 80-bit floating-point type that doesn't have the properties you expect of regular IEEE 754 floating-point types, thanks to the explicit integer bit. The design makes it hard to properly emulate the more common 32-bit and 64-bit single and double-precision floating-point arithmetic bit-equivalently, and this is compounded by many compilers' decision to spill floating-point registers incorrectly (they're spilled as 32-bit or 64-bit, not 80-bit), which makes the numerical results of your program effectively random. Also, the size of the 80-bit types isn't really conducive to vectorization, so the floating-point unit gets left behind as SIMD programming starts to become more important.
So what happens is that the x87 is essentially the last of the pre-IEEE 754 floating-point systems that's still hanging around. A lot of the features that would make it interesting in an environment where every vendor has a different floating-point system are now just vestigial weirdness in a world where everybody is following the same floating-point system, and not worth supporting.