Sure, taking the Julia responses alone, you could argue that a high proportion of language's users love it. But when placed alongside other languages, it leads some to conclude that Julia is loved more than Python; if 22,999 people love Python and 786 love Julia, is that really true?
Now, is there reason to think that there is bias in these survey results? That is certainly a possibility.
To a degree I agree with you in that the framing of “most loved” could be approached better with niche vs widespread languages. There are a lot of people who self select into small languages, vs languages in widespread use, so perhaps noting the relative usage would be helpful in contextualizing what people think.
Disclaimer: I don't really like Python, but I don't dread it.
Disclaimer 2: I quite like Julia but every time I have tried to drop Python to use it I have had to go back to Python.
Is that because of library availability or something to do with the interpreter?
First off we're ultimately talking about ordinal data here and even the Evan Miller post in another comment misses that ordinal data is fundamentally tricky. Everyone is talking about the p("most loved") but that makes assumptions that "most loved" has a consistent meaning.
The problem with ordinal data is that the only thing that's known about it is an ordering of the values, but the distance between values is undefined. That is the difference between a 5 star and a 4 star review is not necessarily that same a between a 2 and 1 star review. This means that you can't meaningfully average these.
However there is an even bigger problem, which is what I think parent is feeling here, and that is selection bias. It's very hard to compare the average rating of a film such as Star Wars and a film like Cannibal Holocaust. The first is a general audience film and the later is an extremely niche subset of gore horror. If you show Cannibal Holocaust to the general population it will receive wildly lower rating than Star Wars. However if you were to do a survey of all people who have a DVD of Star Wars and a DVD of Cannibal Holocaust, I wouldn't be at all surprised if Cannibal Holocaust was more loved. There are plenty of people that have Star Wars on their shelf and feel 'meh' about it, but almost no one who owns Cannibal Holocaust on DVD that doesn't feel like it is an essential horror classic.
The annoying truth is, there's really no statistical way to solve this. There are some solutions to better modeling ordinal data (you could for example, transform this problem into an ordinal regression problem). But ultimately "loved" is not really a measurable thing, so we're always looking for imperfect proxies.
fisher.test(matrix(c(786, 298, 22999, 11156), nrow = 2))
#> Fisher's Exact Test for Count Data
#>data: matrix(c(786, 298, 22999, 11156), nrow = 2)
#>p-value = 0.0003266
#>alternative hypothesis: true odds ratio is not equal to 1
#>95 percent confidence interval:
#> 1.116046 1.469612
So I want to raise this caveat as a Julia lover: the love% is highly correlated to why people are using the language, because Julia is not so popular, it's unlikely people (students) are forced to use it, thus less Dread.
But I think Julia deserves to be loved AND widely used.
I see what you did there
Which also likely explains MatLab being absolute last.
(On the flip side, Matlab was a great tool and a significant achievement when introduced in the 70s. Cleve Moler did a lot of great work that advanced the state of art in numerical analysis and applied mathematics. We can celebrate that history while still trying to avoid Matlab whenever possible in 2022.)
1. Making multiplication between arrays a matrix multiplication by default, not element wise. Not everyone is doing LA, the fact that you have to consider different operators /modifiers for multiplying scalars and elementwise vectors adds significant mental overhead if 99.99% of all your multiplication should be elementwise.
2. Why oh why the '.' as the broadcasting operator. Anything (except maybe the komma) would have been better. The '.' is just way too easy to overlook. When I was still helping students with their matlab code (I now use if you want my help as a incentive for them to learn python) the problem was in 90% of the cases a missing dot somewhere. The bad thing is that it breaks in weird ways, you just get nonsensical results without a crash. This is related to point 1, because most of what we do is elementwise so you have to put dots everywhere.
3. Indexing starting with 1. This one is actually very minor and really just a personal preference.
I understand why Julia did this, i.e. to attract the matlab users, but it makes it so much less appealing for those of us who have moved on already due to matlabs shortcomings.
I'm not sure what your complaint is about lack of data structures. I recall using classes and structs and maps and cell arrays regularly without issue in matlab.
There’s really no comparison to any programming language from the past 20 years. Lots of sharp API corners and inexplicable inconsistencies and limitations, gnarly performance overhead even if you know what you are doing and you’re being careful, mediocre debugging tools. It feels like every feature was just bolted on piecemeal and ad-hoc (which they probably were).
If you only need to do mix a few scattered lines of non-numerical code in the middle of a big otherwise matrix-heavy project, it’s not too bad. But I feel pretty sorry for anyone trying to use it as a general-purpose programming language.
It may be just me, but both the list and the ranking are really weird. Not just apples to oranges, more like apples to toilet paper.
Delphi is a language everyone is forced to use at work, horrible legacy projects vs Rust and Elixir that basically noone is using at work and all hobby,fun projects.
BUT at the same time Lisp and Haskell are also rank very low despite being mostly hobby projects type languages.
Delphi evolved from TurboPascal and TP was one of most universally and genuinely adored tools in the late 80s - early 90s. And it was in fact beautifully functional and super fast. Delphi retained most of that even if it acquired some bloat in the process, and it also inherited a lot of goodwill. It sort of dwindled into near non-existence since then, but the whiff of its awesomeness lingers.
Rust has nothing to match any of those three in 2022, maybe in a couple of years.
I think it's safe to say that Julia has a notable ability to polarize people -- you tend to either love it or hate it. Personally, I can hardly even imagine using anything else at this point.
I think this is not true, many of us (including myself) were really intrigued by Julia and really wanted to like it, but came away a bit underwhelmed.
It certainly has some neat ideas and people do very interesting stuff with it. That said it is certainly not the panacea of "write code which is as easy as python but gets you the speed of C".
What is causing the current (small) backlash is the community being so strongly fanboyish and are still selling this uncritical view. Compared Julia fans, Rust proponents sound like they hate their language.
The advocacy is becoming quite off putting.
Try to fight against dispatch and squeeze Julia into OO or functional or etc. paradigms and you're Gonna Have a Bad Time, in my opinion.
So if you avoid mutable vectors and OffsetArrays you should generally be fine.
As far as the argument "Julia is really buggy so it's unusable", I think this can be made for any language - e.g. rand is not random enough, Java's binary search algorithm had an overflow, etc. The fixed issues have tests added so they won't happen again. Maybe copying the test suites from libraries in other languages would have caught these issues earlier, but a new system will have more bugs than a mature system so some amount of bugginess is unavoidable.
Does anyone have any commentary on how mature it is in terms of sharp edges on a typical julia newbie project? (e.g. setup, tooling, onboarding docs, library docs, error messages, etc)
Otherwise, I am in love with this language and with all the tools developed in it. It is the best language for "scientific" machine learning (i.e. autodiff and optimization over weird models that can hardly be represented as neural nets). It is quite a bit less mature for typical ML.
Most languages I've worked with I neither love nor dread. Clicked through to the SO survey results and even skimmed the methodology section, but I couldn't find what question they asked to get these numbers.
I remember in the survey reports it was discussed because there were some languages that were on both the "most loved" list and "most dreaded" lists. I want to say C and R (and maybe Haskell??) were examples of that but it's been awhile.
I'm not sure why they made them mutually exclusive, as it muddies things a bit.
A "no strong opinion" option may have provided some interesting nuance.
Julia is no where on the map in almost every metric (no commonly used libraries, no web frameworks, etc), and even in the other metrics where Julia is listed it is WAAAAYYY down there. Below Lua. Below Haskell. It is even below MATLAB. If that's not a scathing indictment of Julia, I don't know what is.
Even in the "most loved" category, if you look at all the respondents who "want" to use Julia, it is no where near the top.
I know Logan is the community advocate for Julia, but picking just the one slice of data where Julia looks appealing and blogging about just that is very off-putting. If anything, this survey should be a call for introspection or reflection, on what and why Julia is not taking off despite people loving the language. Or a well-rounded blog post on the various metrics where Julia is listed would be much more appreciated. In fact, a blog post on what the plans are to solve static compilation, making first time to plot better, building better tooling, features planned for Julia 2.0 would be much more appreciated than this kind of shameless advertising.
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.
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.
Things that are "better" with modern solvers: computational efficiency (appropriate adaptive choice of step size); numerical stability (detecting when things go wrong); higher precision. And other nice improvements like callbacks and root-finding and sensitivity analysis built into the solvers.
1. Ruby (49.99% love)
2. Scala (50.3% love)
3. C++ (48.39% love)