Google's fully homomorphic encryption package

Good point, I hadn't considered that one. However, as I already mentioned in passing, staking thresholds will centralize the validation process into fewer nodes, away from the decentralized aims of original cryptocurrencies. Mining pools are a part of this problem, even for existing PoW coins.

It shouldn't be a problem for anyone if I want to help maintain the distributed nature of the network at my own expense. Perhaps in Ethereum's case, the threshold is a part of the greenwashing as they transform from PoW to PoS. However, it should be seen as a problem whenever a cryptocurrency is promoting increased centralization.

Bitcoin doesn't have any staking rewards, but its community also recognizes the importance of publicly accessible nodes for the health of the network. There used to be the Bitnodes project that would reward nodes with high uptime, but it never really materialized due to low participation numbers.

It's just that the only allowed "changes" are logging certificates with specific characteristics, and in many cases all the interesting certificates have been logged. You can't log the same certificate again.

Historically, prior to the mandate, and to a lesser extent up until this month (at the end of May 2021 near as I can tell the last possible certificate that could have existed, trusted in the Web PKI without ever being logged, would have expired) it was possible to find certificates out in the wild which hadn't been logged and go log them. But by 2017 or so you'd need to be on the ball because Google's spiders, the ones which power the search engine, were doing the same thing.

If you have money, and thus can afford to make it worth their while, a CA can sell you (No Let's Encrypt doesn't offer this, they could but there's no obvious reason why you should want it or why it would be in their interests to offer it) a certificate which hasn't been logged, even now. The mandate from Chrome isn't a root store policy, it's just a mandate for Chrome. You can then submit that certificate to logs yourself, the CA which sold it to you likely has some suggestions for where to do that. So long as you keep your receipts (SCTs, everybody else's are burned inside their certificate, but since yours was not logged when you received it, it's too late for that) you can prove this certificate was properly logged and it will work just fine.

Google does that, for some of their systems. But they know what they're doing (or at least, they employ teams of people to know).

In more modern GPUs, the tricky part is that you write a GPU shader as scalar code but it gets executed as SIMD (with typically around 32 SIMD lanes), and the hardware uses a combination of dynamic flow control and masking. Like in your example "if(a == 0) r = comp1(); else r = comp2();", if the condition is true for all 32 lanes then the GPU will execute comp1() and jump over comp2(). But if the condition is only true for 31 lanes, it has to step through all the instructions of both comp1() and comp2() for all 32 lanes, with a mask register to suppress execution on individual lanes based on the condition. The divergent control flow in 1 out of 32 lanes is doubling the total number of instructions processed for all 32 lanes, so you want to be careful to avoid that if you care about performance.

That masking is not quite the same as manually writing "r = (a==0)*comp1() + (a!=0)*comp2()", because the masking will likely also suppress any memory reads performed by comp1()/comp2() in the disabled lanes. That's good for performance, though obviously not good if your goal is to avoid leaking information. On the other hand, if there are no memory reads and a high likelihood of divergent control flow, then you might get better performance by doing more arithmetic and avoiding the overhead of branches.

However, the library Google uses doesn't work that way. Instead, it works by basically simulating a boolean hardware circuit that carries out the operation. Computer hardware doesn't have if/then/else – it has boolean and/or/not. So you want a simple 32-bit addition? Fine, just write a loop over a 32-bit field with hardware carry and all that.

This is where the 9-orders-of-magnitude slowdown WRT "real" computer hardware comes from. That's a lot: a one-second calculation would take 30 years. Thus yes it's nice but still a research proof of concept until somebody manages to speed those bit operations up a whole lot *or* somebody manages to implement subtraction and test-for-zero.