The question was to be divided into different topics, so here comes.
Julia is an expressive language, that is, it is a good tool able to do things, and it is also efficient in computing power usage.
All in all, Julia is about efficiency.
The ease and productivity of Julia, from the easy, fast base language to composable packages translate to the efficiency of development.
The computational efficiency of Julia translates to efficiency of computer uses.
However, let’s bite the bullet and look at this efficiency for what it really means.
A business with 2% of its cost in software wouldn’t risk ruining the business over 2%, and something more important like reliability (which Julia currently lacks) will be more important.
A project that needs lots of performance but can hire experts can use C++/etc because they can be fully optimized. While Julia can be easier to optimize in some cases, there are also a lot more C++ programmers. C++ is also more reputable as a standard in this front.
If the business just wants quick apps, python/etc can do the job. Many languages are also more familiar even if it’s not “python-like”, so those may be selected instead.
So, this leaves us at the intersection of efficiency in development and efficiency in compute power. For example, some indie games, tech startups, some low power embedded devices once static compilation becomes practical, etc.
However, this very intersection is also full of competition, for example, python’s numba, a bunch of small languages, python with native code library, etc.
What is Julia’s role. Where will we see the killer application that pushes Julia forward?
I’m only asking because my boss might read this thread, hear about correctness issues, etc., not be able to find specific ones to evaluate the severity of and push me back into Python/C++ land again. Any links you had to specific ones would help us evaluate.
All I am coming up with now is this search on GitHub, i.e. just search for “correctness” in the issues on JuliaLang.
I have been using Julia full time for work for the last 3 years and I have never run into a situation where a correctness bug in the language itself affected my code or results.
I have definitely run into bugs in Base and the stdlibs, like something doesn’t work as expected or throws an error when it shouldn’t, but not silent correctness bugs that change a result to be incorrect.
I have also run into bugs in packages, but again I don’t think any correctness bugs affected my work (During my PhD, I ran into a bunch of correctness bugs in Convex.jl which were a huge pain, which is actually what got me deeper into Julia programming in the first place, to fix them. But I don’t think I’ve been hit by any in packages since then at my job).
A group I work for at Merck/MSD are using Julia daily and in fact presented about it at JuliaCon this year: DyVE, a Framework for Value Dynamics | JuliaCon 2023. To clarify, we aren’t working on PK/PD stuff directly, otherwise this comment wouldn’t add much because it’s already been noted how much of an impact PumasAI is making in that space. We are working on other statistical/ML problems, JuMP for large MIP/LP problems, SciML for dynamic models, and Catlab for structuring large models.
A significant part of my time over the last 3 years has been devoted to a project entirely developed in Julia for precisely this reason:
the problem was so complicated that we anticipated having to test several ways to solve it => efficiency in development
most of the solution methods require lots of heavy computations => efficiency in compute power
We originally had to convince everyone involved that using Julia for this was a good idea. But now, 3 years later, we have a mini eco-system of ~10 packages (most of which are closed-source, but for instance Eikonal.jl came out of it too). And it is clear to everybody that this was the best choice.
I’m not so sure about this. For example, in the project mentioned above, some of the work involved running computations on GPU clusters. I’m very far from being a Numba expert, but I doubt it would have been as easy to do with Python/Numba than with Julia.
In particular, a better choice than Python + C++, which would otherwise have been the default choice, but retrospectively a terrible one ↩︎
To provide one datapoint to your question (and some food-for-thoughts), I managed to use Julia at work for the following reasons:
it was startup, now “upgraded” as a scaleup
(hence) small team => each “specialization” boils down to 1 person (or 2, for redundancy)
need for GPU-specific applications, with some math (= how to do advanced compute as easy as possible without hiring specialists, because everyone is participating in pretty much everything, albeit sometimes from afar)
Otherwise, we’re using Go for all the infrastructure (Kubernetes-based), which provides a very good balance between learning curve / performance / ecosystem. Heck, we even used gonum for a couple of math stuff. For that part, Go is, in a word, “goodenough”