Are these criticisms of Julia true?

I found this Reddit thread about someone asking if it’s still worth learning Julia in 2022 and some person listed a few items that he considered deal breakers when it came to Julia that I wanted to get a second opinion on. Here’s the abstract:

In 2022, Julia is niche-dead, and presumably won’t resurrect. The key reason is that albeit it is intended to solve the so called “two language problem”, in fact it has failed to do so. The full concept of Julia is useless in the industry for use cases where speed really matters, outside high performance scientific simulations, so the industry keeps using C++ and presumably Rust for data-intensive applications. The achilles heel of Julia is its garbage collector and also that it tries to compile the source code during the first execution, which is epic fail for industrial usage. In the meantime, Python is catching up with speed at the use cases where it truly matters (with FastAPI, Numba etc.) and where real runtime performance is needed, C++ is the king and Rust will soon be the queen (with PyO3 and tons of other libraries). Julia has no chance against these giants. It will probably survive as a scientific simulation language, though.


Thanks to anyone who shares their opinion.

Since I dabble in Python as much as I dabble in Julia, I’ll comment on that bit. First, it’s contradictory to say garbage collection is an achilles heel for Julia but then laud Python, where it is tougher to reduce heap allocations/GC pressure. Second, it is misleading to name FastAPI and Numba in the same breath with no context. FastAPI is a fast web framework because it is asynchronous (look up ASGI for more history); it is not a Python accelerator like Numba, Cython, or PyPy (NumPy and CuPy deserve honorable mentions for fast array code). Third, there is another contradiction between the opinion that Julia’s LLVM-based just-ahead-of-time-compilation is an “epic fail” and the opinion that Python benefits from the LLVM-based just-ahead-of-time-compiled Numba. I refer to the recent comments I made on how Python impedes Numba from being as good as Julia. To put it politely, a redditor assessed many things when they had yet to understand them.

Whether Julia (and Rust btw, they’re both 0.52% on the TIOBE index) ever escapes “niche” status and becomes competitive with the “giants” Python and C++, I don’t know. I think compilation-saving has to improve, and my most realistic guess is better interoperability with Python could gradually convert the Python user base. But that’s probably a biased take, I believe the dynamic nature would appeal to Pythonistas, but it’s possible that unlike me, many would not sacrifice unoptimizably dynamic language features like runtime modification of classes and truly malleable nested functions.


If you want to learn an industry-dominating language then Julia is obviously not that currently. It also isn’t likely to dethrone Python even ignoring technical merits and just looking at the number of people already tied to Python. So even if a take like the one you referred to sounds bleak at first, it is mostly factually correct I would say. But, I just don’t think that picking the overall “winning” language is the most important thing for you personally. It’s not like a stock you need to bet on and cash in later, beating all of those that “bet on the wrong horse”. (Unless you stake your career on the choice maybe.) More a question of, can Julia help solve your specific problems better than the alternatives. For most people here, it can. And the rest probably just enjoy the beautiful concept of it.


It really depends on your use case and your goals regarding the learning process.

If you want to learn a language to get a job, I believe some good advice is to focus on two things:

  • Learn fundamentals of software development and good programming practices
  • Let the job market inform you about which languages are in higher demand and learn them, as you would be integrating existing teams with existing codebases.

So on the basis of my second point, you’d probably be much better off with Python, C++, and/or Javascript, as their existing userbase is huge. I believe this is what the author implies.

However, if you are working in an environment where you can choose which language you can work with (like scientific research, where, to some extent, you can ignore my second point) then I believe learning Julia is definitively worth it. Some new software companies are beginning to choose Julia as their stack, which also further illustrates my point (new companies starting from scratch get to choose which language they use).

Now, even if your goal is to join the industry, I believe learning Julia should be a great learning experience nonetheless. If you become well-versed in Julia, the language and ecosystem will naturally expose you to great fundamental concepts and techniques.

For example, Julia can be as fast as low-level languages if you get things right. That is to say, you can learn low-level optimization strategies with Julia. Julia also has amazing high-level language features like generic programming (via multiple-dispatch) and code generation (via macros), so learning the language will expose you to those concepts. Additionally, Julia has great tooling, so the ecosystem will expose you to very good programming practices like integrated testing and automatic documentation.

I believe you just can’t learn some of these things in Python, and on the other hand, learning them really well in C++ would absolutely take you years, compared to months in Julia.

In my particular case, I’m in computational research and education, so I believe I’m into Julia for the long term. But if you are not, or don’t plan to be for more than a few years, I believe investing time in learning Julia has a great payoff nonetheless because of the fundamentals and good practices you will get exposed to.

Now, my expectations about Julia are that it should absolutely take universities by storm, as it is a fantastic language for both research and education. So its “niche” I believe is considerably larger than what the author suggests. We will see where the ecosystem develops from there in a few years.

Now, some of the points raised by the Redditor could also be addressed over time, I believe. I’m very enthusiastic about static compilation in Julia, which is however at a very early stage. As static compilation seems to be closely related to how Julia is used on GPUs, which is another major use-case for Julia, I would expect to see some progress in this area. Improved Python integration should also lead to substantial growth for Julia, as the userbase for Julia packages could grow substantially.