Did #julialang end up kinda stalling or at least plateau-ing lower than hoped?
I know it’s got its community and dedicated users and has continued development.
But without being in that space, and speculating now at a distance, it seems it might be an interesting case study in a tech/lang that just didn’t have landing spot it could arrive at in time as the tech-world & “data science” reshuffled while julia tried to grow … ?
Can a language ever solve a “two language” problem?
IMO Julia just had way too many big issues to gain critical mass:
-
Copied 1-based indexing from MATLAB. Why? We’ve known that’s the worse option for decades.
-
For ages it had extremely slow startup times. I think because it compiles everything from C, but even cached it would take like 20s to load the plotting library. You can start MATLAB several times in that time. I believe they improved this fairly recently but they clearly got the runtime/compile time balance completely wrong for a research language.
-
There’s an article somewhere from someone who was really on board with Julia about all the issues that made them leave.
I still feel like there’s space for a MATLAB replacement… Hopefully someone will give it a better attempt at some point.
I still feel like there’s space for a MATLAB replacement…
GNU Octave?
https://en.wikipedia.org/wiki/GNU_Octave
using a language that is mostly compatible with MATLAB
The only benefit Octave has over MATLAB is that it’s free. Which is something I guess, but in practice it is MATLAB without the benefits of MATLAB.
It’s plotting functionality sucks as much as anything else, it has fairly good toolkit support but not remotely like MATLAB, and it still has the mediocre MATLAB language. Worse - with custom incompatible extensions!
Yea I remember reading about some deeper issues with the language (Dan Luu was quite dark on it I think) and that more or less turned me off. At the time I would have had to have been amongst some dedicated users urging me on to consider adoption.
-
@maegul @programming Maybe nobody (save for the Julia developers) ever cared about the “two language problem”. I see folks are just happy writing high performance tools in Rust with Python wrappers.
In any case, I’m happy that the Julia folks gave birth to things like DifferentialEquations.jl, truly a piece of art. Anything that helps scientists and engineers move away from MATLAB is welcome.
Anything that helps scientists and engineers move away from MATLAB is welcome.
The MATLAB language may be pretty bad but IMO that’s not what makes MATLAB good. Rather it’s:
-
Every signal processing / maths function is available and well documented. I don’t know how well Julia does on this but I know I wouldn’t want to use Python for the kinds of things I used MATLAB for (medical imaging). You don’t have to faff with pip to get a hilbert transform or whatever…
-
The plotting functionality is top notch. You can easily plot millions of points and it’s fast and responsive. Loads of plotting options. I just haven’t found anything that comes close. Every other option I’ve tried (a lot) only works for small datasets.
@FizzyOrange The problem with Python for signal processing and stuff like that is not pip (I know it’s a meme by now, but it’s really not that bad) but rather, the fact that some SciPy subpackages are barely maintained
-
> Maybe nobody (save for the Julia developers) ever cared about the “two language problem”
Yea, it’s what prompted my post. I saw in a rust forum push back on the two language thing but from the lower level side (where they were arguing about introducing lazier memory management facilities on the basis that you should just use swift/Python etc).
And re MATLAB … absolutely! This is not a diss against Julia at all.
@astrojuanlu @maegul @programming
I think there’s two ways to think about the two-language problem (from my scientists view):
-
from the developer side, when the target is a product/library it may indeed be better to develop in a typed, compiled labguage, and just have a wrapper in Python, or another high-level language that the users/scientists use.
-
from the user/scientists side: start developing in Matlab/Python, build the proof of concept and demonstrate that the method works. But for the real case application, more performance is needed. So one needs to find a Rust/C++/Fortran developer to join the project. No funds for that, so code never gets developed.
Julia solves the second kind nicely. If I had to rewrite everything in Rust/C(++)/Fortran, the last few years’ research would not have happened.
@tschenkel @astrojuanlu @programming
I’d suppose part of the problem might be that there’s a somewhat hidden 3rd category of user that “feels” whatever added complexity there is in a two-language lang like julialang and has no real need for performant “product” code.
And that lack of adoption amongst this cohort and your first enforces lang separation.
I may be off base with whether there’s a usability trade off, but I’d bet there’s at least the perception of one.
@maegul @astrojuanlu @programming
BTW, I’m not talking about “product code” in Julia, necessarily. The point is that I can stay at the “research code” level and don’t have to rewrite anything, but can just move from a toy problem with a few parameters to a full size mod with 100s of parameters.
In my case I had a Python code solving an ODE system and a global optimisation of all parameters took a week on the 24 cores on a cluster. The same case runs over the lunch break on my laptop in Julia.
For the most recent paper a PhD student of ours use 2000-ish GPU hours for a global sensitivity/uncertainty analysis. That would have been impossible in Python or Matlab. On a single GPU that would have taken 10 years (300 years in Python), instead of 3 months*.
*yes, you can just through more GPUs at the problem, but then we can start the discussion about CO2 footprint being 40 or 600 times higher, respectively.
Note: all our benchmarks are for solving ODE system. Just doing linear algebra, there isn’t really a difference in speed between Matlab, Bumpy, or Julia, because that’s all going to run on the same LA libraries.
@maegul @astrojuanlu @programming
You put your finger right on it. If I tell people that they can replace Matlab or Python with Julia, then there is often not the pressure justifying learning another language.
But when I show them, that (a) the fundamental syntax is nearly the same as Matlab or (b) that the same thing in Python is much more clunky (Numpy and Scipy are not exactly elegant in my eyes), and they can get 40 and 600 times speedup respectively, then there is much more interest.
I needed the performance and DifferentialEquations.jl gave it, and my students stay for the easier language. But then they don’t have a long time with Matlab or Python under their belts, so the perceived pain of learning a new language to the same level is less, of course.
At the moment we still teach Matlab mostly, because that’s what employers expect, but some of my students choose Julia in addition to it. And they do like it.
More and more universities move their scientific “computational thinking” type of classes to Julia (from either Matlab or Python), which may move the trend when their will be more STEM graduates knowing the language.
Considering, it may be worth highlighting that tools like Jax exist as well (https://github.com/google/jax). These have even become an expected integration in some toolkits (e.g., numpyro)
It may not be the most elegant approach, but there’s a lot of power in something that “mostly just works and then we can optimize narrowly once we find a problem”
It doesn’t make a solution that solves this mess bad, but I do wonder about it being a narrow niche
@hrefna @maegul @astrojuanlu @programming
Interesting. But seems to be limited to arrays. And I’m wondering what the benefit is over regular Numpy. In my tests I did not find Numpy to be slower than any other Blas or Lapack implementation (if type stable and immutable).
Do you have any comparisons?
In any case, I don’t think it would work for solving ODEs unless I’d implement the RHS in a JIT compiled function.
I used to love Python, but now it looks like a collection of add-ons/hacks to fix the issues I have.
-
Why is everyone in this thread constantly putting meaningless @ mentions at the top of their replies?
The thread was started as a toot by a Mastodon user. All of the replies are actually Mastodon posts. Thanks to the magic of the Fediverse, these render in Lemmy as comments.
As cool as that is, it does end up looking confusing. Maybe some quick visual indication (possibly customized by each user) to show source of comment could help.
💫 the magic of the Fediverse ✨
Yea I try to post from mastodon when it makes sense. You’re seeing the mentions as that’s how mastodon links things together. Here on lemmy, the connections are all more structural and so implicit.
This is about as good as lemmy-mastodon interaction can be: when someone posts from mastodon to a lemmy community.
Though now, with automatic hashtag-ing since v 0.19.4, the two can work together better. See https://hachyderm.io/@maegul/112720255264101773
@maegul @programming I had already switched to Python to solve the “Matlab problem”. I’ve been Julia-adjacent, looked at it with an open mind but it doesn’t make sense to switch to it when I can do almost everything I need in Python. A little diss here, just when we arrived at a free, available solution for widely available sci/biz programming envrionment (Python) Julia peeled off some whose code becomes unusable for most consumers of code.
Python was first released in 1991, Julia in 2012. I think it may be too soon to call the race.
Problem with that logic is that python was essentially “reborn” at some point 2010-2012.
That’s when scipy, pandas and notebooks all came together, and with early pandas putting python on the map more than some (cough - Guido - cough) are willing to admit.
Of course the maturity of the ecosystem by then is part of it … but also pushing through the python 3 situation wasn’t trivial and likely speaks to the momentum the science stack brought to the ecosystem.
@maegul @programming Perhaps this is all kind of like evolution: something that evolves to be sufficient doesn’t necessarily need to further evolve to some pinnacle (however that may be defined it its context). R and Python are imperfect in so many ways, but sadly it gets the job done for most folks. I think people who explore Julia are simply not content for one reason or the other with R and Python (perhaps also Matlab), but they likely have gotten a lot of work done with R & Python.
So at my previous employer I developed using Julia a custom ML model which ran, but the performance just wasn’t good enough for what I needed despite trying to aggressively optimize. I ended up rewriting in Rust (and calling through R) which ended up being like 10x faster. At my current job I program a mixture of Rust and Python.
If Julia were more peformant then it could potentially be an alternative to Python/R users having to learn Rust - but if you’re looking for top performance, some of your codebase is already written in R/Python, and you’re already willing to learn another language, then learning something like Rust naturally seems the better choice over Julia.
The one thing I did like about Julia - it took barely anytime at all to build a working prototype.
In general, how much more performant would you say Rust is or can be than Julia? Any good resources on this?
What’s interesting about this take is that it targets the whole “two language” thing and implies that it might be a fool’s errand.
In a real way it feels like there’s a “hump” with language adoption. Some languages clear it, some don’t, and I don’t think we have a good feel as an industry for what makes a language “successful” in this regard.
Some things obviously help, other things obviously hurt, but mostly what succeeds or doesn’t seems to be a matter of luck intersecting with need.