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?

@programming

  • festus@lemmy.ca
    link
    fedilink
    English
    arrow-up
    6
    ·
    5 months ago

    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.

    • maegul@hachyderm.ioOP
      link
      fedilink
      arrow-up
      1
      ·
      5 months ago

      @festus

      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.

      • festus@lemmy.ca
        link
        fedilink
        English
        arrow-up
        1
        ·
        5 months ago

        I think it really strongly depends on what you’re programming - I know in some instances Julia’s performance can be nearly identical to languages like Rust. I suspect in my case it related to Julia being a garbage collected language, as my algorithm involved creating very large dynamic structures in memory before serializing them, clearing the memory, and building another one. Since Rust has no garbage collector it knew exactly when and what to drop from memory. In my case I had roughly a 10x(!!) speed-up. Funny enough an even earlier version of that algorithm was programmed in Java, and Julia was roughly 10x faster that it, so Julia isn’t the worst of the pack.