Julia as first language

Quarto works well with Julia, and there’s also Weave.jl which is pretty nice IMO.

For parsing, Julia is migrating toward using JuliaSyntax.jl, which gives much more informative error messages.

I had missed this. I agree that having an installation option that automatically includes things like Revise could be very helpful.

I’m not sure what you mean by this. Julia works great with both. Does it not work well with Jupyter-in-VS-code?

I hear this come up sometimes, and honestly I don’t get it. In my experience it was very welcoming. But I’m a type 1 nerd by @sdanisch 's taxonomy, so maybe that’s it?


I totally see your point, and I think that’s a sensible distinction.

Personally, I see myself in camp no 3. I totally care for programming, and love it. I don’t see a need in my life to do it, and do it just out of fun, and because it feels very close to my nature.

The point where I see this differ to your point 1, is that I am not willing to deal with absent documentation, simply because I think it’s a testament of a lack of care.

And documentation driven development can very much help with this.

Julia’s documentation is currently among the best of all languages that I consider modern and interesting. I read repeatedly, that it was not as good in the past, but currently, I think a lot of love and care has gone into it.

Swift is one of the few languages, that can compare, and I still prefer Julia in this regard.

This hints, that somebody has taken the critic of Julia’s documentation to heart, and I suspect the reason behind this is, that somebody saw value in providing documentation.

You don’t do this, if you don’t care, or if you think there is no value in it.

So now I am asking who is interested, and cares deeply, about the development of the language as being as accessible as possible. :slightly_smiling_face:

Programming communities are very eager, to point out, how welcoming they are to minority, and a lot of this seems performative, as it only applies to sexual orientation and skin color.

But not to the experience level.

I personally feel, and I say this with 5 years into approaching programming, that programming communities take this lightly, and care only to the extent, that a change would help the experienced programmers as well.

And this is the reason why I write this post, and I am sorry, if I failed to properly communicate this. This post is not intended to gain movement about certain issues.

I like to evaluate, how much interest there is, to move the language into that direction at all.

And I listed a few example cases, since I wanted to show, that I care, and that I have already considered multiple aspects, also in order to show the direction I mean.

But this post is mainly about evaluating, if this is even in line with the direction the language is intended to take.

And this seems entirely unclear, even to the people themselves.

This thread is great and I want this discussion to thrive! But it’s also moving pretty quick at the moment, so I’m going to try something new here: I’m going to give everyone a chance to read the posts thus far. In the past hour alone, there’s been over 3000 words added to this thread, which is about 10 minutes worth of fast-reading time… and the whole thread itself is nearly 8000 words!

So read and reflect and come back in an hour. :slight_smile:


This topic was automatically opened after 60 minutes.

I think more about something like this, when I speak about literate programming.

Yep. :+1:t3:
As mentioned in the post that is linked further up, do I welcome the changes that are coming with JuliaSyntax. I consider them very fundamental to my choice of Julia as a programming language. :slightly_smiling_face:

I feel that JuliaSyntax does improve the situation significantly, and I am very thankful for it. :tada:

We have a post about this. Making Revise the default?

Well, it works somewhat ok. Some other user said the vscode extension is quite buggy for him, when used together with the notebook. I get compile times of 6 seconds for a simple function.

The person has commented, that it seems like the vscode extension is not purposefully checked to work with the Jupyter extension.

I am sure, that’s a small issue. As most of what I deem to be important.

And I did not say otherwise. :slightly_smiling_face:

I just like to understand if there is a mindset present among the community, that feels dedicated to introduce people to programming.

And I do think that large parts of Julia is indeed very welcoming.
Otherwise, I wouldn’t be here. :slightly_smiling_face:

I just think there could be made some improvements, to further strengthen that feature.
And I simply like to understand, if the goal of Julia as a language is, to purposefully do that.

Is Julia a language that is aimed at beginners?


I really don’t think it is. Julia is a language aimed at scientific and technical computing practitioners. A good pathway to Julia might be to learn Racket and then once you have a baseline of computing knowledge, learn Julia. I think you could learn enough racket to dive into Julia in a couple months if you had the right resources.


It’s quite challenging to describe the foremost goals of an open-source community writ large. It’s even harder to prescribe what people need to work on. There are many contributors and many motivations. But the initial rallying cry which introduced the language to the world still serves as a decent vision for many of us.

Personally, I think a foremost goal for the language is to be the last language. And for it to be someone’s last language, of course they need to learn it. Necessarily, the community grew from folks who already knew programming in the early days, but now it’s definitely important to be able to speak to much broader audiences.

So, yes, I do think it’s significantly important for us to address onboarding roadbumps and papercuts. And to do that we do need the help of newcomers. It’s not always obvious where these bumps are, and squeaky wheels get the grease. Sometimes, though, it is obvious and there are deep reasons that have prevented us from doing better, despite folks’ best efforts and desires.



1 Like

To be the last language, I think it’s almost a requirement to be viable as the first language.

I feel like it’s largely overseen, by the programming community as a whole, how important that is.
Just check, how many programmers had been in existence 10, 20 years ago.

We are now many millions more.

As the population is growing, the amount of programmers is growing a like.

I think there is much more potential to pick up non-programmers, as there is to convince people who are already at Python.

Sadly, no up-and-coming language seems to really understand this.

Please read my next sentence.


This thread somewhat baffling to me. I have 0 formal training in CS, and have had to pick up R, C++, and Julia. I think that Julia has the finest official documentation of all 3 languages I know, the official manual really does read quite pleasantly. Of course there is room for improvement but most things are always works in progress. R has of course much more unofficial guides targeting new users, but they have a massive labor advantage, being an older language and having lots of financial support from groups like Posit (formerly RStudio). I expect Julia will pick up steam in time…it has already been catching up quite nicely!

[EDIT]: I feel the need to clarify why I find the premise a little hard to understand. The nature of the open community means lots of people have different interests, there’s some people interested in writing friendly beginner resources, some people interested in developing obscure things to help advanced devs, and everything in between. I think referring to “the community” as having one mind is a bit strange. That being said I think there’s a lot of evidence for people and projects in the community caring about the newcomer experience, with the well written manuals, not just for the official Julia docs, but also large successful projects (JuMP documentation is a pleasure to read, I don’t use SciML but I’ve perused it and also found it to be generally quite nice too).


This is easy: just release your language right before the Apocalypse. :wink:


I largely agree with @sdanisch’s reply that there are two camps of people and chosing the right introduction language depends on which people they are, but I think there is also a bit of perspective here.

So, perhaps I belong to the “group 1”. On the other hand, when I was first introduced to Python, I was blown away by the simplicity of its syntax. Before, programming to me was largely a nerdy hobby, something that I can build and toy with but not actually something that really simplifies my problems. Python showed me that I can definitely use this knowledge to do things that would otherwise take me significantly longer or would maybe even be impossible.

I think the major question is for whom should the language be used as an introduction.
In the context of science students, I believe Julia is easily the best option - So many things that used to bother me in python are very intuitive in julia (“why on earth would you use ^ for anything other than exponentiation?”). The type system of multiple dispatch makes so much sense to anyone with a somewhat mathematical background. If you have gone from integers to rationals to reals and then to complex numbers it immediately becomes sensible why you would dispatch on Matrix{<:Real}. It is then no big step to understand what an AbstractVector{<:AbstractFloat} might be.

On the other hand, people may come from different backgrounds. Maybe, explaining the advantages of multiple dispatch isnt worth it to people who want to learn the fundamentals of computer science, want to make some nice plots or want to program a simple robot in a video game. For each of these people, the best language might or might not be another one and thats fine.
Like with any other question of which language is the best, the answer is usually to “use the right tool for the job”.


In thinking about these questions as a whole, absolutely Julia is suitable for beginners. As a concrete example, compare the books Think Python and Think Julia (also shared by @stevengj earlier). These are two great books for beginners, written in a similar style, and to my mind shows that both languages are suitable for beginners. Could one really argue that Julia is somehow harder or not for beginners based on those two books?

My next question would be, are any languages aimed at beginners? Nothing here suggests Python was “for beginners”; it was just a language replacement. It’s the learning resources combined with syntax that makes it easy to learn, and Julia has a nice (better, IMHO) syntax, and the learning resources are ever growing (remember that when Julia first appeared Python was at v3 already and 22 years old). I don’t think any pivot has to be made, things just need time and volunteers(!!!) to grow. Can things be improved? Certainly, but people only have so many hours to devote.

And for the last question, I would argue that the simple fact that we’re all here participating in this thread and many others across Discourse/Slack/Zulip/Discord shows that the community does care and wants to help the language usage grow.


I love the Julia language and find the syntax very beginner friendly. I simultaneously think it needs a tremendous amount of work toward better tooling and documentation to be remotely as user-friendly as the Matlab I came from. To that end, I have been (slowly) pointing out documentation deficiencies and writing documentation where I can. For tooling improvements, guides are being written, but the packages themselves also need improvements:

These beginner-friendly factors are especially important while we don’t have small binary executables, because even users of your code will need a basic understanding of how to get Julia running in an environment. Since this is open-source, the real question is how to get more qualified people interested in tackling the many hundreds of existing Github issues without paying them. (Pkg. VSCode. Documenter.) I think most of the common pain points are known at this point, but to my knowledge many of these critical packages are maintained by less than three people.

(Some relevant discussion was had in this thread on Julia’s flaws and over-promising Julia performance.)


I think there would be a large benefit to making the tooling easier for less experienced users. However, the work of Rstudio on the ide and packages was done primarily during the period after one of founders of r basically gave up on R due to its design and performance. A decade later, google is using it for their data analytics certificate. Putting together an opinionated set of tools, which worked well out of box, might be helpful to make it more widely adopted even if it’s not as the first language.


As I said above I think Racket is a better starting point and part of the reason is because it really is aimed at beginners it’s designed to be a educational language. Python also was designed for educational purposes and came out of an earlier language I believe called ABC History of Python - Wikipedia

While it’s made huge changes since then ultimately it’s early design influence was through pedagogical ideas


I agree that this is the way to teach students that are going to be programmers. It may not be practical for people that are going to use code to do things, but are unlikely to be “code-first”. There’s a reason R is so popular among scientists that need to do some stats that has nothing to do with how good a language it is to learn underlying principles.

But I agree that Julia could be excellent for these folks too, since it can fill the “just need to get shit done” role, and then some fraction of those people have the opportunity to go deeper without needing to learn a while new language. The trouble is that attracting this class of person requires colleagues that use the language, or A LOT of self-actionable online help. I don’t think a concerted effort to build that is likely to yield fruit (though sustained efforts from folks like you and Bogumil and others to answer SO questions surely helps). I think it needs to grow organically.


I think Julia is sufficiently good as a first language that these people can go straight to Julia. It’s not necessarily ideal as a first language, it’s not necessary aimed at first-language, but it’s not actually BAD as a first language, it’s substantially better than R for example. Examples are because R has weird nonstandard evaluation whereas Julia has explicit macros for example, and R has like 137 “object systems” and no actual first class structs, while Julia has zero “object systems” and no need for them, and has first class structs. Also Julia compiles to machine code and is therefore fast, while R compiles to a bytecode and is dog slow. R leaves you as a second class citizen since all its “fast” stuff is actually in C/Fortran/C++ under the hood. So yeah, you can get away with Julia as your first language and it’s not a terrible situation.

Still, it’s easier to understand Julia if you have a background in something simpler. Scheme is really good as a starting point honestly. I’m with @ChrisRackauckas when he says that MIT moving to Python was a mistake.