Critic and his misconceptions

I wonder if it was worthwhile to counter this (IMO) mostly negative narrative Why is Julia not more popular? – The Craft of Coding?

Arguing with critics generally ends badly. Someone gets offended and it creates long-lasting ill will.

Also I agree with 6 of the 9 criticisms.


Which means you don’t agree with 1/3 of the statements, don’t it?

After reading that, ehm, thing, I don’t see how it rises to a level that needs to be engaged with. Read the first point on that list, and you see it isn’t serious in any way.

Also, it’s almost three years old.


Ok, but if I don’t know anything about Julia, I might believe it. (D|M)isinformation should be corrected whenever possible, IMO.

It’s a partially valid low-effort 3-year-old critique that probably got more views in the past 30 minutes than the previous 30 months.

My personal opinion is that “correcting” this blogger will not be productive, and if anything will make the Julia community come across as crusadey, which is already another unfortunate stereotype.


Sincerely, even if I did not know Julia, I think the article would only make me lose any trust in its author, not the language. The first point completely ignores how semantic versioning works, and this to me already discards the author of the role of someone competent enough to do this kind of review.


The number of posts he’s written about why he’s not using Julia really makes it seem like we’re living in his head rent free. Not sure how we’d even go about refuting this post. Like where would you post it?


This is just someone being wrong on the Internet. It happens more often than you would think, and you are going to gain nothing from attempting to correct them. It’ll only reflect badly on you (and the Julia community more broadly).
As always, XKCD is relevant.



I would double down on Stefan’s point here and go further. Treat this as a marketing problem and do some market segmentation for a refutation. Your market is approximately:

  1. People who never read the post.
  2. People who have read the post and agree with it.
  3. People who have read the post and disagree with it.

For (1), writing something makes your situation worse off because they will not ever become a member of (2) unless you raise the visibility of the post.

For (2), you have to understand what you are going to do that will change these people’s minds. Particularly important – will those people trust you more than this author? Do they share your implicit values more than this author’s?

For (3), you’re preaching to the choir.

There is obviously space to target market (2) more for Julia, but it’s tricky and most places you’d post a rebuttal just end up damaging your brand with (1) and (3).


I find most of the reactions here needlessly harsh. The author seems to be enthusiastic about programming languages in general and also writes nice things about Julia by the way, and here he gives his list of perceived problems with the language. I see nothing wrong about that and even agree with several points.

Yes I think some of the points are silly but that’s called disagreeing on some points. Let’s just take the criticism with grace, register the points that look valid (not much new here but it’s still another data point of what annoys people) and ignore the rest or deal with it kindly.

Also, reading HN it seems that our community has a bit of a bad reputation about being quite defensive. I’m afraid the idea expressed here that negative writings about Julia need to be refuted, is exactly what these people are complaining about.


Refutation: Almost all the posts are saying the exact opposite.


I did not have seen that, I took the time to read all of them, and again, my conclusion is the same, he has only lost all credibility to me. It is just pure “this seem a red flag to me, I did not look deeply into this, and I will say some things here that will make you start seriously doubting my competence as a programmer, but I will speak with absolute confidence that these arbitrary metrics that I am using are relevant”. The most telling posts are things like:

Its “multi-paradigm” nature. Yeah, I know other languages have this too, but it does tend to bloat a language.

Well, but it bloats Julia? You do not say, you say it “tends to bloat a language”.

Things always seem to break. Code I write that sits around for a month no longer works when I update the compiler. This is less of a problem now, but it still happens, and is an affect of working with a language that is evolving.

This is March 2022…

Memory consumption is extremely high. Compare the peak memory usage for a program that does nothing more than print “hell0” […]

… this is because of the compilation step …

The language is not stable, and by that I mean it seems to have a lot of bugs. You can’t really call something that has bugs stable.

… what a lazy and arbitrary metric, if you look at Rust issue tracker it has thousands of bugs open, and the language is known as a pinnacle of stability …

The version hopping hasn’t really abated. I see V1.6 is in beta, and V1.7 is in development. Why, why oh why? Maybe stick with one version for a year, then release another version? With every new release I have to wonder if my code stills works, or if some small change will break it. At least if I code stuff in Fortran 95 at least I know what I’m getting.

Again not understanding how semantic versioning works.

Julia tries to be “everything to everyone”, but this seldom works well […]

The same thing again but gives no example of how Julia is getting bloated or how it affecting people negatively.

The fact that it terminates control structures with and end, is much nicer than C’s use of { }, although some might no doubt disagree. One-based indexing is great too, because I never liked 0-based indexing

… this is the kinda of thing that he cares about …

This is a good example of when language designers do something that just doesn’t make sense. Maybe it’s because there are so many people involved in the design of Julia.

He is talking about the “scope problem” that has multiple threads on this Discourse and many many posts from the creators explaining the why things were done this way. Does it seems he have searched and tried to understand the design decision? Of course not. He just complains about it and say designers did something that did not make sense “probably because there is a lot of people involved in the design”.

Version 1.0 was finally released in August 2018, and the most recent release in August 2020 is V1.5. Too many small changes and tweaking. It makes one nauseous just thinking about small things in your older code that potentially won’t work.

It has supposedly had contributions from over 870 developers worldwide. Ever tried to cook with more than 1-2 people in the kitchen? Just say-in.

The name. Why call the language Julia?

In the ends, the complaints are almost always the same, and based more on his own biases about how things “probably” should be/work than any empirical evidence (a clear case of: sources? the voices inside my head).