neeeeees

To repurpose a famous quote - all benchmarks are wrong, but some are useful

I think so but it doesn’t really matter. It’s far faster to apply at the border anyway.

This is not remotely true. The gap between them as players far exceeds the gap elsewhere, combined, many times over.

People forget Kerr was a bad GM

On one of these less forgiving architectures, how does one write programs that read some bytes off the network, bitcast them into a struct, and do something based on that?

On x86 you would use a packed struct that matches the wire protocol.

Wouldn’t this require extra copying if member reads were forced to be aligned?

Quite the opposite actually. Simons and similar practitioners eschewed fundamental valuation techniques. Buffett is possibly a better example.

To add, the set of observable mutations (beneficial or not) that occur as a result of a single point mutation is in all likelihood an extremely tiny subset of the set of all observable mutations - even after “deduping” for the observed effect.

It’s an intentionally misleading tweet.

To simplify, It’s saying, if the genome were a string of some length, for any possible byte b and byte position i, there exists a person whose genome has b at position i. Unlike normal character strings, there are only 20 or so valid characters (proteins) encoded by 3 “bytes” (nucleotides) each. So you’re looking at O(10 billion) values of (i, b) that would still keep the string well-formed in its 3-bytes-per-character encoding.

Most importantly, it’s not saying anything about having some bytes b1 and b2 at the ith and jth positions or any generalization thereof.

Ah okay that makes sense to me

Interesting - is there a type safe way to do this? vector<variant<>>? and/or a custom “vector allocator” to hide the details?

> CMake doesn't fetch your dependencies for you and ensure they're the version that your code is compatible with.

That’s a little too harsh. You can certainly make it do that via a combination of git tags (to build from source) and CMake modules/Find*, but yes, it’s much more cumbersome than cargo/npm/go

Very cool! What tool did you use to simulate this? What does the code/query (if any) look like?

(Author here) Thanks for explaining this more succinctly than I can :)

Just one nitpick:

> decent amount of stuff that has to be done in main before you run _start

should read

> decent amount of stuff that has to be done in _start before you run main

Analogously, cleanup code like running global destructors usually happens in _start/CRT after main returns, but I skipped that in the post for the sake of brevity.

Interesting! I liked the configurability, but it was horribly slow with SSL. Possibly due to uncached DNS lookups but I didn’t dig too deep.

Good answer. OP didn’t specify “blew your mind in a good way”.

Out of curiosity, what field do you work in that a couple of cycles matters/is measurable?

How do you turn this on?

“s '1,$ s/foo/bar/' file.txt”. should be replacement from 1 to end, not 5 to end (#4 on your list)

Typo in the first code snippet:

> model.get('get')

did you instead mean:

> model.get('age')

Neat! Forgive my ignorance, but what does a perfect hash table (which I came across by skimming your project) buy the user? Even with distinct hashes, is there a way to enable random access to the element without an arbitrarily large array?

> they are slow when not thrown

I thought the not-thrown case was pretty much zero-cost, at least in newer versions of Clang... How much of a slow down are we talking here?

Looking forward to grabbing a physical copy of this book. As a beginner, CI and Alex Aiken’s course at Stanford were a great place to start.

Bob also gave me a lot of insight on what it’s like working on programming languages in the industry when I reached out to him as an undergrad.

This is very [very] similar to https://opslevel.com

Hey everyone, I wanted to build a tool like this to clearly illustrate how 'code is just data' - something a lot of students in a class I TA'd struggled to grasp. Everything in CUTE centers around a memory array with disassembly overlay, and each word being editable. It's still a little rough around the edges (e.g - the assembler doesn't catch many syntactic errors which aren't hard to detect), but I wanted to get some early feedback!

Looks pretty cool! Couple of questions:

- Is there a story behind the name?

- Out of curiosity, does “Encore Cloud” also run on AWS?

- I think a lot of developers have a mentality of “rather write boilerplate than be tied to a platform not endorsed by $bigCompany”. Do you have a strategy to mitigate this?

Congrats on the milestone!

I hope it’s okay to ask a technical question:

How did you build push notifications (especially on mobile) with a single codebase? Do you use something like OneSignal?

Also, is your iOS app still using Cordova? It looks and feels so nice, which is a marked difference from the last time I tried that framework.

So you’re telling me... To understand recursion you should first understand ecursion ? :)

I think I can answer part of this. I worked on building GraphQL APIs dynamically from Rails models as sort of a pet-project at Shopify a few years ago.

It’s not a difficult task, but when discussing viability with the APIs team, the general consensus was that you don’t want your API coupled to your data. Most of the time, you don’t want to expose everything.

Of course, you can start describing what to omit, but now you’re just writing an API design by omission.

Building good APIs is hard, so you want to build the right abstraction - which is not always the easiest one.

Not sure why you’re getting downvoted. A little harsh and hyperbolic , sure, but their website has become an unusable joke in recent years.

FLT_ESPILON is the bound on rounding error for certain operations. Plenty of numbers smaller than it can be represented in most floating point implementations

Ah I see, thanks for explaining