Rust refs are not OCaml refs though. Rust just places more guardrails around update-in-place model, instead of using controlled references to immutable data like OCaml (and Clojure).
Thanks for explaining!
To me Rama looks so high level, that somebody feeling the pain of not having it should be launching new projects all the time, like a consultancy.
IMO the main difference between downstroke and alternate picking is that at the same tempo downstroke will have 2 times shorter attack, because the player will have to move their hand 2 times faster.
For stuff like this we used in-memory ring buffer logger that printed the logs on request. And it didn't save the strings, just necessary data bits and a pointer to formatting function. Writing to this logger didn't affect any timings.
Rust code emitter is Clang, the same one that Apple uses for C on their platforms. I wouldn't expect any miracles there, as Rust authors have zero influence over it. If any compiler is using any secret Clang magic, that would be Swift or Objective-C, since they are developed by Apple.
Totally agree about reasons, they have some hidden agenda behind this decision that they don't want to disclose. Rewriting in native code allows step-by-step rewrite using JS runtime with native extensions, but moving to a different VM mandates big rewrite.
My most plausible guess would be that compiler writers don't want to dig into native code and performance, writing a TS to Go translator looks like a more familiar task for them. Lack of JS version performance analysis anywhere in the announcements kinda confirms this.
Mapping between reactive variable and DOM element. I first heard this term in Million.js docs, but it explains very well what most 'reactive' frameworks are doing. For example, a Signal creates the mapping at runtime on first render.
Looked at SolidJS, it's primary mechanism is signals, which are essentially runtime edit maps. They have the same downside as all other types of edit maps - programmer needs to compose them manually, which becomes messy very quickly with loops and conditions.
> It looks like the US wants a regime change in Ukraine, it's possible that this became a pre condition from russia for talks to go forward.
It's not just possible, it was stated openly multiple times by Russian diplomats. The official position is: anything signed by Zelensky has potential to be invalidated later, because according to constitution of Ukraine he is not a legitimate president anymore. So this legal loophole should be removed before signing any agreements.
I think by 'we' Dugin meant 'anti-globalists', not Russia. There are pro-globalists in Russia and anti-globalists outside of Russia, so one doesn't equal the other.
Ok, I see now. This is limited to cases when compiler can prove that the reference is not shared, but still can be useful when adding elements to collections.
This is interesting. If I want my object to be movable without the need for acquiring the locks for all outbound references, I need my references to be of type 'reference to mutable data'. So that could be one of the reasons why Rust reference types are like this.
But what happens to inbound references when I'm moving my object? Who is in charge of updating them?
So, the speedrun author claimed it was RNG-edited, but it was level edited instead? The author could easily refute that by providing the RNG seed. I think every run that claims to be RNG-edited should post RNG seed for verification. If the author claimed that the run was unedited and it was 'just luck', I'm surprised that anyone believed him in the first place.