Caveat: This is in my view not just a technical achievement, it also works because some library authors play nice. And because things where standardized from the get-go, instead of evolving organically/provided much later by users.

I think the main thing that Julia gets right is that there are de-facto standardized interfaces for a lot of things that are actually followed/used.

E.g. in C++ on the other hand, you have a bunch of libraries that bring their own primitives, like all the Matrix classes-- their is no interface for those, and even if their was, it would be a pita to write C++ code that was able to work with a bunch of difference primitives here. So the problem is not only that it would be a lot of work to write C++ code to be "primitive-agnostic" (=> you would basically have to soak your codebase in templates), there are not even common expectations for you to build upon (like: does a matrix class provide rowncnt()? or rowCount()? or size(1)?, or nrow()? => if there is no common ground not even extensive template magic is gonna save your day).

Julia also makes it super easy to write type-agnostic code in general ("dynamically typed"), which is simply not the default and/or extra effort in many other languages.

There is a talk on how this is possible due to multiple dispatch: https://www.youtube.com/watch?v=kc9HwsxE1OY

One of the main things I like about Julia is that all the libraries are just built on their core Array type. In Python, there’s torch tensors, numpy arrays, and I think Jax has their own array type too. Also, Julia has a really beautiful distributed computing paradigm, whereas python needs to use libraries like Ray, which have their own quirks and documentation and community

General scientific computing is pretty good across the Julia ecosystem, from optimization, to ODE and now PDE solver libraries, to various statistics and inference packages, etc. It lacks the deep NN tooling or breadth of ML libraries of Python, and nothing matches R for breadth of stats libraries, but for most other scientific computing it is really great at this point.

Scientific/Numeric/Data-Python is essentially a DSL around C-API which creates friction (try for example to map a custom function over a Pandas column). Whereas in Julia, it's just Julia. It's liberating to just extend and use a library written in the same language. It leads to surprising synergies.

numpy is only fast if the computation does not escape it. There are plenty of cases where execution ping-pongs (if that's a verb) between python and the C(++) wrapper numpy actually is. Then everything becomes quite slow.

Anyway, I see data scientists and statisticians (at least 100% of the ones I know) completely ignoring Julia, just because they only have been exposed to Python and R in their education. The quality of the programming language/ecosystem seems to be irrelevant.