Hi, first of all let me say that I know this is a big subject, but I couldn’t find any serious discussion about it, so I’m asking here.
I think it’s obvious that Julia has a really good philosophical basis, and I believe it has a lot of potential to grow and compete with all the other big languages.
However, I believe that presently, it’s still not ready to be used for most programming projects. But the “good news” is that perhaps it won’t be so hard to fix, if we make it a priority. I would say there are 3 main roadblocks that I’m aware of:
- Performance, or: No integration of JIT and interpreter
Right now, every function that runs even once, gets compiled. This is causing really long start-up time, and a really long time-to-plot, which could be easily avoided by compiling only functions surpassing some call count.
Julia already has an interpreter, so perhaps this won’t be so difficult? I’m sure many would be happy to have that as an option.
I should note that the idea has been mentioned here, but I couldn’t find a discussion about it: https://julialang.org/blog/2019/03/debuggers
Another thing that can really help performance, is caching the compiled functions, and luckily there’s already a mechanism to serialize and unserialize them (iirc tim already opened an issue about it).
Every modern language (and even most non-modern ones) lets you include your module using a single command, and makes sure to remove duplication for you.
The funny thing is that you can import a local module, if you just add the local directory to Julia’s path (which creates its own stack of problems). But perhaps it means that it would be very easy to implement?
edit: Just to clarify, I’m talking about importing modules within the same project (local modules), for example a utility module, or a module for common structs.
- Executable size
When compiling a trivial program on windows, the build ends up taking about 500 megs, mostly in complementary dlls and such. Python does the same trick of including itself, but needs only 30 megs. Perhaps there’s a simple solution to drastically reduce the build size?
This one is perhaps not so immediate, but all-in-all wouldn’t it be nice if you could send someone a julia program over email, like you can with any other big language?
I have a lot of other tidbits that I would like to improve in Julia, but I’ll save it for another time. I’m writing all this not to complain, but to help point out what I think should be on high-priority if we want Julia to make its steps towards mainstream and professional use.
I wish I could do all of this myself, but this isn’t one man’s work, even if I was familiar with the code-base and had the time to see it through. But if we decide to make this a priority, we can all carry a little bit and get it done together. So, at this point in time, I’m just trying to figure out if enough people agree with me (or perhaps if I’m wrong about it).
So, let’s discuss it. Do you think these issues are important? Do you feel there are other important things missing? I’m interested in your opinion!