Moderna and Pfizer tested variant-specific (B1.351) boosters and found they weren't significantly more-effective than a third dose of the original vaccine.
https://www.nature.com/articles/s41591-021-01527-y
> And I can think of more than one well-regarded unicorn where everyone still has access to basically everything, even after their first or second bad security breach.
It's good to have competition in this area. Influx is giving me whiplash (it's on its third database engine in six months!)
The circular buffer approach is fine, but it does have the drawback of being unable to represent variable-length data (like key-value pairs). It's also harder to compress the data.
Can a GROUP-BY do windowed aggregations? Like, take an average over ten-minute windows? My SQL knowledge is not great.
Need replication? Gotta write your own sharding logic or set up pg_shard.
Need aggregations? Gotta write your own logic. Will you do them on the fly? Use triggers? On demand?
Need to remove old data? Gotta set up a cron job. But wait, what if I want to age different series at different rates? Now you need a policy system. Sigh.
Not saying Postgres can't be the storage engine, but there's a lot of work to do on top of that.
The author also points out that some of the benchmarks poorly represent real workloads:
"Bottom up (since the worst offenders are now first),
binary-trees is silly since it measures allocation speed for a case that simply doesn't exist in real code;
thread-ring is basically insane, since nobody ever bottlenecks like that;
chameneos-redux's C++ implementation is ridiculous. The C is not so ridiculous, but you still have the problem that basically every language in the top few spots does something completely different;
pidigits tests whether you have bindings to GMP;
regex-dna tests a regex engine on a small subset of cases (arguably the first half-acceptable benchmark);
k-nucleotide tests who has the best hash table for this particular silly scheme, and they don't all even do the same thing (eg. Scala precompacts, like my new Rust version);
mandelbrot is kind'a OK;
reverse-complement would be kind'a OK if not for a few hacky implementations (like the Rust);
spectral-norm is kind'a OK;
Haskell basically cheats fasta (which is why I copied it);
meteor-contest is too short to mean anything at all;
fannkuch-redux is probably kind'a OK,
n-body is kind'a OK.
So maybe 5/13 are acceptable, and I'd still only use 4 of those. I think if looking at mandelbrot, spectral-norm, fannkuch-redux and n-body you can argue the benches are a reasonable measure of peak performance. However, these cases are also all too small and simple to really be convincing either, nor is it particularly fair (where's NumPy for Python?)."
Basic question — when you're writing a kernel in Rust with its own threading implementation, how does the rust compiler even know what threads are? It has to identify thread boundaries for send/sync, right?
This may of course change with new variants.