Julia 1.11 Highlights
julialang.org
julialang.org
I also feel that Julia managed to achieve "forward interoperability" between libraries that is almost unparalleled in my experience: It is often possible to just pass data structures across library boundaries, and in MANY other languages this is absolutely not the case; consider e.g. C++, where you might have like five different "Matrix" classes/types between GUI library, linear algebra package, image processing toolkit etc., and the code you write has to convert those types at every boundary by hand.
The one thing the language is bad at (but this also improved a lot over time!) is the suitability as conventional scripting language, where you run some source code through a cold-started interpreter (you get somewhat railroaded into having an open interpreter instance, that you then run your scripts on instead).
Never coded in Julia, how does this work?
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.
Also, arguably, Julia, while fantastic, just didn't do that much that Python didn't do already. It's main argument outside of tidier ergonomics was basically "speed without leaving Julia" but with Numpy and Pandas being essentially stdlib, that just wasn't a very powerful argument. Julia was basically too incremental to be worth switching to. It seems to have found its niche elsewhere though with the optimization people?
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.
Come chat in the Julia slack #finance or #actuarial channels!
IMO one of the issues with Julia is that it’s easy to get nerd-sniped trying to do clever things with the type system and to make as much of your code as possible statically-inferable. Code and libraries that rely heavily on type dispatch ends up throwing MethodErrors deep into the call stack, far away from your code, which makes it harder to debug them.
More mature Julia developers tend to keep things simpler, and make better use of dynamic types instead of contorting to treat it like a statically-typed language.