[anonymoushn]

> Yuri's criticism was not that Julia has correctness bugs as a language

Are you sure? Here are some issues from the post:

"Wrong if-else control flow" seems like a language issue? bug is still open [0]

"Wrong results since some copyto! methods don’t check for aliasing" seems like a bug in a core library. The bug, which is filed against Julia, not some third-party library, is still open [1]

"The product function can produce incorrect results for 8-bit, 16-bit, and 32-bit integers" was a bug in a core library, which was fixed [2]

"Base functions sum!, prod!, any!, and all! may silently return incorrect results" seems like a bug in a core library and is still open [3]

"Off-by-one error in dayofquarter() in leap years" seems like a bug in a core library which was fixed [4]

"Pipeline with stdout=IOStream writes out of order" seems like a bug in a core library and is still open [5]

I've been deliberately conservative here and only posted the issues from Yuri's post that are in the JuliaLang/julia repository. The other issues are filed against JuliaStats/Distributions.jl, JuliaStats/StatsBase.jl, JuliaCollections/OrderedCollections.jl, and JuliaPhysics/Measurements.jl. Since I have not used Julia very much, I don't know whether these are commonly used libraries or obscure libraries nobody uses, but they seem pretty close to the core use-cases of the language. Maybe someone who uses the language a lot more can shed some light on this issue.

Some commenters seem exhausted by what they perceive as a continual stream of lies about these topics, which has left them less inclined to post about them.

[0]: https://github.com/JuliaLang/julia/issues/41096

[1]: https://github.com/JuliaLang/julia/issues/39460

[2]: https://github.com/JuliaLang/julia/issues/39183

[3]: https://github.com/JuliaLang/julia/issues/39385

[4]: https://github.com/JuliaLang/julia/pull/36543

[5]: https://github.com/JuliaLang/julia/issues/36069

[ninjin]

At its core, yes, Yuri wanted to highlight the fact that the “power” of the language created more or less “a fractal” of type/function composition cases that made it very difficult to guarantee the correctness of a given call site. This is inherent in the language, but causes potential issues across the ecosystem and he felt that the community did not take it as seriously as he would have hoped. At least that is the takeaway I got from both talking to him and reading what he wrote.

To me, this is a long and complex discussion to be had by those that understand general programming language design and the case for Julia itself and frankly statements like “Some commenters seem exhausted by what they perceive as a continual stream of lies about these topics, which has left them less inclined to post about them.” are bloody cheap, unfalsifiable, and adds little to nothing to the discussion.

[anonymoushn]

> At its core, yes, Yuri wanted to highlight the fact that the “power” of the language created more or less “a fractal” of type/function composition cases that made it very difficult to guarantee the correctness of a given call site. This is inherent in the language, but causes potential issues across the ecosystem and he felt that the community did not take it as seriously as he would have hoped. At least that is the takeaway I got from both talking to him and reading what he wrote.

For things like "The majority of sampling methods are unsafe and incorrect in the presence of offset axes" I agree that this is just some unfortunate combination of library code and concerns that the library authors had not considered, but the numerous correctness issues in the language and stdlib seem like they would often make it hard to figure out what exactly the problem is.

> bloody cheap, unfalsifiable, and adds little to nothing to the discussion.

Sorry about that. I'm not sure how to highlight the recurring nature of these less-than-factual posts and their effect on some members of the community while respecting the wishes of those people.

[ninjin]

> For things like "The majority of sampling methods are unsafe and incorrect in the presence of offset axes" I agree that this is just some unfortunate combination of library code and concerns that the library authors had not considered, but the numerous correctness issues in the language and stdlib seem like they would often make it hard to figure out what exactly the problem is.

I am not sure what we are arguing here. You asked what Yuri originally wanted to highlight and I answered based on my own insights. I have re-read what he wrote and I still stand by my conclusion and I see no point in arguing back and forth as I have stated here and in a comment when Yuri’s post was originally submitted [1] that all the issues are derived from how Julia as a language handles types and dispatch. Everything beyond this is arguing minute semantics and frankly very uninteresting compared to a discussion as to whether it can be resolved and how.

[1]: https://news.ycombinator.com/item?id=31398040

> Sorry about that. I'm not sure how to highlight the recurring nature of these less-than-factual posts and their effect on some members of the community while respecting the wishes of those people.

Not sure if I can consider this an apology when you in your very next breath make exactly the same kind of vague statement that I called out in the first place. Since you apparently know these people, how about collecting their opinions and presenting them anonymised? Likewise, if there are lies spread across so many posts, why not simply collect and refute them? This all seems obvious to me, but maybe I am missing something? In fact, I find posts such as yours in very stark contrast to what Yuri wrote and accomplished with his post, so perhaps you can find inspiration there?

[anonymoushn]

If the project has cultural issues that would cause severe correctness issues regardless of the language's semantics, it may not be that useful to talk about technical solutions that would let other projects without these cultural issues make a language with similar semantics and fewer correctness issues.

> Since you apparently know these people, how about collecting their opinions and presenting them anonymised

This sounds like the sort of claim that would get called out as unfalsifiable online.

> Likewise, if there are lies spread across so many posts, why not simply collect and refute them? This all seems obvious to me, but maybe I am missing something?

Is the question really "Why don't you just do a lot of work for me, for free, since I will not use a search engine?"

[ninjin]

> If the project has cultural issues that would cause severe correctness issues regardless of the language's semantics, it may not be that useful to talk about technical solutions that would let other projects without these cultural issues make a language with similar semantics and fewer correctness issues.

How can solving – or failing to solve – a technical issue that could then lead to insights shared between communities ever be a bad thing? Maybe I am just too thick to see it? But I am ending my efforts at this point as I am not getting any closer to understanding what you are trying to convey.

As for your “comebacks”, we clearly have very different standards and expectations when it comes to discourse. Where I come from, those that bring claims are expected to also bring adequate evidence – or at the very least attempt to do so and not spread claims just to later throw their hands into the air when called out for it.

[Sukera]

[0] is already fixed on master but can't be backported to LTS due to the fix introducing other problems specific to LTS. [2] is closed. [3] should be fixed, but doesn't seem trivial to do. [4] is a regular ol' bug (again, not a language but a library bug). Same goes for [5].

From the linked stuff, only [0] is a true correctness problem of the language and not a bug in a library.

> Some commenters seem exhausted by what they perceive as a continual stream of lies about these topics, which has left them less inclined to post about them.

How is differentiating bugs in the language (parser, compiler, type system, ...) from bugs in libraries implemented in the language "lying about these topics"? It's not like julia is claiming to prevent logic bugs, or am I missing something.

[anonymoushn]

"Yuri's criticism was not that Julia has correctness bugs as a language" would be an appropriate thing to say if none of the bugs in the post were "Wrong if-else control flow."

Edit: "certain libraries when composed with common operations had bugs" also does not seem like a completely on-the-level way to describe bugs in the stdlib that do not require any particular composition to encounter.

[ViralBShah]

If you look at the linked issue, you will see that it is a type intersection issue (a real language issue) mischaracterized as a control-flow bug. Many readers here seem to see that and believe that if statements in Julia are broken - no that is not the case.

[anonymoushn]

As an end user it may be hard for me to accept that there are no control-flow bugs involved when this code

    println(flag)
    if flag
        println("flow for true.")
    else
        println("flow for false.")
    end

prints

  false
  flow for true.

[oivey]

I pasted that code into a REPL (including setting flag=false, which seems to be implied) and got:

  false
  flow for false.

How did you get your output? Your post implies that if statements are broken in Julia. Untrue.

[jakobnissen]

It is from the top comment in https://github.com/JuliaLang/julia/issues/41096