related_post_gen

Looks like the HO means hand optimized, with special datastructures for this benchmark. see: https://github.com/jinyus/related_post_gen/#user-content-fn-...

The article links to a presumably extremely specialised benchmark[0] with some surprising results. To me as a simple dev, at least: Java (JIT) beats C++ and even Scala. What is Julia HO and why is it so ridiculously fast? The speed difference between Python and Pypy is massive. Is there any reason not to use Pypy? Shouldn't it be the standard? [0] https://github.com/jinyus/related_post_gen/

There is one for data processing here: https://github.com/jinyus/related_post_gen

Is it ready for benchmarking? D currently sits at the top of https://github.com/jinyus/related_post_gen and it would be interesting to see how neat stacks up.

It's most likely just reference counting and the way abstractions work in Swift (dynamic dispatch?). In particular, it still loses to C# even if you use AOT for the latter, especially in multi-threaded scenarios. HotSpot C2 and .NET Dynamic PGO-optimized compilations first and foremost help to devirtualize heavy abstractions and inline methods that are unprofitable to inline unconditionally under JIT constraints, with C2 probably doing more heavy lifting because JVM defaults to virtual calls and .NET defaults to non-virtual. With that said, I am not aware of any comprehensive benchmarking suites that would explore in-depth differences between these languages/platforms for writing a sample yet complex application and my feedback stems mostly from microbenchmark-ish workloads e.g. [0][1]. Performance aside, I do want to compliment Swift for

There is no such thing as a free lunch :) Modern GC implementations offer an important advantage - very cheap allocations and batched deallocations which allow to sustain high allocation traffic that goes through the heap. This comes at a cost of non-deterministic memory usage and object de-allocation. Further tradeoff is made between GC pause times, allocation throttling (Go) and even higher memory footprint (ZGC). My knowledge on the exact overhead of Swift's reference counting is very limited but there's a good chance it comes with significant upfront cost that you don't have to pay in languages with GC or with compile-time-defined allocation semantics (Rust and C++ RAII). There's a reason why Apple invested in atomics being as cheap[0] as they are on their ARM64 cores. Overall, every time I find Swift benchmark numbers on the internet

I think my benchmark[1] would be a great test for this. The jq[2] version takes 50s on my machine. [1] : https://github.com/jinyus/related_post_gen [2]: https://github.com/jinyus/related_post_gen/blob/main/jq/rela...

Fast compilation, Fast runtime, Easy to learn, Easy to distribute, Easy concurrency. ps: I wrote a data processing benchmark[1] and go is currently leading the charts. I ported it to c++ but it's not performing as expected. Take a look if you have the time. [1]: https://github.com/jinyus/related_post_gen

The arrows that iterate through the steps is great UX. I'm new to both array and stack based programming and it was pretty intuitive. How would I go about file i/o and parsing json? I have a data processing benchmark[1] that I'd like to use this for. [1] : https://github.com/jinyus/related_post_gen