And slower (to start) than both of them. I tried julia to write some scripts that were previously in numpy, but the slow start threw me off. I hope they solve this because it's a great language.
I do wish that Julia would start up in an interpreted mode and compile in the background so that it would be fast enough when first opened and then attain maximum speed later on. (I think this is how JavaScript engines work?)
The problem with Julia tooling in general is that they feel 90% done. And tooling is, in my opinion, more important than the language itself.
There's much more recent work here: https://github.com/tshort/StaticCompiler.jl/pull/46 and apparently some more is still ongoing privately.
That said, yeah. I would not recommend Julia currently for people who truly believe they need AOT compilation, and that they need to trigger AOT compilation very often and with low friction. That definitely needs more work, but it's happening.
That said, a lot of people overestimate how much they actually need AOT compilation.
Julia has some fantastic tooling in other areas though. Especially the package management and interactive analysis tools.
Yes, modern V8 does this, as does the JVM. Common Lisp runtimes also often support this, though I think they usually leave it up to the programmer to choose when to compile a function, they don't always do it automatically. The .NET CLR also behaves like Julia - JIT compile on first execution of every function.
Are you hitting the startup time very often? If so, you might want to try some things to keep one julia session open and sending code to it like a daemon instead of constantly closing and opening sessions.
This package makes that workflow really easy: https://github.com/dmolina/DaemonMode.jl
Actually loading them when running scripts is O(s) even for some of the biggest library (Plotting, Differential equations etc.)
f(x) = 2x + 1
f(1)
Next if you do
f(1.0 + 2im)
The genius of Julia’s design is that the JIT compiler is designed around the semantics of multiple dispatch, and the multiple dispatch semantics are designed around having a JIT
There is also technically an interpreter if you want to go that way [1], so in principle it might be possible to do the same trick javascript does, but someone would have to implement that.