Data Processing Benchmark Featuring Rust, Go, Swift, Zig, Julia etc.

https://github.com/zupat/related_post_gen

by behnamoh • 6 months ago

143 115 6 months ago

pron15• 6 months ago

I was surprised to see that Java was slower than C++, but the Java code is run with `-XX:+UseSerialGC`, which is the slowest GC, meant to be used only on very small systems, and to optimise for memory footprint more than performance. Also, there's no heap size, which means it's hard to know what exactly is being measured. Java allows trading off CPU for RAM and vice-versa. It would be meaningful if an appropriate GC were used (Parallel, for this batch job) and with different heap sizes. If the rules say the program should take less than 8GB of RAM, then it's best to configure the heap to 8GB (or a little lower). Also, System.gc() shouldn't be invoked.

Don't know if that would make a difference, but that's how I'd run it, because in Java, the heap/GC configuration is an important part of the program and how it's actually executed.

Of course, the most recent JDK version should be used (I guess the most recent compiler version for all languages).

rockwotj• 6 months ago

It’s so hard to actually benchmark languages because it so much depends on the dataset, I am pretty sure with simdjson and some tricks I could write C++ (or Rust) that could top the leaderboard (see some of the techniques from the billion row challenge!).

tbh for silly benchmarks like this it will ultimately be hard to beat a language that compiles to machine code, due to jit warmup etc.

It’s hard to due benchmarks right, for example are you testing IO performance? are OS caches flushed between language runs? What kind of disk is used etc? Performance does not exist in a vacuum of just the language or algorithm.

pron15• 6 months ago

due to jit warmup

I think this harness actually uses JMH, which measures after warmup.

KerrAvon2• 6 months ago

Why are you surprised? Java always suffers from abstraction penalty for running on a VM. You should be surprised (and skeptical) if Java ever beats C++ on any benchmark.

woooooo2• 6 months ago

For the most naive code, if you're calling "new" multiple times per row, maybe Java benefits from out of band GC while C++ calls destructors and free() inline as things go out of scope?

Of course, if you're optimizing, you'll reuse buffers and objects in either language.

pron15• 6 months ago

The only "abstraction penalty" of "running on a VM" (by which I think you mean using a JIT compiler), is the warmup time of waiting for the JIT.

cryptos• 6 months ago

In the end, even Java code becomes machine code at some point (at least the hot paths).

Imustaskforhelp• 6 months ago

This is really interesting. Julia is a beast compared to python.

Nowadays whenever I see benchmarks of different languages. I really compare it to benjdd.com/languages or benjdd.com/languages2

Ended up creating a visualization of this data if anybody's interested

https://serjaimelannister.github.io/data-processing-benchmar...

(Given credits to both sources in the description of this repo)

(Also fair disclosure but it was generated just out of curiosity of how this benchmark data might look if it was on benjdd's ui and I used LLM's for this use case for prototyping purposes. The result looks pretty simiar imo for visualization so full credits to benjdd's awesome visualization, I just wanted this to be in that to see for myself but ended up having it open source/on github pages)

I think benjdd's on hackernews too so hi ben! Your websites really cool!

gus_massa• 6 months ago

Someone replied to me in an old comment that for fast Python you have to use numpy. In the folder there is a program in plain python, another with numpy and another with numba. I'm not sure why only one is shown in the data.

Disclaimer: I used numpy and numba, but my level is quite low. Almost as if I just type `import numpy as np` and hope the best.

another_twist3• 6 months ago

Almost as if I just type `import numpy as np` and hope the best.

As do we all. If you browse through deep learning code a large majority is tensor juggling.

SatvikBeri• 6 months ago

For what it's worth, I've ported a lot of heavily optimized numpy code to Julia for work, and consistently gotten 10x-100x speedups, largely due to how much easier it is to control memory allocations and parallelize more effectively.

Vaslo• 6 months ago

So in the D vs Zig vs Rust vs C fight - learn d if speed is your thing?

Ygg23• 6 months ago

That only applies in an apples-to-apples comparison, i.e., same data structures, same algorithm, etc. You can't compare sorting in C and Python, but use bubble sort in C and radix sort in Python.

In here there are different data structures being used.

D[HO] and Julia [HO] footnote: Uses specialized datastructures meant for demonstration purposes: more ↩ ↩2

makapuf• 6 months ago

You're right of course but it also depends on how long you want to spend on it. If Python gives you radix sort directly and the C implementation you can have with the same time is bubble sort because you spent much time setting up the project and finding the right libs it kinda makes sense.

hiccuphippo• 6 months ago

Don't know about D but C, Zig and Rust use LLVM so there should be no difference.

vips7L• 6 months ago

Depends on the D compiler. The reference compiler optimizes for compilation speed. LDC is backed by llvm and gdc by gcc.

jhack• 6 months ago

D gets no respect. It's a solid language with a lot of great features and conveniences compared to C++ but it barely gets a passing mention (if that) when language discussions pop up. I'd argue a lot of the problems people have with C++ are addressed with D but they have no idea.

rsyring• 6 months ago

Could say the same for Nim.

But popularity/awareness/ecosystem matter.

elcritch2• 6 months ago

That's the great thing about LLMs.

Especially with Nim it's so easy to make quality libraries with a Codex/ClaudeCode and a couple hours as a hobby.

Especially when they run fast. I just made Metal bindings and got 120 FPS demos with SDF bitmaps running yesterday while eating Saturday brunch.

Ygg23• 6 months ago

If the difference in performance between the target language and C++ is huge, it's probably not the language that's great, but some quirk of implementation.

maleldil• 6 months ago

Ecosystem isn't that great, and much of it relies on the GC. If you're going to move out of C++, you might as well go all in on a GC language (Java, C#, Go) or use Rust. D's value proposition isn't enough to compete with those languages.

hnlmorg• 6 months ago

D has a GC and it’s optional. Which should be the best of both worlds in theory.

Also D is older than Go and Rust and only a few months younger than C#. So the question then becomes “why weren’t people using D when your recommended alternatives weren’t an option?” Or “why use the alternatives (when they were new) when D already exists?”

chenzhekl• 6 months ago

Garbage collection has never been a major issue for most use cases. However, the Phobos vs. Tango and D1 vs. D2 splits severely slowed D’s adoption, causing it to miss the golden window before C++11, Go, and Rust emerged.

pjmlp2• 6 months ago

Tiny community, even more tinier than when Andrei Alexandrescu published the D book (he is now back to C++ at NVidia), lack of direction (it is always trying the next big thing that might atract users, leaving others behind not fully done), since 2010 other alternatives with big corp sponsoring came up, others like Java and C# gained the AOT and improved their low level programing capabilities.

Thus, it makes very little sense to adopt D versus other managed compiled languages.

The language and community are cool, sadly that is not enough.

ekianjo3• 6 months ago

Data processing benchmark but somehow R is not even mentioned?

mcdermott2• 6 months ago

It would be the slowest language result on the list.

ekianjo3• 6 months ago

Slower than Python? I seriously doubt that

pyrolistical2• 6 months ago

That’s odd zig concurrent got slower

another_twist3• 6 months ago

Contention overhead likely. Performance is more than just the langauge.

pyrolistical2• 6 months ago

Also 3 years old. Zig has been rewritten in that time

piskov2• 6 months ago

C# is very fast (see multicore rating). Implementation based on simd (vector), memory spans, stackalloc, source generators and what have you — modern C# allows you go very low-level and very fast.

Probably even faster under .net 10.

Though using stopwatch for benchmark is killing me :-) Wonder if multiple runs via benchmarkdotnet would show better times (also due to jit optimizations). For example, Java code had more warm-up iterations before measuring

von_lohengramm2• 6 months ago

This entire benchmark is frankly a joke. As other commenters have pointed out, the compiler flags make no sense, they use pretty egregious ways to measure performance, and ancient versions are being used across the board. Worst of all, the code quality in each sample is extremely variable and some are _really_ bad.

another_twist3• 6 months ago

I mean this is only meant to be an iteration if I understand correctly. Its not like someone is going around citing this benchmark yelling rewrite everything in Julia / D. Imo this is a good starting point if you are doubtful or fall into the trap of Java is not fast. For most workloads we can clearly see, Java trades off the control of C++ for "about the same speed" and much much larger and well managed ecosystem. (Except for the other day, when someones OpenJDK PR was left hanging for a month which I am not sure why).

nnevatie• 6 months ago

If you get the same speeds for C++ and Java, I'd like to point out that the C++ implementation is likely very sub-optimal.

This can obviously be true for toy problems, but tends not to generalize.

inkyoto• 6 months ago

Quality does vary wildly because the languages vary wildly in terms of language constructs and standard libraries. Proficiency in every.single.language. used in the benchmark perhaps should not be taken for granted.

But it is an GitHub repository and the repository owner appears to accept PR's and allows people to raise an issue to provide their feedback, or… it can be forked and improved upon. Feel free to jump in and contribute to make it a better benchmark that will not be «frankly a joke» or «_really_ bad».

von_lohengramm2• 6 months ago

I'm completely alright with just having fun and hosting your own little sandboxes online, but what good does it do to post and share this with others in its current state? The picture it paints is certainly not representative, and this sort of thing has been done a million times over with much better consistency. Again, I think it's great to hack around in every language and document your journey all the way, but sharing this is borderline misinformation. It's certainly not my duty to right the wrongs of this benchmark.

ahartmetz2• 6 months ago

About the C++ version: You have to be an absolute weirdo to (sometimes) put the opening brace of functions on the same line, but on the next line for if and for bodies.

galangalalgol7• 6 months ago

I think there was a name for that brace style? It seems silly, but leaving c++ development after decades for a variety of reasons, it turned out a standard formatting tool was one of my favorite features.

dwroberts• 6 months ago

Some of the rules seem very arbitrary too

Must: Represent tags as strings

Provided the correct result is generated I don't get the rationale for this one. As long as you obey the other rule for UTF-8 compatibility, why would it be a problem to represent as bytes (or anything else)?

Seems like it would put e.g. GC'ed languages where strings are immutable at a big disadvantage

elisbce• 6 months ago

Totally agree. I found the results surprising because a bunch of languages are faster than C++. Then I looked closer. The requirements are self-conflicting, No SIMD, but must be production-ready. No one would use the unoptimized version in production. Also looking at the C++ implementation, they are not optimized at all. This makes this benchmark literally pointless.

matthewfcarlson• 6 months ago

I see some questions around the methodology of the testing. But is this representative of Ruby? Several minutes total when most finish under a second?

igouy7• 6 months ago

fyi

https://benchmarksgame-team.pages.debian.net/benchmarksgame/...

aatd86• 6 months ago

Isn't that measuring the speed of json encoding instead?

KerrAvon2• 6 months ago

Genuine question: Are GitHub workflows stable enough to be used for benchmarking? Like CPU time quantum scheduling is guaranteed to be the same from run to run?

vlovich123• 6 months ago

No, it’s sloppy benchmarking

jasonjmcghee• 6 months ago

What's up with the massive jump for 20k to 60k for nearly all languages?

foota• 6 months ago

My guess would be cache related. 5k probably fits in L1-L2 cache, whereas 20k might put you into L3.

XJ6w9dTdM• 6 months ago

I was very surprised to see the results for common lisp. As I scrolled down I just figured that the language was not included until I saw it down there. I would have guessed SBCL to be much faster. I checked it out locally and got: Rust 9ms, D: 16ms, and CL: 80ms.

Looking at the implementation, only adding type annotations, there was a ~10% improvement. Then the tag-map using vectors as values which is more appropriate than lists (imo) gave a 40% improvement over the initial version. By additionally cutting a few allocations, the total time is halved. I'm guessing other languages will have similar easy improvements.

sergiotapia• 6 months ago

I wrote a script (now an app basically haha) to migrate data from EMR #1 to EMR #2 and I chose Nim because it feels like Python but it's fast as hell. Claude Code did a fine job understanding and writing Nim especially when I gave it more explicit instructions in the system prompt.

gethly2• 6 months ago

Go being beaten by C# in multicore is quite hard to believe. Also Zig and Odin doing so "poorly" in single core is strange.

osmsucks• 6 months ago

The quality of the benchmark code is... not great. This seems like Zig written by someone who doesn't know Zig or asked Claude to write it for them. Hell, actually Claude might do a better job here.

In short, I wouldn't trust these results for anything concrete. If you're evaluating which language is a better fit for your problem, craft your own benchmark tailored for that problem instead.

gethly2• 6 months ago

So far, the best benchmark seems to be the https://plummerssoftwarellc.github.io/PrimeView/

Although it is very single-thread biased test.

DeathArrow2• 6 months ago

Go is beaten constantly by C# in both Benchmark Game and Techempower benchmarks.

mrsmrtss• 6 months ago

I don't know why this is downvoted, because the statement is not wrong (https://benchmarksgame-team.pages.debian.net/benchmarksgame/...). Times have changed, modern .NET is very fast and is getting faster still (https://devblogs.microsoft.com/dotnet/performance-improvemen...).

piskov2• 6 months ago

Modern c# has many low level knobs (still in a safe way; though it also supports unsafe) for zero allocation, hardware intrinsics, devirtualization of calls at runtime, etc.: simd (vector), memory spans, stackalloc, source generators (helps with very efficient json), etc.

Most of all: C# has a very nice framework and tooling (Rider).

kdps2• 6 months ago

It's not really surprising given the implementations. The C# stdlib just exposes more low-level levers here (quick look, correct me if I'm wrong):

For one, the C# code is explicitly using SIMD (System.Numerics.Vector) to process blocks, whereas Go is doing it scalar. It also uses a read-only FrozenDictionary which is heavily optimized for fast lookups compared to a standard map. Parallel.For effectively maps to OS threads, avoiding the Go scheduler's overhead (like preemption every few ms) which is small but still unnecessary for pure number crunching. But a bigger bottleneck is probably synchronization: The Go version writes to a channel in every iteration. Even buffered, that implies internal locking/mutex contention. C# is just writing to pre-allocated memory indices on unrelated disjoint chunks, so there's no synchronization at all.

freeopinion2• 6 months ago

In other words the benchmark doesn't even use the same hardware for each run?

Quothling• 6 months ago

C# is great, but look at the implementations. The jvm is set up wrong, so JAVA could perform better than what is benchmarked. Hell with Python you'd probably use Celery or numpy or ctypes to do this much faster.

So overall the benchmarks are kind of useless.

dnautics• 6 months ago

Zig's being compiled in "releasesafe" so lots of bounds checking going on.

hgs3• 6 months ago

Why is there no C benchmark? The C++ benchmark appears to be "modern C++" which isn't a substitute.

jakobnissen• 6 months ago

The fact that Julia “highly optimized” is 30x faster than the normal Julia implementation, yet still fails to reach for some pretty obvious optimizations, and uses a joke package called “SuperDataStructures” tells me that maybe this benchmark shouldn’t be taken all that seriously.

Benchmarks like this can still be fun and informative

stu2421• 6 months ago

For comparison here's one from Dec '25

https://niklas-heer.github.io/speed-comparison

Certainly does "look" very interesting.

boroboro43• 6 months ago

This one doesn’t even have warmup for Java, which makes results complete non sense.

Those benchmarks should be just forbidden for their misleading nature.

igouy7• 6 months ago

How much difference does it make for tiny programs?

https://benchmarksgame-team.pages.debian.net/benchmarksgame/...

debois2• 6 months ago

The study seems to be “solve this the obvious way, don’t think too hard about it”. Then the systems languages (C, Zig, C++) are pretty close, the GC languages are around an order of magnitude slower (C#, Java doing pretty good at ca. 3x), and the scripting languages around two orders of magnitude slower.

But note the HO-variants: with better algorithms, you can shave off two orders of magnitude.

So if you’re open to thinking a bit harder about the problem, maybe your badly benchmarking language is just fine after all.

dadoum• 6 months ago

D is a GC language too so the pattern does not hold that well.

dvfjsdhgfv• 6 months ago

Then the systems languages (C, Zig, C++) are pretty close

I'm sorry, I don't see C among the results.

debois2• 6 months ago

My mistake, sorry. Same for D above.

Point stands, though: if your language is too far down the list, better algorithms might be enough.

igouy7• 6 months ago

on HN 2 years ago

https://news.ycombinator.com/item?id=37848571

? unchanged from 7 months ago

Someone2• 6 months ago

Rules:
MUST
Support up to 100 tags
Represent tags as strings

That doesn’t require the strings that represent the tags to be the tag strings, So, one can bend the rules by representing tags by single-character strings or, alternatively, by using fixed strings of length 0 through 99, and then doing the tag comparisons only on the first character of each string or, alternatively, the length of the string (if obtaining that is fast)

Especially when tags have large common prefixes, that could speed up things tremendously.

In languages that support string interning (https://en.wikipedia.org/wiki/String_interning), I suspect that also could be used to bend the rules.

DeathArrow2• 6 months ago

If people don't find their preferred language on top, they will claim the benchmark is flawed. They will find a condition that is not satisfied by the benchmark. But if we operate outside of the benchmarks assumptions, all benchmarks are flawed since they cannot satisfy all possible conditions.

Data Processing Benchmark Featuring Rust, Go, Swift, Zig, Julia etc.

Related Stories