Hacker News Reader

acconstaon SARS-CoV-2 variant A.30 is heavily mutated and evades vaccine-induced antibodies

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.

acconstaon Dropbox Reaches Key Profit Milestone

How about when they were buying those DCs?

acconstaon Regex: badly needs fuzzing

> modern C++

This library is old enough to drive...

acconstaon Simple coroutines for games in C++

Google implemented fibers. Hopefully they'll get upstreamed.

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

acconstaon Glibc getaddrinfo stack-based buffer overflow

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

acconstaon Once upon a time, memory allocators made sense

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

acconstaon Writing high-performance servers in modern C++

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

http://think-async.com/

acconstaon How Completely Messed Up Practices Become Normal

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

acconstaon System design implications of declining network latency vs. disk latency

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

acconstaon Time Structured Merge Tree: From LSM Tree to B+Tree and Back Again

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.

acconstaon Time Structured Merge Tree: From LSM Tree to B+Tree and Back Again

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.

acconstaon Experiences Building an OS in Rust

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.

acconstaon Rust Faster

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

acconstaon Rust Faster

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

acconstaon Experiences Building an OS in Rust

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

acconstaon Windows 10 and .NET Native

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.

acconstaon Experiences Building an OS in Rust

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?

acconstaon Experiences Building an OS in Rust

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.

acconstaon Experiences Building an OS in Rust

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

acconstaon Pushing the Limits of Kernel Networking

Even with the intrinsics AES is pretty expensive

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

acconstaon Trying Rust for web services

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

acconstaon My gamedever wishlist for Rust

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

acconstaon Trying Rust for web services

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.

acconstaon Trying Rust for web services

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

acconstaon My gamedever wishlist for Rust

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

acconstaon Trying Rust for web services

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.

acconstaon Trying Rust for web services

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

acconstaon Trying Rust for web services

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

acconstaon Employees at Airbnb, Square and Stripe Are Spending 50%+ of Income on SF Rent

New York manages

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

acconstaon Redox: A Rust Operating System

Hello! I think it's possible to encapsulate unsafe pointer operations so they're only required in memory allocation, I/O primitives, and device DMA. I'll open a github issue or two with thoughts.

Out of curiosity, are you modeling this on an existing code base/architecture, or is this a new design?