acconsta

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

This may of course change with new variants.

How about when they were buying those DCs?

> modern C++

This library is old enough to drive...

Google implemented fibers. Hopefully they'll get upstreamed.

https://www.youtube.com/watch?v=KXuZi9aeGTw

>Many of Rust's safety guarantees come from compile-time checks that then do not have any runtime penalty.

But not bounds checks, which are unfortunately what you need with respect to buffer overflows.

For large allocations, realloc can remap virtual memory instead of doing a naive copy:

http://blog.httrack.com/blog/2014/04/05/a-story-of-realloc-a...

A networking library based on Asio has been proposed for C++17. In the meantime, use Asio.

http://think-async.com/

> 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.

Which companies? That's pretty scary.

>A rotating disk is roughly able to saturate a 1Gb ethernet link.

Locality is key there. Read randomly and you won't saturate a 100Mb link.

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.

Yeah, but...

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.

Yeah, I'm not brave enough for embedded.

I'm still pretty excited about what's happening in this space though. Thanks for your thoughts.

I apologize if I gave the impression I was claiming otherwise. It's just context for the discussion.

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?)."

https://users.rust-lang.org/t/blog-rust-faster/3117/12?u=acc...

Ah, so Rust does represent thread semantics through types? It's curious that the authors don't mention that in their proposal.

Unmanaged native code definitely has an edge, even in I/O-heavy applications like databases.

http://www.scylladb.com/technology/cassandra-vs-scylla-bench...

Not to mention low-memory environments like mobile.

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?

Any thoughts on C++ coroutines? Microsoft has a draft implemented in their compiler, and there's a second competing proposal.

https://msdn.microsoft.com/en-us/magazine/mt573711.aspx

http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n445...

Ideally we'd implement something similar in Rust.

I think every OS does this to some extent. Windows uses DPCs, Linux uses tasklets.

Even with the intrinsics AES is pretty expensive

https://software.intel.com/en-us/articles/intel-aes-ni-perfo...

That might make you the biggest company using Rust? Very cool, I hope you write it up.

Oh OK, that's cool. I don't think many languages could enforce that.

I was thinking async-await, which I thought hasn't been standardized yet. Do generators provide the same functionality?

Either way, I hope Rust skips the callbacks.

Scope-bound resource management (SBRM) is clearer than RAII, I think.

And... how would that be possible at compile time?

50% C++, 25% Java

http://qr.ae/RP7wXh

At Google's scale, the performance difference between Java and C++ can means millions of dollars in electricity alone.

>Even Google mostly uses Java

I'm not so sure about that. The core services (e.g. Search, Maps, Earth, Big table, Map reduce) seem to be C++. Ads is possibly an exception.

A Node-style event loop leads to callback hell. It would be awesome to have something like Boost Asio.

New York manages

http://www.wsj.com/articles/construction-in-new-york-city-go...