Julia: Performance Tips (docs.julialang.org)

Legitimate and honest question: in which circumstances would you choose Julia over more mainstream alternative like Go?

There is also a section of Modern Julia Workflows [1] about optimisation that gives helpful, practical advice.

[1] https://modernjuliaworkflows.org/optimizing/

I love Julia. It's a fun language, LLMs write it better than they write Python.

Back in the day I had trouble convincing my C++ friends to give Julia a try, because Julia's garbage collector was a showstopper. But if you follow these performance tips related to pre-allocation, in-place mutation, avoiding temporary allocations (and maybe avoiding cycling references), you don't struggle with GC performance issues.

Looking back, I think the tooling Julia had from the start, combined with the REPL, made it actually really nice to fix these performance issues. Much better than compiling and linking a binary and running it through some heap profiler tool. You could simply do

    julia> @time f()
      x.y seconds (N allocations: M bytes)

and iteratively improve part of the code base instead of profiling the entire application.

(To be fair: back then escape analysis was not implemented in the compiler, and it was hard to avoid silly allocations)

My PhD advisor demanded I use Julia for my dissertation. Back then I was a junior programmer so Julia's one-based indexing absolutely threw me off.

In retrospect, the PhD experience was miserable and using Julia contributed to my 'death by a thousand cuts'.

For newcomers my main tip is to use views for array slices (for example, via the @view and @views macros), since by default Julia creates copies of slices. Broadcast operation (the dot syntax) is another super useful instrument for speeding up vectorized operations. You can write fast GPU code with them without resorting to GPU kernels, in some cases. Although GPU kernel programming via CUDA.jl is convenient in Julia, once you get used to it.

We have been running benchmarks to compare different languages relevant to high-performance computing and unfortunately Julia still lags behind even Numba-JIT-compiled Python. Perhaps my understanding of Julia is limited, but even the Rodinia SRAD program, which was originally written in Julia, performs faster in all other implementations that aren't Julia.

there is still no vmap-like operation for GPUs in julia, right? How's Reactant coming along?