What steps should the Julia community take to bring Julia to the next level of popularity?

[Eben60]

To begin with, you are asking in a rather suboptimal way, sorry for being direct. The tips in Please read: make it easier to help you could help.

I have therefore no idea what is wrong in your case. My results are as following:

@time begin
    function add(x,y)
        x + y
    end
    println(add(3, 3.14))
end

#
6.140000000000001
  0.020796 seconds (25.63 k allocations: 1.714 MiB, 82.16% compilation time)

(Mac Mini M1. My old Windows computer would be by a factor 2 or 3 slower)
PS - Using VS Code (scripting mode)

[ShalokShalom]

Once the program is running, I have all my old functions, and constants, etc still in that backlog as well.

So I can’t just “go back” and delete them, and even more annoying so, I don’t even see, what the code is, that I am running.

Other languages don’t run them in the REPL, as far as I can tell, they just evaluate what is on-screen.

[ShalokShalom]

I think it’s just my plugin. It’s not showing errors either, just auto-completion works.

And I wasnt really asking, I just mentioned that the performance issues – that I assumed were the same for everyone – are hardly limiting the value of a self regarded “high performance” language.

[ShalokShalom]

I think there is no market for “an easier C++”

First, most people will say Go, and Rust, and Zig, and god-knows-what, is already an appropriate alternative.

And second, I believe people who are coding C++, are not really looking for an “easier” language, but much rather a more sane one.

And they got Rust.

I find it more appropriate, to pitch Julia to people who are new to programming.
Since I have pointed that out already, I won’t repeat all again.

Ultimately, people change language, if their current one can not do for them, what they want it to do. I think this is how the current landscape formed, and how it has always formed.

It is not about the language being “objectively” good or bad.
Smalltalk was a fantastic language, people loved it, and because the performance was behind C, the developers got told to use that instead.

“You want objects? Well, we have Objective-C and C++ for you, then.”

Completely missing the point, that these are vastly different beasts.

People go to a specific language, if that one can solve something for them, that others can’t.
At least in their subjective perception.

For some people, that special thing is simply to be unique, interesting, and a wonderful toy.
And to be honest, I think the vast majority of programmers do program mostly for the money.

They go home, and don’t care about the quality of the code.
They do care that they get paid, and that they don’t have to take responsibility.

So, if we are saying, we want Julia to be more popular, we ask implicitly:
To whom?

More scientists?
Business developers, who expect you to run on the JVM?
System programmers, who ask you to ditch the garbage collection?

I personally suggest that young people who have not decided what language, they are striving to use, but they do know they want to do programming, are a wonderful audience group.

They are motivated, and there are millions of them.

India alone will produce more developers within the next 5 years, as there are C++ devs today.
So why focus on existing devs?

They are only stubborn, and think they know already what makes them happy.

[Eben60]

@ShalokShalom

I have all my old functions, and constants, etc still in that backlog

You were told to use Revise, weren’t you?

[martin.d.maas]

Well this is the longest thread I’ve seen, but apparently it hit some nerve in the community.

Just adding my 2c: programming languages (or even frameworks within existing ones) have gigantic network effects, especially on this day and age of open-source and the internet. The more developers using Julia out there would naturally lead to having more bug reports, more PRs to solve those bugs, more packages, more educational content, more job postings, and all this provides a positive feedback loop which in turn drives language adoption.

However, if a language is not popular enough, this feedback could become a negative one. Some people could get the impression that there are too many bugs with it, too little documentation, too little job postings, not enough beginner content, etc. Especially when the other languages have set the bar already quite high in some regards.

So the concern expressed by the title of this thread is indeed a valid one. It is in the best interest of the community that Julia reaches a certain “higher level” of popularity. A level from which everything becomes easier from that point going forward. Like a certain “critical mass” of developers using the language (and contributing back in some form, like PRs, bug reports, documentation, using it to teach a class, etc).

We can’t know when this will happen. It could be the next version of Zygote that removes the impression that there are too many bugs in the language, or some progress with static compilation to ease deployment in production settings. It could have even been the last realease that reduced TTFX substantially (with more progress yet to come to the last stable release)…

Or even, like with the critical mass phenomenenon, just a matter of adding many small contributions in various areas until some tipping point is passed.

However, I don’t think we can say that this tipping point is already behind us.

A few indicators I use: I see just too few job postings that mention Julia as an even desirable skill. While I don’t have numbers to back this claim, I think it’s quite obvious.

Also, on the much related online-education side of things: top Udemy courses for Julia have like ~300 reviews, while R courses have ~50,000. On youtube, there is only one non-official channel (doggo dot jl) with about 7k subscribers, and there is at least one R programming channel with 85k. The top youtube video result for “R programming tutorial” has 3.5M views, while the top one for Julia (Derek Banas?) has less than 200k. So the difference in popularity with R is about an order of magnitude in this area, not to mention Python or C++.

Now, this is simple economics: more jobs postings would create more audience for this content, and it would even become very profitable for the course creators or youtubers to create more material, reinforcing the impression that these languages are very easy to learn, with lots of beginner-friendly content.

So, anyway, we’ll see when this tipping point is reached – I place my bet on the next milestone regarding static compilation – but I’m pretty confident Julia will get there, given that it already has enough traction and that we are seeing steady progress.

[bertschi]

That works the same way when using Python in Jupyter and had me ditch Jupyter.
I do use a REPL workflow though, i.e., do a small change and just paste that to the REPL (via Shift+Return in VSCode instead of actually pasting though). Further, I usually put my stuff into its own module – which can be a bit annoying as I need to qualify when testing stuff directly in the REPL – allowing to simply replace all definitions by reloading the module when things got to messy. I never ever restart the REPL though – unless forced to do so (sometimes wish that Julia was more like Common Lisp in that respect).

[PetrKryslUCSD]

It is a pity that these threads tend to become the corner where the disgruntled and the unhappy congregate. This then gives the mistaken impression that Julia is a failed experiment, because those Julia users that are quite content with it would rather avoid posting here. At least that is my feeling atm.

[xiaoxi]

@martin.d.maas

We can’t know when this will happen. It could be the next version of Zygote that removes the impression that there are too many bugs in the language, or some progress with static compilation to ease deployment in production settings. It could have even been the last realease that reduced TTFX substantially (with more progress yet to come to the last stable release)…

It is a pity that such projects that could greatly improve the ergonomics of Julia receive so little prominence in blog posts.

[raythurnevoid]

I’m a newcomer to Julia and I’m thoroughly enjoying it. To increase the popularity of this language, perhaps we should spam some articles to ThePrimegen to catch his attention .

I’m primarily a FullStack developer, working mostly with JS/TS, especially Svelte/SvelteKit. I’m not afraid to adopt niche technologies, as I was an early adopter of Svelte/SvelteKit.

Over the past year, I’ve been learning Python in my spare time. While I’ve used it for personal projects and appreciated features like list comprehensions, generators, ranges/slices, and popular libraries like pandas, I often found simple tasks verbose or messy.

The biggest pain point in Python for me was package management, it’s pure anarchy and environment reproducibility is difficult. The Python community sticks to older versions (3.8 being the most popular), resulting in outdated online solutions. On Windows there are occasional issues, and features like asyncio in Jupyter are not supported. I grew frustrated with the Python ecosystem.

So, I explored Julia, which I discovered thanks to Fireship on YouTube.

Julia isn’t perfect, but it’s pretty good. A few downsides include limited IntelliSense in the VSCode extension, enum implementation, and occasionally confusing compiler errors. Several things shine: the REPL, debugging experience, package management, the broadcast operator, do…end blocks, piping, @async, executing external processes with shell strings (backtick), and multiple dispatch instead of messy OOP.

So far, Julia code I write is clear and direct, with minimal boilerplate. The syntax reminds me of the best aspects of JS, Python, and shell languages like Bash (and I hate bash, but executing a process and grep on it is cool).

For solo projects, I’d choose Julia, even at work, due to its many positives. However, for collaborative projects, the lack of good IntelliSense and abundancy of online solutions can be a problem.

Overall, Julia is fantastic, and I want to see it gain more popularity. More Medium articles and YouTube content, not just for scientific fields but also general-purpose areas like CLI, data engineering, and batch processing, would benefit Julia. (For building an HTTP API or generating web pages, I’d stick to Go or Node.js).

[indymnv]

@jreileyclark

I would love to write some of these, but I honestly have no idea how to start a tutorial blog. You guys who have blogs written in Julia should have blog post #1, “How I created this blog in Julia”. Again, I need my hand held. So do most people. This should be a ubiquitous tutorial. Every julia user should be taught how to share their creations online, should be encouraged to share their work on linkedin, twitter, etc.

I hope with this article at least there is an improvement in this area

Creating your own blog with Julia and Franklin

[mwsohn]

I stumbled upon this Wikipedia page on “Comparison of statistical packages (Comparison of statistical packages - Wikipedia)” in which Julia statistics packages are not listed at all. Can someone who is more knowledgeable about stat packages please go to this page and add information about Julia packages?

[JackaChou]

Unlike in Julia REPL or the official jupyter notebook, I found that running Julia codes in the vscode-jupyter is very slow. I don’t know the reason, and nobody fixed it.

[ShalokShalom]

Yep. And the complex setup that it requires, is a non-solution.
I would rather ditch the entire language, then using that.

I can, in every single language, popular and non-popular, fire
up VS Code and start scripting.

If Julia forces me to create custom packages and follow a quite involved process
just to use a REPL, you simply lose a lot of people at that point.

If you think this is hyperbolic, then we have a case of organizational blindness here.

[ShalokShalom]

I am particularly happy, that the Julia community consists of mainly scientists, since I trust them more than anybody else, that they can accept that some things may be not hurtful to them, but indeed be objectively suboptimal.

For why some people criticize seemingly a lot, and some are just fine:
Well, that is due to the organizational blindness, as I just described.

People who are happy with the language, often don’t see the weak spots, because for them, they simply don’t exist.

So they can’t tackle the described issues either, since again, they are not really valid concerns to them.

An issue can only be seen as such, if the person experiencing it, does really feel the pain, that it brings with it.

So I believe, it’s kinda an implicit requirement, that you are unhappy with aspects of the project, in order to be able to bring up points, that could improve the ecosystem.

@indymnv

Why setting up an own blog, when there is the Forem?
I guess, thats for what it was made for.

@JackaChou As said, this is sadly also slow for me.
The VSCode extension seems overall lackluster, particularly for a reference implementation.

[Eben60]

@ShalokShalom

If Julia forces me to create custom packages and follow a quite involved process
just to use a REPL

No, it doesn’t, you can very well use Revise just with scripts. Interested how?

[skleinbo]

@ShalokShalom

If Julia forces me to create custom packages and follow a quite involved process
just to use a REPL, you simply lose a lot of people at that point.

The VSCode extension has a setting for loading Revise automatically. And by the way, a Revise-like workflow without some user intervention is not the standard in other REPLs as well. IPython has autoreload, but then again, typing using Revise isn’t any less convenient than %load_ext autoreload %autoreload 2

@ShalokShalom

The VSCode extension seems overall lackluster, particularly for a reference implementation.

I find it quite impressive to be honest. What would “spruce it up” in your opinion?

[Tamas_Papp]

@ShalokShalom

People who are happy with the language, often don’t see the weak spots, because for them, they simply don’t exist.

Almost of the “weak spots” of Julia has been discussed ad nauseam at this point, and the developers and experienced users are acutely aware of them. They are kept track of in (longstanding) issues, and are discussed at JuliaCon (look up the “what’s bad about Julia” and “the state of Julia”). Moreover, gradual improvements happen with every release.

Discussion itself adds little value. Improvements usually requires a lot of work from highly skilled people, who have other priorities, and determine what they want to work on (frequently they are features that are not on the lists of “weak spots” that newbies enumerate, but nevertheless improve the language significantly).

Practically your choices at this point are

@ShalokShalom

ditch the entire language

or accept it as it is, wait for improvements, and optionally start contributing to make them happen faster (even minor contributions that do not address major issues like TTFX are helpful, because they free up core devs to work on the latter).

(BTW, these points are not specific to Julia, but apply to all FOSS languages.)

[indymnv]

@ShalokShalom

Why setting up an own blog, when there is the Forem?
I guess, thats for what it was made for.

It’s a matter of taste I guess, some developers still prefer to have their own site where they can write whatever they want, other people will do it on Medium/Forem.

[ShalokShalom]

I had been made aware about this workflow by that video:

[Video] How to Reduce Julia's Latency

Hi everyone, I made a video about reducing Julia’s latency after a conversation with a friend who said that they really wish all of this information was in one place. Hence, you get this video. Possibly part one of two, where in the second I cover the packages I referenced in the outro of this one (JuliaFormatter, JET, Aqua, and Cthulhu). [Minimise Julia's Latency: Revise, PrecompileTools, and PackageCompiler] Feedback is very welcome! I will mention, though, that while I do talk…

If this is, how you imagine introducing new people to Julia, then I can only give you the feedback, that this will cement Julia to stay a niche language.