I’ve been thinking about learning a new lang recently, and while Julia does seem to be a real alternative to python for analysis, I can’t see how ergonomic it would be for simple (or convoluted, why not?) scripts.
The reverse keeps me from investing more time in Go (and Rust), though
For scripts, the JIT overhead has gotten a lot better, and I think it will continue to improve. The strategy is saving more so that it doesn't have to get recompiled on launch. That currently doesn't happen for packages. Which means while R and Python run much slower, they feel much snappier -- and will be much faster if you're just running a bunch of short scripts that wont amortize compilation. So in the short term, I wouldn't use Julia for speed.
Multiple dispatch and powerful meta-programming are two other major highlights. Multiple dispatch can make for much simpler, cleaner looking syntax, while often making it easier to remember too -- you only need one name per concept. I briefly compared explicit SIMD vectorization in Julia and C here: https://bayeswatch.org/2018/08/08/matrix-multiplication-kern... were I to change the vector size, all that'd take in Julia is changing the number of elements, and it'll dispatch correctly. In C... I don't have too much experience with object oriented programming which gives single dispatch, but I like the separation of functions from objects, and freedom of dispatching on any/all of the arguments.
If metaprogramming appeals to you, Julia makes that really easy compared to many other languages, with things like the `@eval` macro or `@generated` functions. Any sort of repetitive pattern that isn't easily expressed in array operations can probably be handled pretty simply with metaprogramming. I gave an example of `@generated` in the blog post with matrix multiplication kernels, and a great example of `@eval` is: https://github.com/JuliaDiff/ForwardDiff.jl/blob/master/src/...
In that link, ForwardDiff defines a gazillion function overloads for dual numbers for automatic differentiation.
Being an interactive language, plus the helpful macro `@macroexpand`, can make it easy to explore and figure out what's going on if you like playing with that sort of stuff.
I've heard loads of great things about Rust, too. Hope this helps decide if its worth looking at. My examples were all still analysis-focused, but that's my experience.
The one domain I’d say it’s not suited for is embedded systems where you have very tight memory restrictions but I expect that to improve soon as well.