I agree that the experience is extremely off putting. But having been in the community for almost 5 years now, I have to say there are super awesome lovely people that are mostly silently working in the background and very hard at that. The loud minority unfortunately is grating, and I do wish the stewards of the language established more strict guidelines on conduct or philosophy of the language. I don’t want to name names here, but when prominent members of the Julia community bash other programming languages while ignoring the painful friction in Julia, it comes across as very tone deaf and in poor taste, and does set a bad precedent.
I think having a weekly what’s great about Python/Rust/Go/Zig and how can we port this to Julia would be awesome, instead of the weekly gripes about Python/MATLAB/R.
I've seen that post as well, and often wondered if it was fair characterization of overall Julia community (maybe it is), or is the result of a single bad apple at the top that overshadowed an otherwise pleasant community.
Unfortunately, it doesn't take much negative energy to spoil a community, even if it comes from just one person. That it was a language co-creator is troubling but not necessarily a reason to avoid the language if the rest of the community is nice (which maybe it is, maybe it isn't).
However one thing I have noticed is that most language communities do tend to follow an attitude set by the language creator(s). This seems to have played out quite a bit for Clojure, Python, Elm, Elixir, and other languages where, at least to me, the overall shared perspective of the community is closely aligned to the personal attitudes and opinions of the language author(s).
Ouch! As a big Julia fan I cannot exactly complain about these criticism. They seem overall very fair. Although some things like tracking down problems I think is affected a lot by what you are used to. I am way slower figuring out problems in Python than in Julia.
But the heavily academic code and often poor user documentation for third party packages is a very real problem. I would like to point out that I think the Julia core libraries are better documented than Python. But third party stuff often has a long way to go.
I also think Julia may suffer a bit from people writing a lot of CLEVER code. I am computer science guy who feel lost in the midst of all these brainy Julia PhDs, postdocs and researchers. I think maybe many of us more regular programmers have a bit healthier habits in writing code a little bit less clever and and perhaps more verbose.
It is not all bad though. I think that the APIs to a lot of Julia libraries are quite well thought out. It is more the inside of a lot of these packages which can look a bit messy.
Perhaps Julia code quality and documentation can improve when the language starts expanding more outside academia and more among general programmers, industry etc.
I don't think it's the same for the languages that you listed, they seem much more pragmatic and willing to acknowledge flaws and tradeoffs. Maybe the Julia community comes close to Rust in the degree of cultiness.
Blog posts (and especially public forum posts and github issue discussions) on the topics you care about are quite common. It seems very normal and unsurprising that a community advocate would cheerlead survey results like this and let others discuss the topics you mentioned (and they do). I am also surprised by your "scathing indictment" comment. Julia released its first stable version 3 years ago. MATLAB/R/Haskell have existed for decades. Julia has 30% of the user-share of MATLAB (and same order of magnitude comparisons to R and Haskell). This seems like a pretty big achievement already, especially when you see where these other languages are on the "love" scale.
Don't get me wrong, there is plenty that needs to further be fixed with Julia, but it is pretty easy to see that there is serious progress on all these tasks when you look at their forum and github. For a language conceived 10 years ago and having its first stable release 3 years ago, this seems quite amazing to me.
I've tried Julia and really liked it, but the user experience was pretty bad. The language really needs faster interactivity or a strong type checker. I found myself waiting after than compiler a lot more than in some AOT compiled language like Rust... I fear the language suffers from being overused by people who are familiar with Matlab and Python and draws too much inspiration from them, much like how Rust draws too much inspiration from C++.
I've generally found the Julia community less welcoming than some (Rust, Python), although much better than the "classics" (C,C++,Java and friends).
For example, picking the first question I can see on discourse (which isn't a clear technical question, it was number 3) is "What is the status of debugger?". The first answer is "I've used Julia for 3 years and I don't need a debugger" whereas searching for similar questions on the Rust discourse tends to find answers.
This isn't a complete investigation, it might just be me generalising from my small number of interactions with the Julia and Rust communities.
> It seems very normal and unsurprising that a community advocate would cheerlead survey results like this and let others discuss the topics you mentioned (and they do).
Maybe I find it a little tone deaf. As someone that has been using Julia for a long time and still seen very little growth in the language (compared to Rust for example), and sees users on a regular basis complain about basic issues in Julia (tooling being the biggest one for me), I find it off-putting and evangelizing when prominent community members blatantly disregard information counter to the narrative they want to establish. I hold Logan to a much higher standard, and the tone in the blog post rubbed me the wrong way. Even on Slack, there's a discussion of how "little" Julia is in this survey, and for the public messaging to be different from what a lot of users are voicing feels off. I do feel my comment was a stronger reaction, but it was perhaps stemming from my frustrations after seeing the survey, seeing it discussed on slack, seeing it discussed at work, and then reading this post.
> I am also surprised by your "scathing indictment" comment. Julia released its first stable version 3 years ago. MATLAB/R/Haskell have existed for decades. Julia has 30% of the user-share of MATLAB (and same order of magnitude comparisons to R and Haskell). This seems like a pretty big achievement already, especially when you see where these other languages are on the "love" scale.
Perhaps. Maybe I was too strong here. Julia has come a long way, and I absolutely love using it over MATLAB. But scientists and researchers are still picking MATLAB over Julia today, and that is extremely troubling for the future of the language. People are dreaming that Julia will eat Python's lunch when Julia seems like it is barely catching up to MATLAB.
I think Julia will get there eventually. But maybe I need to adjust my expectations. I previously was hopeful that after Julia 1.0, adoption would skyrocket. It did increase, but not to the extent that I would have liked. After Julia 1.6, I was hopeful again. But I think I just need to temper my expectations. Maybe after like 10 years it might be a popular language, but right now it feels like it is such an extremely niche language, and that personally hurts that I've sunk so much time and effort into it.
Beyond the state of the Julia Language (which I am excited to try out since 1.0), the core community comes off really badly in this post, and the previous follow-up discussion on HN [1], and julia-users group [2].
As an enthusiastic Julia user, I can definitely attest to this. It's frustrating to just want to share with people what you find cool about a language, only to be accused of being part of some astroturfing campaign, or for any discussion of the language being immediately derailed by people complaining about 1-based indexing.
Granted, there are definitely cases out there where Julia users have been overzealous and undersensitive when trying to convince others to come try out the language, but my experience with these people is that they're almost always coming at it from a place of just being excited about finding a language that works well for them and solved so many of their issues, and so they want to share that with others.
____
D is a cool language and it's a shame it seems to get ignored so much. I hope D people continue to work at it.
Having used Julia for 2+ years, I couldn't disagree more. Productionizing Julia code has been a total nightmare. The community library support has been growing but hasn't gone through the wringer. Just because things are improving doesn't provide a meaningful understanding against its competitors.
I don't see any reason to use Julia over Go for backend webservers. Rust or C++ for systems programming. And frankly, I prefer Python for scientific computing.
Julia also has a tiny standard library and lots of flaky external libs which make productionization of code a risky adventure which I have personally been bitten by.
Most people are allured by Julia's overhyped marketing which is a shame because the original paper by Stefan is pretty impressive. We're seeing some criticisms of Julia in this thread, rightfully so.
My advise to people who are subscribed to Julia's marketing is to listen to people that are complaining. No one wants to just complain, they're saying that because of many reasons. Be humble and try to listen, accept Julia's many shortcomings (error messages and stack traces, library support, startup time, IDE, debugging, etc.). Julia has many shortcomings that are only apparently after using it outside of the Jupyter Notebooks. Not accepting those makes you an annoying fanboy.
What you've pointed out might all be valid. But they seem to be issues with maturity. When Python was at a similar age, did it have all these issues worked out?
Not sure if you can generalize it to "Julia community isn't interested".
If we have more ppl liking Julia and using it for general purpose computing (which it is capable of), then more of these tools will become mature overtime.
Also, Julia is not in the same niche as Rust though, it's more like a Python, so not sure if the comparison is apt.
While I don't think this piece was well argued I must agreee with the sentiment that Julia is somewhat of a disappointment, at least for me personally.
Last year I started learning Rust and wanted to use it instead of C++ in the future. I since have programmed quite a lot in it, contributed to open source software and absolutely have fallen in love with it.
So this year I wanted to replace my default scripting language (Python) with Julia and potentially use it for my simulations or ML in the future.
But every time I take a stab at Julia - last time around the release of version 1 - it never really stops feeling foreign. Everything is slightly unintuitive and weird. Also, learning Julia made me realize how amazing Rust's learning resources are. Besides the official book and the API docs (with an amazing template), there are a lot of great third party and actively maintained resources likes cheats.rs. I never felt Rust was unituitive or hard to learn. Even if some concepts are unique, the resources do a great job of introducing them to you. While Julia's learning website lists an exercism course, its manual and a bunch of video lectures.
I think selling Julia as a Python competitor raises wrong expectations. Julia may look easy or Python-like but is far more difficult to use IMHO. They may be similar in terms of applications but at least in how they feel to use, they are very different.
I still haven't given up but whereas I speak very highly and enthusiastically of Rust and recommend it everywhere (yes I am one of those people), I cannot see myself doing the same for Julia in the future.
Ps.: I wish there was a book club-like way of learning programming languages and discussing progress with friends. That would make learning even more fun.
Julia is too quirky. Its one-indexing thing, general time-to-first-plot problems, and its multiple dispatch by default makes it hard to advocate to a general audience (or a community as big as "Deep Learning community").
The ecosystem also feels weird. For example for CLI parsing in Python I do argparse/click, in Rust I do clap. Both work well (Rust especially so). Julia seems to have ArgParse.jl which I found unpleasant. My guess is that this sentiment spills to other areas as well in the ecosystem. I am sure that Julia has very well designed libraries, but most of the rest are not so honed for practical use, and most importantly, probably lacks some features that Python-equivalent ones have.
Also personally (I am far from a DL researcher but I do research), I find Julia's design headachy as well quite some times. I like Python yield statements for iterators but the equivalent in Julia is always more complicated. Making Julia code performant requires another layer of intuition of how the JIT works. Julia has type annotations but "type annotations as lightweight formal methods" often cannot be fulfilled due to design (for example one cannot annotate the equivalent of `map :: (a -> b) -> [a] -> [b]`). Of course I stand corrected as only a casual Julia user.
I also want to say that I only stated my criticism towards the language. There are many many good things about Julia that I will just omit due to time.
A few months ago, I was forced to work with Julia. What a dreadful experience. Matlabish syntax (did the creator of the language ask satan for advice?). Working with the namespaces is like waking with a stick in the a$$. Libraries are sparce, immature and buggy. The fanboys claim it's fast off the bat, but you only get fast results after lots of tweaks and tricks. Thanks God my manager came back to his senses and we reverted back to Python.
I only wish failure, ridicule and complete obliteration to the Julia project
I'm a moderator at Julia's discourse site. We've seen this happen and we're working on improving this, but I'm also (biased and) sympathetic to the "Julia community" writ large.
Julia's optimal sorts of workflows are different than many expect — especially for folks coming from static languages. Julia is a dynamic language. But also, Julia isn't Python. There are ways in which your workflows from other languages just aren't optimal in Julia. So when someone comes in "hot" and rants about how their workflow isn't working out how they expect, others jump in and — yes, defensively at times — point out alternatives that work for them.
I think some of this tension comes from an expectation mismatch. Some of the changes noted in these comments about how Julia is presented on julialang.org were made specifically due to this sort of expectation mismatch.
This doesn't mean that nobody in the community cares about improving workflows — in fact I know that's not true. But if you want to use Julia today, there are definitely some happy paths that we should guide folks towards.
I'm not that up to date on the language, it's been a few years since I did anything nontrivial with it because the experience was so poor. And while that might not seem fair to Julia, it's my honest experience: my concern isn't a pissing match between Julia and the world, it's that bad JIT experience is a huge turnoff and I'm worried about Python's future as it goes down this road.
I hate Julia. It is not about the language but rather about the community surrounding it. Take for examples this post. I have nothing against the author, but everyone using Julia pretends they have leveled the playing field. That they need more than C but don't want to waste their with Assembly because they are too superior. It is a bit like the Arch community, where superiority is claimed and all alternatives are dumbed down because they are not on the cool table.
Out of principle I don't engage with products like these because you either become part of them or will never get truly involved.
Julia always was one of the languages I wondered whether I should have a closer look at (do python data-science stuff mostly, so it is an interesting project). However, reading Dan Luu writing about his experiences with members of the Julia community https://danluu.com/julialang/ I try my best to not get anywhere near it. Directly cited:
Update: this post was edited a bit to remove a sentence about how friendly
the Julia community is since that no longer seemed appropriate in light of
recent private and semi-private communications from one of the co-creators
of Julia. They were, by far, the nastiest and most dishonest responses I've
ever gotten to any blog post. Some of those responses were on a private
discussion channel; multiple people later talked to me about how shocked
they were at the sheer meanness and dishonesty of the responses. Oh, and
there's also the public mailing list. The responses there weren't in the
same league, but even so, I didn't stick around long since I unsubscribed
when one the Julia co-creators responded with something bad enough that it
prompted someone else to to suggest sticking to the facts and avoiding
attacks. That wasn't the first attack, or even the first one to prompt
someone to respond and ask that people stay on topic; it just happened to
be the one that made me think that we weren't going to have a productive
discussion. I extended an olive branch before leaving, but who knows what
happened there?
Update 2, 1 year later: The same person who previously attacked me in
private is now posting heavily edited and misleading excerpts in an attempt
to discredit this post. I'm not going to post the full content in part
because it's extremely long, but mostly because it's a gross violation of
that community's norms to post internal content publicly. If you know
anyone in the RC community who was there for the discussion before the
edits and you want the truth, ask your RC buddy for their take. If you
don't know any RC folks, consider that my debate partner's behavior was so
egregious that multiple people asked him to stop, and many more people
messaged me privately to talk about how inappropriate his behavior was. If
you compare that to what's been publicly dredged up, you can get an idea of
both how representative the public excerpts are and of how honest the other
person is being._
I think having a weekly what’s great about Python/Rust/Go/Zig and how can we port this to Julia would be awesome, instead of the weekly gripes about Python/MATLAB/R.
reply