isidor3

Perhaps, but as far as I've seen they don't make the requirement go away. They do make many types of development far more accessible, as an extension of how SQL or Excel make development far more accessible. Sure, people make messes with the tools available, and sometimes the tools can handle it and still give you something useful, many times it takes someone actually knowing what they're doing to clean it up though.

Garbage collection and what the JIT decides to do often isn't.

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)

I found this series to be a great read on some of the history of Galileo and the status of scientific understanding at the time I believe part of it has made the rounds on hn before: http://tofspot.blogspot.com/2013/10/the-great-ptolemaic-smac...

An author at Ars Technica has been trying to push the term "confabulation" for this

You build 9 different services in-house, obviously.

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.

Maybe some personal enjoyment?

From that same post, though, referencing the C 11 standard

> "All pointers to structure types shall have the same representation and alignment requirements as each other."

And so the concern wouldn't apply to this pattern?

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.

If you scroll down to the bottom of the post, there is a references section with a link to it.

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?

Looks like Leap is the new focus of their development: https://github.com/ggandor/leap.nvim/issues/3

Because the next move made by your opponent would trivially be to capture your king, ending the game.

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.

> having one or two days per year which are part of no month is stupid > having one or two days per year with no day of the week is asinine

These don't sound like real reasons to me. If it costs having a 13th month with just a few days in it or a NO_DAY_OF_WEEK constant in my DAYS_OF_WEEK enum, I'd take it if it meant all of the weirdness was limited to a few days always located at the end of the year. Sounds like a convenient place to put leap seconds as well! While you're at it, make those days holidays for most people, so that when tech inevitably breaks due to the weirdness, those of us who get paged for such things can fix them in peace before the rest of the world starts back up a few days later.

It actually is though! The force due to air resistance is the primary thing slowing down the bike and rider, and the force, which doesn't change with mass, slows down a heavier bike less, and so a heavy bike will be rolling faster than a lighter one at the bottom of a hill, all other things being equal.

Heavier things do gain kinetic energy faster when falling, it's easy enough to confuse "being hard to stop" with "moving fast." Intuitively, the heavier object has "more" of something but in casual conversation "kinetic energy" isn't a common or familiar term. If you haven't studied enough physics to reach for that concept, I'm not surprised a lot of people just settle on "faster" when attempting to describe it.

My go-to would be "Do you know if sshd would work?" To me, framing it directly as a knowledge question, and to not appear as if you're coming from a place of authority (unless you know both their problem and your solution both well enough to solve it without running into edge cases, and how often does that happen?). They either know or they don't, or potentially have a reason for not trying in the first place. If they don't know and don't have a reason, it's a simple "well, that's what I'd try next, it could make things easy if it works" to get your suggestion out there, but you let them solve their problem (if it works...)

In APL and J at least, all operators have the same precedence, and always associate to the right, so there's never any ambiguity.

Yes, Lua was originally written as a language for rich configuration files and has grown out of that into a more fully featured language.

It's also one of the easier languages to sandbox, since you can evaluate user provided code in a custom environment that only contains the functions you deem safe. You can even use the standard debug hooks to set an upper limit on the number of instructions a script can execute to prevent someone from creating an infinite loop in a config file and locking whatever thread is reading the config.

It's not very appropriate as a data serialization format, or as machine written config, but the parent post specifically asked about human written configuration files.

Lua was written for exactly this purpose, and I personally enjoy writing with it, so it would be my first choice in most cases.