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

Community
439

Rephrasing the question to “What has the community already done that is very helpful?”. My background as a mechanical engineer gave me one compulsory computer course in WATFIV, and an elective on microprocessors (6502) and some experience programming my HP calculator. After many years I started using MathCad and then MATLAB. From there to Julia starting at version 1.5.
My answer to this question would be:

  1. The book “Julia for Data Analysis”.
  2. Julia and Package documentation
  3. Discourse and Stack Overflow.
  4. Helpful Tutorials that can be found on the internet.

I was doing some infrequent data wrangling in the last couple of days and found myself going to the above book repeatedly, as well as using the other resources mentioned.

3 Likes
440

I can already suggest a title:

“What can be improved for Julia for beginners, teachers and students”

And that is an very important sub-topic IMO

4 Likes
441

I believe that Julia possesses certain advantageous features that R and Python have yet to adopt. Some of these attributes might prove to be quite challenging to implement, while others could even be considered impossible. Imagine the scenario where you create a new data type. With this type in place, it becomes possible to implement comprehensive mathematical operations. Consequently, vectors and matrices of this type work seamlessly. Even the computation of a matrix’s inverse—given that the element type is a custom structure—can be achieved, provided you implement the necessary operators through multiple dispatch.

Here is a sample work of an entire math implemented on a user-defined struct. All of the methods work as they work using Float64’s: https://github.com/jbytecode/JMcDM/blob/main/src/greynumber.jl

Let me to give another specific example. Imagine you need to conduct k-medoids clustering for a dataset containing 100,000 samples. The R implementation necessitates a pre-calculated distance matrix, which is impossible to accommodate on a standard home computer (in fact, the R implementation is capped at 65,535 samples). However, in Julia, you have the option to create an OnDemandDistanceMatrix, a subtype of AbstractMatrix. This allows you to calculate the required distances on-demand, enabling you to utilize Clustering.jl’s kmedoids function. Although it does come at the cost of increased calculation time, it renders the task achievable. At the end, it is now possible.

During one of my university lectures, I delve into subjects like SQL, R, Python, and Julia. I consistently highlight the unique features of Julia and encourage my students to independently recognize the differences. Through some guidance, they come to realize the opportunities that Julia offers, often making a pleasantly surprising choice.

I know that I’ve alluded to multiple dispatch in various ways. However, are users of R and Python truly familiar with these features? Simply stating that ‘multiple dispatch is exceptionally beneficial’ might not resonate with them. Are they conscious of the fact that their operator overloading mechanisms don’t apply to matrix inversions?

In certain scenarios, Python takes the lead. It’s appropriate to let it take the forefront in those domains. Similarly, the current situation applies to R; it has a legacy and is renowned in specific fields. However, what about Julia? What unique capabilities does Julia offer that cannot be replicated using other tools? By showcasing the areas where we bridge the gap, we create more room for newcomers to make their mark.

And yes, all of the aforementioned aspects pertain to the unique language design of Julia, not the packages.

12 Likes
442

Not necessarily, and frequently not. These languages are package-centric, if you provide a proper input to the package, the package will behave as a function barrier and run fast the computations. Some packages work like that in Julia, but most are designed for generality, so that they do not act as function barriers that stabilize the input data types.

Yes, exactly, that’s what happens with Python/R etc. One can frequently do better in Julia using the structure of our own problem, but implementing our own algorithms is already an intermediate step of interaction with the language and requires some understanding of how Julia works.

I do. I find Julia a fantastic language for teaching, because it exposes to the students not only all the high-level stuff (packages, etc) but also the lower level stuff (types, stability, allocations, etc).

On the other side, many Python/R etc programming courses are not about the language itself, but about some specific packages, that’s not really comparable. A course about python for learning programming in general is much less interesting than a Julia one, IMO.

6 Likes
443

Students without computer skills can learn the mechanics of Julia not because they need to, but because they are easy to understand.

Agree. I know how to use tidyverse, but I have no idea about OOP in R.
https://adv-r.hadley.nz/oo.html

I’m not sure it’s a good idea to explain why to use Julia when you are learning something else. Understanding the advantages of Julia over other languages involves unnecessary jargon and complexity. For comparison, the book “Bayesian Statistics using Julia and Turing” explains the advantages of Julia (such as multiple dispatch), but the book “R for Data Science” assumes that the reader wants to use R and goes straight to explaining Data Science concepts.
https://storopoli.io/Bayesian-Julia/pages/01_why_Julia/
https://r4ds.hadley.nz/intro

2 Likes
444

Totally agreed. The objectives are different. I think as a community we tend to explain Julia because we still feel the need to justify why we chose Julia to begin with.

On the other side, if I was using DifferentialEquations I could just start with “we are using this because it is the best tool available for this”, period.

3 Likes
445

Another area like this in my opinion is Agent Based Models. With ABMs you need to describe the behavior and decision making of the individual agents, so you will be programming that logic in the language itself (not by calling some pre-packaged code). But then, you also will be creating some simulations with thousands or millions of agents, and running the simulation for thousands or millions of parameter values to see how behavior varies. So the speed of your decision making logic for the agents is of paramount importance.

Julia also has a really nice Agents.jl package to make running and collecting data on your ABM easy, as well as plotting utilities and etc.

So, right away you can use loops and decision making in Julia code and start studying complex systems, and it is already quite fast. If you do that in Python with the individual agent decisions written in python loops and things, it will be hundreds of times slower.

4 Likes
446

I think the Julia community should rethink how to promote Julia. I’m not sure that comparisons with other programming languages benefit the promotion of Julia.

Julia is good enough for most cases with pros and cons like any other programming language. The book “R for Data Science” explains that it uses R because it is good enough.

In this book, you won’t learn anything about Python, Julia, or any other programming language useful for data science. This isn’t because we think these tools are bad. They’re not! And in practice, most data science teams use a mix of languages, often at least R and Python. But we strongly believe that it’s best to master one tool at a time, and R is a great place to start.

1 Like
447

I might be too late on this thread, but i will say that one of the things that really made it difficult for me was the fact that the language server takes over 50s to load on my computer. It may seem trivial, but these kinds of experiences are very important to “convince” someone who may be experimenting with the language. So i would say better tooling.

10 Likes
448

I don’t mean bashing other languages, but explaining the features of Julia and why they are interesting.

Comparison with other languages is frequently a nice way to learn. For instance one obvious comparison is OOP vs. multiple dispatch, and I don’t think that for most simple uses one is better or worst than the other. But since people will be exposed to OOP sooner or later, I find natural and necessary to explain how Julia is different.

1 Like
449

I have some experience here, having used R in the classroom for quite a long time and writing a book for its use in Introductory Statistics for non-programmers. (Using Julia for Introductory Statistics covers some of that material for Julia). I’ve also, for quite some time now, used Julia in the classroom for non programmers as an accompaniment to a first-semester calculus class. I don’t think either is more advantageous than the other here at the non-programmer, introductory statistics level, and my personal bias would be to use Julia, for its easier-to-pick-up syntax (much easier, IMHO, than the tidyverse style). However, our students (and faculty) really seem to like RStudio more so than Jupyter. There are also many more worked out examples in the R world from books to journal articles to blogs that make R’s promotion for statistics much easier.

6 Likes
450

I’d like to point to hoogle for Haskell as a great example of a tool that would improve finding certain documentation in Julia.

You give in the function signature and it returns a list of all matching methods and their documentation.
For example,

  • Num -> [Num] returns all methods that take in a number and return an array of numbers.
  • Similarly you can ask for all methods of + that take in a Real value, you can even ask to only look into certain packages.

Their syntax is weird, but something similar with Julia syntax might be very helpfull. Especially if it can be called from the REPL.

4 Likes
451

13 posts were split to a new topic: The challenges of documenting generic functions

457

I have an idea to increase Julia’s popularity, but I’m not certain how easy it is to implement from a technical standpoint. Following Wittgenstein: “The limits of my language mean the limits of my world” We should translate the documentation of the Julia base and the packages to other languages (human languages). This will increase the access of Julia to a considerable population that doesn’t speak English. I would suggest starting with Chinese and Spanish. I’m not certain if it is possible to automatize the translation during the CI for example using Deepl API DeepL Translate: The world's most accurate translator. Then, later a native speaker can do screening to double-check that everything is translated correctly, of-course the code examples can remain in English.

Another idea that can help to increase the Julia popularity is to include videos on the Julia language channel whit non-native English speakers/developers explaining their packages and showing how to use it.

Edit:

@lazarusA maybe do you have an idea how to achieve this?

3 Likes
458

Would it make sense to create a blog about Julia written by ChatGPT similar to this one?
https://derekcuevas.github.io

I like this blog because its posts are short and explain a single concept.

459

Yeah, I had looked into splitting out a topic along those lines from these recent posts, but I always try to ensure that both the source thread and the destination thread both remain with a coherent discussion. This sequence was a little more free-wheeling and a little less-directed — which is fitting with the very broad scope of this very topic — and there’s not a clear set of posts that can make for a good start to such a dedicated conversation that’s distinct enough from this one, in my opinion.

Folks can always start their own topics as they’d like!

5 Likes
460

Julia would not be alone if it goes with this suggestion. For an example see here. Perhaps @LaurentPlagne can comment?

461

Rust developers create buzz by explaining upcoming Rust features, such as async fn in traits.

Should Julia developers create similar buzz? What new Julia features could improve the experience for users and IDEs?

3 Likes
462

The PROBLEM with Julia is this

Julia is faster than Python AFTER THE JULIA SOURCE CODE HAS BEEN COMPILED.

It is the time taken by Source Code Compilation that is holding Julia back.

And for the novice user, Julia compiles EVERYTIME it is run.

4 Likes
463

I think the technical solution for user code compile caching is in hand with pkgimages where compiled native code is cached at the package level as of Julia 1.9. What needs to be done to make Pkg.generate() or PkgTemplates.jl easier to use?

Maybe we need a default Local.jl package that a novice can just toss include statements into? This is perhaps a slight variation of the Startup.jl package idea.

1 Like