I was hoping from the title that this would be about creating an audio representation so you could listen to the database work as if it were an old PC that had distinctive sounds for different tasks
I do think it's important to raise issues like this, but I personally hope that it means people put more careful eyes on it and pitch in patches so the project succeeds rather than people avoiding it.
(totally unbiased opinion from having just switched to it after apparently not enough research and not wanting to continue the browser hunt)
From playing games that get that distance wrong, it doesn't give me a headache or anything, it just makes the whole world feel bigger or smaller than reality. Really frustrating in games that try to replicate a real feeling. In a driving sim, for example, it can make you feel like you're driving a toy car rather than a full sized one, or that you're a kid in the seat of your parents car. Obviously not a feeling you want to invoke unintentionally, but perhaps there's ways in software to adjust?
Plotting the average or top percentile latency of an API on the left axis and the number of calls to that API on the right is pretty much standard practice where I work. I would argue it makes things more clear. You get to see exactly how the latency changed as the traffic does, or where more noise is visible because the traffic was low.
Because both scales are using completely different units it's more difficult to confuse the two.
While this is an interesting project and work, I do want to call attention to the fact that this is a highly specialized AI that's trained and customized per-track that is being raced on. It's not a generic one that can beat humans (or even make it to the finish line) on a random track that you plop it down on.
Impressive work though, and amazing what the community as a whole has accomplished for even enabling this sort of thing to be done. Doubly so on a game that as far as I'm aware doesn't have anything to enable API access that would make training this model easy without all the tools that have been developed for it in the endless quest for more speed.
Users of cars pretty routinely replace seals that are under a lot more extreme enviroments and abuse than a phone without issue. All of the ones I've dealt with pretty much are "just a gasket and a few screws" Sure, there needs to be some design process to get there, but let's not pretend that doing this would be some unheard of technological advancement.
Sounds like the torpedoes were armed, but not yet fired. So the sub itself turning around in a circle triggered the self-destruct mechanism while the weapons were still in the tubes.
Yes, and obviously ARM didn't chose the instructions in its reduced set optimally, if the best implementations require those instructions to be split into smaller ones. But that doesn't really speak to if that's because it's just better to pack instructions that way, or because these implementations of ARM and x86 just need to do it to be performant in spite of deficiencies in their instruction sets.
It is interesting to me how both instruction sets have converged on splitting operations into simpler micro ops. The author briefly mentions RISC-V as having "better" core instructions, but it makes me wonder if having the best possible instructions would even help that much.
If you made a CPU that directly ran off of some convergent microcode, would you then lose because of bandwidth of getting those instructions to the chip? Or is compressing instruction streams already a pretty-well-solved problem if you're able to do it from a clean slate, instead of being tied to what instruction representations a chip happened to be using many years ago?
I wrote a little solver for some programming puzzle. Thought I was being clever by using bitfields for an array of booleans to reduce memory usage and bandwidth, as they seemed a natural fit for the problem I was solving.
Turned out that it was actually significantly faster to use one byte per boolean and forgo the masking operations. I assume the processor was just good enough at keeping its cache filled in that particular workload, so the additional masking operations just slowed things down. So I understand why you might not want a compiler to automatically do this.
The most "complicated" part about operator overloading (in my opinion) is dealing with precedence rules. Some languages, instead of dealing with this complexity, treat all operators the same. Lisp-like languages, for instance, by way of how the programs are structured, doesn't need rules for precedence. APL/J just does away with any idea of precedence and instead each operator acts on the result of the expression to its right. This breaks common arithmetic rules (2 * 2 + 2 evaluates to 8, for example), but I wonder if a language otherwise like C/C#/Java ditched precedence and allowed custom and overridable operators, if the result would be a lot less complex overall than some of the messes that can be found in C++.
I've never played Diplomacy, only read about it. But, I feel like you don't have to convince your opponents that you're human to win. The players could know that their opponent is a bot and still attempt to strategize with it, game the A.I. to get it onto their side, etc.
I suppose everyone might gang up on the A.I. immediately, but I don't think it's necessarily a forgone conclusion that they do.