I just wanted to share some thoughts about the state of Julia 1.X, and what I see as the most important missing features of the language. I intend to make this a “no-rush feature request” for Julia 2.0, rather than a “complaint post”, so please bare with me.
It’s no doubt that Julia is an interactive, high-level language, that can attain the performance of statically-compiled low-level languages, and this already represents a tremendous progress in language/compiler design, which has made me really enthusiastic about Julia.
However, I also realized that Julia still can’t obtain the same portability that statically-compiled languages enjoy. For example, things like Python interoperability are harder to obtain with Julia than with C++. Additonally, other nice things to look forward to, like compiling to Webassembly, are nearly impossible in Julia for the moment, let alone running on low-memory or embedded devices. That is to say, Julia (at least in it’s 1.X version) isn’t the optimal language in which to write a universal library that can run anywhere.
I am aware of the experimental project StaticCompiler.jl, which makes me really enthusiastic that all this will could be possible in the future. This is nevertheless in a very early stage of development.
Correct me if I’m wrong, but it looks like StaticCompiler.jl is headed to eventually be able to support a dialect of Julia 1.X, and not the full language.
I also remember reading that StaticCompiler.jl was one approach, while there was another possibility of making libjulia mode modular or more portable, I don’t really remember. It would be nice to hear some comments about this. Will the progress on StaticCompiler.jl go hand-in-hand with making the runtime more modular? For example, could we expect to have threads or at least being able to call C from statically-compiled Julia when something changes in relation with the runtime?
Static compilation is also related to the interface design problem that was at the core of Yuri’s criticism. That criticism was centered around the fact that some of the tools available in static languages are missing in Julia.
What do I think? Well, maybe writing a Julia package should impose some additional restrictions to a developer, like being forced to define an interface, while leaving all the freedom of a fully dynamic and interactive language at the top-level.
Of course, this could hurt Julia’s composability. However, in my case, that would be a small price to pay in order to get things like seamless Python/C++ interoperability and more safety checks.
From the point of view of a computational researcher, Julia 1.X has solved the two-language problem, that is clear to me. Before Julia, one couln’t even write a paper in my field without resorting to low-level languages (or hiding the running times). However, when the time comes to consolidate what you’ve accomplished into a universal library that is both great for users, and that can run anywhere, apparently we still have to rely on a monstrous thing like C++. It would be nice if we didn’t .
Anyway, thanks for reading, and I appreciate any comments.