Is this actually simulating a d20 with physics?
919 karma · joined August 6, 2019
Is this actually simulating a d20 with physics?
https://www.tinygnomes.com/qwiki.cgi?mode=previewSynd&uuid=B...
We had already known from autopsies that neural density in certain brain regions is much higher among autists.
This is somewhat mitigated by consistent consecutive error handling, meaning you always immediately dispatch an error on the line after assigning it. Every time we have had bugs because of this, it's because someone tried to be clever and delay handling an error until slightly later (like at the end of an if else chain where each branch might have had an error).
The reality is that the vast majority of error handling in go is to do one of two things
1) pass it up the stack 2) wrap it and pass it up the stack
The fact that you must do this explicitly in all cases is a failure of the language. Many people have pointed this out, but the go team and elite members in the community are very dedicated to the myth that every error is precious and special and must be handled in a one-off manner.
This is how we use most errors in our code base. But we tend to not treat them as sentinels, we are only interested in the descriptive error messages.
And yes, postgres is faster and will eventually pass MySQL in deployments, but that's success also has very little to do with its speed.
I agree with your point about debugging, but I have a different idea how to best achieve it. Rather than wrapping an error at every stack layer, just take a stack trace when the error is created. This works great as long as... you don't design the system to require sentinel errors. Treating errors as rare, exceptional events rather than normal values used for control flow changes how you approach them.
We have in the past eliminated sentinel errors and gotten measurable gains from doing so, but this is mostly because our errors were both common (occurring several times on every request) and expensive to construct. The direct cost of errors.Is() was minor compared to the cost of building the error itself.
And you might be surprised how common it is for people to insist on wrapping an error at every layer of the stack. I've gotten in arguments with these people online, they're out there.
The last section of the blog has a discussion of aesthetic and philosophical concerns around using errors for control flow. I'm against it, for the reasons I provide. YMMV.
Basically: the critical functions in the benchmark are small enough they were being inlined by the compiler, which means it's possible for the compiler to further optimize the loop to avoid all comparisons in some cases, producing an inaccurate result for some of the benchmarks. You can fix this by adding noinline directives to the methods.
I'll be publishing an update to the article and a post-mortem on how this slipped past review. The rank ordering of techniques in the article is unchanged, but the magnitude of the difference is not nearly so large.
They use DoltDB to version control their machine learning feature store:
And because I don't know, I don't have a strong opinion about it one way or the other. That's all "benefit of the doubt" means. "I don't know one way or the other, but this guy has a pretty good track record, so until I know more I won't assume anything bad."
explain select * from xy join uv on (x = u and u > 0) where u < 2;
Project
├─ columns: [xy.x:2!null, xy.y:3, uv.u:0!null, uv.v:1]
└─ LookupJoin
├─ IndexedTableAccess(uv)
│ ├─ index: [uv.u]
│ ├─ static: [{(0, 2)}]
│ ├─ colSet: (3,4)
│ ├─ tableId: 2
│ └─ Table
│ ├─ name: uv
│ └─ columns: [u v]
└─ IndexedTableAccess(xy)
├─ index: [xy.x]
├─ keys: [uv.u:0!null]
├─ colSet: (1,2)
├─ tableId: 1
└─ Table
├─ name: xy
└─ columns: [x y]