But then we might run into a shortage of carrier pigeons.

...and in other news, it's getting harder to build killer robots in the privacy of your own hotel room

Also, I would like to add that we are really talking about two separate issues here.

For me, I do not like that we lose voting accuracy. So there are simple ways to improve on it, like I stated earlier.
For you, you do not like that it has become a popularity contest, and that it comes down to uninformed masses making the decision. I won't argue with you there.

But for your issue, again that has nothing to do with voting accuracy. Instead, that has to do with educating the uninformed masses, which is indeed an entirely separate issue altogether, and the electoral college does not solve that problem.

Like they say in programming: garbage in, garbage out. Since the electoral votes themselves are based upon the votes of the uninformed masses, they too are going to be garbage. But at least we can have a more accurate outcome if we improve upon the current electoral scheme.

Yeah, that whole thing about each State selecting the president... All that means is that my vote doesn't matter because it is going to be nullified from winner-take-all.

Like I said before, if the US were just one big "State", then winner take all is fine. I get that. But when you have winner-take-all applied across multiple states, you lose voting accuracy.

Again consider my updated example:

State A: 500,001 votes for candidate 1; 499,999 votes for candidate 2
State B: 0 votes for candidate 1; 100,000 votes for candidate 2
State C: 0 votes for candidate 1; 100,000 votes for candidate 2

Again, state A gives ten electoral votes to candidate 1, and states B and C each give one electoral vote to candidate 2.

In this example, candidate 2 gets a total of 699,999 votes, and candidate 1 gets a total of 500,001 votes. Yet due to the electoral votes, even though candidate 2 got 39% more votes, he/she would still lose.

I will not argue that indeed, today it may seem like a popularity contest is taking place, but in the end, to allow for the outcome of one state to nullify the outcome of the others (like in the above example), seems preposterous to me.

And in fact, it becomes even more clear when you consider that the above example could be updated as follows:

State A: 500,001 votes for candidate 1; 499,999 votes for candidate 2
State B: 0 votes for candidate 1; 100,000 votes for candidate 2
State C: 0 votes for candidate 1; 100,000 votes for candidate 2

Again, state A gives ten electoral votes to candidate 1, and states B and C each give one electoral vote to candidate 2.

In this example, candidate 2 gets a total of 699,999 votes, and candidate 1 gets a total of 500,001 votes. Yet due to the electoral votes, even though candidate 2 got 39% more votes, he/she would still lose.

While we're at it, let's also do away with the electoral college. And yes, I'm being serious.

Here is a simple example:

You have three states. The first one is 10x larger than the other two, and the voting outcome is as follows:

State A: 500,001 votes for candidate 1; 499,999 votes for candidate 2
State B: 49,999 votes for candidate 1; 50,001 votes for candidate 2
State C: 49,999 votes for candidate 1; 50,001 votes for candidate 2

State A gives ten electoral votes to candidate 1, and states B and C each give one electoral vote to candidate 2.

As you can see, even though candidate 2 received more actual votes than candidate 1, he/she winds up losing.

The winner-take all rule makes sense whenever there is just one state involved, but when you carry it over across multiple states, you wind up losing accuracy. Currently there are only two states, Nebraska and Maine, which actually implement proportional voting by splitting their electoral votes. But even then, that is not 100% perfect because there are an integer number of electoral votes which are based on population size, so there is still a rounding error.

The most accurate, and to me the simplest approach is to simply add up the actual votes from each state for each candidate, and only at the very end do you compare votes to see who is the winner.

I would like to point out that your calculation of the memory per tab is slightly off. Because the first tab includes memory for both itself and the software overhead, in order to compute the actual memory/tab you need to remove the first tab's contribution from the computation.

In other words, using your observation of 61MB for the first tab in Firefox, you would subtract 61 from 794MB to arrive at 733MB for the remaining 39 tabs. This yields a more accurate memory/tab value of 18.79MB.

You could do the same for the IE memory/tab value as well, except as you noted, there is no software overhead, so the memory/tab would be the same even if you factored it out.

According to the IEEE 754 standard, a double allows for at least 15 significant decimal digits of precision. This means that a number like 9,999,999,999,999.99 can be represented exactly with no rounding. I believe this is more than sufficient to fit Apple's budget in a C double float, using their current market cap of 496 billion.

In contrast, because Apple's budget exceeds 2^32 dollars, using a 32-bit fixed point number would not be sufficient, whereas the double float is.

Nice... However it does not implement castling.

Earlier you made the following statement:

That is what is under debate. Is it true that all security is "security through obscurity"? There is a difference between understanding how an encryption algorithm works (obscuring an algorithm), and knowing a particular key to decrypt ciphertext using that same algorithm (obscuring an input to that algorithm).

For instance, it is possible to understand how the Diffie-Hellman algorithm works works -- meaning it is not obscure -- and yet still be unable to decipher the contents of a message encrypted via that algorithm. In this example, as in many others, the workings of an encryption algorithm need not be obscure in order to be considered secure.

In the sense that algorithms rely on their inputs, such as private keys, to be kept hidden (obscure), you would be correct. But since the phrase "security through obscurity" typically refers to the algorithm, and not its inputs, it would be misleading to claim that all security is "security through obscurity".

Right, but you should be sure to use the proper units.

1GB equals exactly 1,000,000,000 bytes by definition.

1GiB (notice the 'i') is the one that equals 1,073,741,824 bytes.