In your case, you could have a channel where the Receiver is the only part of the code that transfers anything. It'd receive a message Transfer { from: Account, to: Account, amount: Amount } and do the required work. Any other threads would therefore only have copies of the Sender handle. Concurrent sends would be serialized through the queue's buffering.

I'm not suggesting this is an ideal way of doing it

scog aims to solve this: you write one simple YAML file describing your CLI and it generates proper completion scripts for all three shells.

It's built on clap's battle tested generators, so you get proven, quality completions without maintaining shell-specific scripts

Suggestions welcome ;)

Comments URL: https://news.ycombinator.com/item?id=45688422

Points: 4

# Comments: 1

From his Wikipedia article:

``` In an online blitz tournament hosted by the Internet Chess Club in May 2015, American Grandmaster Hikaru Nakamura accused Supi of cheating (Supi had defeated Nakamura).[2] The tournament judges accepted Nakamura's accusation, reverted the match's result, and banned Supi from the tournament. Brazilian Grandmaster Rafael Leitão wrote in his personal website, "Accusing him of using an engine in this match is absurd. The match is full of tactical mistakes. Nakamura played extremely poorly and, honestly, wouldn't have survived long against any engine given his terrible opening.". ```

Some years later Nakamura lost 4-0 and again insinuated that GM Supi used an engine.

Despite all that, Nakamura still published a video calling him a "legend" for once beating Magnus in 18 moves

Funny, because that's not anywhere close to what the comment you're replying to states.

They said `"Safety" is just a shorthand for "my program means what I say"`. That's a reasonable explanation: the code you wrote is not working exactly as you intended, due to some sort of unknown behavior.

The "bug" you're talking about would be the program doing exactly what you implemented, but what you implemented is wrong. The difference is so obvious that it's hard to think that you're engaging in a good faith argument.

Would you also say the same for a C++ project that uses shared_ptrs everywhere?

The clone quip doesn't work super well when comparing to C++ since that language "clones" data implicitly all the time

I struggled with Rust at first but now it feels quite natural, and is the language I use at work and for my open-source work.

I was not "mentally deficient" when I struggled with Rust (at least that I know of :v), while you could say I had a skill issue with the language

I work for an American startup, remotely from S. America. I'm hired according to the (extensive, and expensive) local labor laws, while my startup likely knows absolutely nothing about the intricacies of how my countries' labor laws work, the EoR just handles everything and sends the employer a bill every month.

pglite.dev/repl does not have the same level of visualizations as postgres.new.

What I 'want' is exactly what I described in my previous message, postgres.new but without the required LLM integration, the same sentiment others had in this thread.

They mention stuff like "an interpreter which translates the [JavaScript] code but locks it up in a cage"¹, their presentation² mention JS interpreters and a JS AoT compiler, so I'm not really sure how they did it

¹: https://www.radicalfishgames.com/?p=6892 ²: https://www.youtube.com/watch?v=KfBzlzvt8RU

People are naturally going to compare the timings and function you cite to what's available to the community right now, though, that's the only way we can picture its performance in real-life tasks.

> Mojo or other languages, specifically because it generates hate

Mojo launched comparing itself to Python and didn't generate much hate, it seems, but I digress

In any case, I hope Bend and HVM can continue to improve even further, it's always nice to see projects like those, specially from another Brazilian

While that's true, Python would be using big integers (PyLongObject) for most of the computations, meaning every number gets allocated on the heap.

If we use a Python implementation that would avoid this, like PyPy or Cython, the results change significantly:

    % cat sum.py 
    def sum(depth, x):
        if depth == 0:
            return x
        else:
            fst = sum(depth-1, x*2+0) # adds the fst half
            snd = sum(depth-1, x*2+1) # adds the snd half
        return fst + snd

    if __name__ == '__main__':
        print(sum(30, 0))

    % time pypy sum.py
    576460751766552576
    pypy sum.py  4.26s user 0.06s system 96% cpu 4.464 total

[Edit: just noticed the previous comment had already mentioned pypy]

> I'm aware it is 2x slower on non-Apple CPUs.

Do you know why? As far as I can tell, HVM has no aarch64/Apple-specific code. Could it be because Apple Silicon has wider decode blocks?

> can be underwhelming, and I understand if you don't believe on my words

I don't think anyone wants to rain on your parade, but extraordinary claims require extraordinary evidence.

The work you've done in Bend and HVM sounds impressive, but I feel the benchmarks need more evaluation/scrutiny. Since your main competitor would be Mojo and not Python, comparisons to Mojo would be nice as well.

https://man7.org/linux/man-pages/man7/vdso.7.html