Can juliac increase julia adoption?

[Anil_Beniwal]

rust star history shows exponential trend while julia going towards logrithimic scale towards stagnation.

[lmiq]

Sure it can.

[nilshg]

Maybe.

[Tamas_Papp]

@Anil_Beniwal

julia going towards logrithimic scale towards stagnation.

I am not quite sure how stagnation on a log scale is different from stagnation on a linear scale, but the situation is actually much worse.

I applied a super-scientific “freestyle quadratic” extrapolation and found that

Yes. In 15 years or so, Julia will have negative users, going to -\infty quadratically.

Unless we solve [everyone insert their favorite issue with Julia here].

Personally, my biggest issue quality of life issue was

redefining struct

but they just went and fixed it in

bpart: Fully switch to partitioned semantics

so I will have to find something else to complain about.

[franckgaga]

Now that was funny! Thanks for the laugh

[linwaytin]

Comparing julia to rust is not fair. They are designed for very different purposes. Rust is meant for more general programming tasks. People are talking about replacing c/c++ with rust. I don’t know how many c/c++ programmers are in the world, but I’m sure it is way more than people working on scientific computing, for which julia is designed.

A meaningful comparison, in my humble opinion, is between julia and matlab. Unfortunately I have no idea how many people are using matlab.

[Benny]

If the implied question is whether AOT(?) juliac is similar enough to Rust to be adopted for similar reasons, then we don’t really know because juliac isn’t even released yet, but probably not because Julia’s semantics and resulting implementation are very different from Rust’s. Languages and compilers can be written in Rust (example: Rust) like they can be written in C or C++; I really doubt anybody would write a language or compiler in Julia and get stuck with an internal garbage collector. I can imagine trimmed juliac executables being appreciated or juliac libraries being embedded in bigger packages in other languages, but Julia will probably still be comparable to other interactive languages with heftier runtimes. The usual user complaints (see Tamas_Papp’s comment for one) about Julia tend to mention those languages in passing, not languages like Rust, and the trend for Julia doesn’t surprise me given those complaints and how the two-language problem doesn’t bother many people much.

Aside: why is there a ~5 year gap for Rust’s data points and ~2 year gap for Julia’s? The trend lines are probably still more or less accurate, but it seems strange for so much data to be missing.

[MDSW]

It might be useful to understand (a) adoption within the scientific and engineering community, and (b) adoption beyond. Toward (a), this is really about Julia’s core design intent and audience, and understanding the specific blockers. For (b), IMHO it is a combination of addressing things like we keep seeing in this sort of thread, and then getting the word out beyond the traditional audience, which the community is not necessarily well postured for right now.
Arguably, if you wanted to compare to Rust, which I don’t think is a great comparison for reasons @Benny raises, but for the sake of argument, the Rust community is pursuing more of (b) with much smaller efforts focused on (a). Again, arguably, the opportunity space in (b) is much larger than in (a), so you would expect different growth curves. But I do think there are some places in (b) where Julia can really shine while staying true to its core strengths.

[Anil_Beniwal]

i used rust as an example as it was release at same time as julia. here is comparision with typescript. i could have done a comparision with python, it will be wrong comparing with

a decade old language.

[mbauman]

If you like Julia, use it! Get your friends and — more importantly — your coworkers to use it! If you’re excited about juliac, great! Try it out and submit bugs!

The reason folks are investing time and energy into juliac is because people who are using Julia and want to be using Julia need that feature. It’s not just work because they like the work.

I concretely know that it’ll increase adoption in several very representative companies. I don’t know if it’ll increase the number of stars.

[Benny]

@Anil_Beniwal

a decade old language

TypeScript was publicly released in 2012, the same year as Julia and Rust; the 0 stars at 2014 is when v1 was moved to Github. It’s a bad comparison for other reasons, especially because it extends and transpiles to Javascript, and strays farther from anything to do with juliac’s potential.

[Ininterrompue]

Yeah, our work is interested in juliac. Reasonably sized binaries would be a huge boon to us, and “scientific computing” would benefit at large (it’s not just prototyping/REPL-based workflows/one-off scripts). The increased adoption will more likely depend on the tooling around it and how easy it is to write programs which can make use of --trim. I could say more if I could play around with it, but I’ve been struggling to get juliac working on Windows on either 1.12 beta or the 1.13 nightlies.

[Anil_Beniwal]

i like julia i have nothing against it, i hate ts but i don’t know why it became popular and julia lagged behind?

[ForceBru]

Wait, it’s now possible to redefine structs?! Indeed, the following works in Julia 1.12:

julia> struct RedefineMe{T<:Real}
        a::T
       end

julia> x = RedefineMe(5)
RedefineMe{Int64}(5)

julia> struct RedefineMe{T<:AbstractString}
        a::T; b::Int
       end

julia> y = RedefineMe("hello", 5)
RedefineMe{String}("hello", 5)

julia> x
@world(RedefineMe, 40635:40638){Int64}(5)

julia> analyze(x::RedefineMe) = length(x.a) - x.b;

julia> analyze(y)
0

julia> analyze(x)
ERROR: MethodError: no method matching analyze(::@world(RedefineMe, 40635:40638){Int64})
The function `analyze` exists, but no method is defined for this combination of argument types.

Closest candidates are:
  analyze(::RedefineMe)
   @ Main REPL[6]:1

Stacktrace:
 [1] top-level scope
   @ REPL[8]:1

Cool, that means now I won’t have to reaunch the REPL after modifying a struct definition!

[ForceBru]

I think the problem is that Python is almost a perfect substitute for Julia. Moreover, it’s already extremely popular, there’s a lot of learning resources and you can use it to do anything you want.

• Array manipulation? NumPy.
• Dataframes? Pandas, Polars (written in Rust).
• Plotting? Matplotlib, seaborn (based on Matplotlib), Plotly, …
• Statistics, regression, time-series analysis? statsmodels, arch…
• Machine learning? scikit-learn.
• Deep learning? PyTorch, TensorFlow, JAX, …
• Scientific computing? JAX and its ecosystem (Equinox et al, Flax, Optax etc), SciPy, SymPy.
• Optimization? scipy.optimize.minimize (uses FORTRAN code under the hood), NLopt (C++?), Optax, …
• Bayesian modelling? PyMC, blackjax, pystan, cmdstanpy (bindings for Stan).
• Language models? HuggingFace Tokenizers, OpenAI’s tiktoken (written in Rust under the hood), Transformers (PyTorch-based), SentenceTransformers.
• Need fast code? Switch to C++ or use Numba, Cython, jax.jit, PyTorch without leaving Python (code will be silently compiled).

Some peoples’ thought process could be: I already know Python (almost everyone knows Python nowadays), I know what libraries to use to do what I need, so why use Julia? What does it provide that I don’t have in Python? Off the top of my head, differential equation solvers. Anything else?

Thus, it’s not immediately clear why use Julia when one can do the job in Python, calling into C++ and FORTRAN for the actual heavy-lifting, but the end-user probably doesn’t even notice this. I use Julia because I kinda like it (sometimes it’s easier to write), but for my usecases, there’s nothing that Julia can do, but Python can’t, so I could just as well use Python for almost everything.

[ufechner7]

@ForceBru

Anything else?

ModellingToolkit.jl It allows you to symbolicly define physical and chemical and other systems, which amazing!

And a unique composibility of packages, a much more mature eco-system of control system libraries, 50 times the performance in many cases, true multi-threading, better (and integrated) package manager etc etc

[Benny]

@Anil_Beniwal

i hate ts but i don’t know why it became popular and julia lagged behind

TypeScript transpiles to Javascript, the client-side language of the Web, which is a pretty big deal. Julia does not.

@ForceBru

Thus, it’s not immediately clear why use Julia when one can do the job in Python, calling into C++ and FORTRAN for the actual heavy-lifting, but the end-user probably doesn’t even notice this

And we don’t complain about doing the heavy work of LinearAlgebra in Blas implementations that aren’t written in Julia. Even if we ignore the massive gaps in ecosystem diversity (and thus user bases, resources, and stability) and just consider the basics, people who wish their language was faster are used to not compiling their own code, and nobody likes doing that every session. It’s possible to precompile almost everything for a script the first time, but without doing the work of isolating it to a package, it can’t share a session with other scripts. For everyone’s gripes about Python’s speed and lapses in composability among its heavy reliance on other languages for performance, people seem generally happy to not deal with an optimizing compiler.

[jules]

One thing I liked when going to Julia was that there are fast arrays of arbitrary types, so I could put colors in a dataframe, or static matrices, or whatever. On the other hand most people just need floats and strings and that’s it, so if a library like Polars provides those in a super fast fashion then for a lot of people that’s hard to beat.

So I sometimes feel Julia attracts more adventurous and creative people that are interested in composing new things with each other, while people that care about robust production use cases would rather use unexciting but established and battle tested tools.

[croberts]

I think the problem is that Python is almost a perfect substitute for Julia. Moreover, it’s already extremely popular, there’s a lot of learning resources and you can use it to do anything you want.

• Array manipulation? NumPy.
• Dataframes? Pandas, Polars (written in Rust).

I switched from python to Julia because I needed to compute lags of variables from large unbalanced panels. I was using Pandas (Polars did not exist at the time, in 2018), which stands for “PANelDAta”, and I was surprised that there was no non-buggy implementation for computing lags. An implementation I wrote in python took 3 hours to run and an implementation in Julia took a minute to run.

My takeaway was: (1) Python has packages for lots of different things, which work great when your problem maps directly onto package functionality; (2) if the Python package lacks what you need then you are up a creek; (3) the best developed Python packages lack essential functionality for basic things (the panel data package can’t compute lags???). Although Julia’s ecosystem was (and is) underdeveloped, the things I wanted to work on were going to require things poorly supported in Python (much more tricky things than mere lags), and I recoiled at saying: “I’m not going to answer that question because there isn’t a Python package for it.” If I must write my own performance sensitive functionality, then I would rather write that functionality in something other than python.

[Vasily_Pisarev]

My impression is, Julia on Colab (i.e. a recognition of language existence by a big tech company) may have a larger effect than juliac plus solving TTFX plus switching to 0-based indexing combined.