This happens to some extent, particularly in the US's electoral system. But I'd argue the incentive for divisive politics is coming mostly from the fleeting nature of our communication media (plus legitimate grievances that mainstream politicians were out of touch with for a long time).

Twitter was already a politically destabilizing force even before data analysis and manipulation caught up to it. The medium itself punishes constructive interactions and ideas.

https://en.wikipedia.org/wiki/McNamara_fallacy

What's been presented as an indictment of Julia (in Yuri's own post and after) is the fact that members of the Julia community have vocally downplayed problems and played the victim when quality concerns have been raised, as I think you're doing. Do you want to convince everybody you've "won" "a lose-lose"? Or do you want to write correct programs?

I like Julia, the language and the tech. I really hope this hostile attitude towards criticism and growth fades eventually, because I'd like to be able to use and trust it at some point.

[0] https://news.ycombinator.com/item?id=49570973

  1. random.choices(['a','b','c'], weights=[-1,5,1], k=10000)
     Negative weight on 'a' silently shifts

  2. random.choices(['a','b','c'], cum_weights=[5,2,7], k=10000)
     Non-monotone cum_weights makes 'b' unselectable.

  3. statistics.fmean([1,2,3], weights=[-1,1,1])
     “Mean” of three values in [1,3] returns 4 — outside the convex hull.

The LLM fabricated a fake/idiosyncratic definition of weighted mean in order to claim it's a bug, because it was instructed to come up with bugs.

  4. json.dumps({1: 'a', '1': 'b'})
     Produces invalid JSON with duplicate keys; round-trip silently drops one entry.

  5. urlparse('http://example.com/?').geturl()
     Trailing ? (empty query) and # (empty fragment) silently stripped

So all of these "eye watering correctness issues" so far seem to be either (1) straight-up correct, or (2) doing things Python explicitly tell you not to do. Same deal with the Numpy "bugs", AFAICT, as I touched on in my previous comment.

In fact, I would venture that we all know those Python bugs are fake, but (unfortunately) the Julia ones aren't. Because the Julia bugs mentioned by Yuri were reported to the Julia bug tracker, and eventually fixed. Whereas if you really thought these are real bugs in Python, then (IMO) you should be reporting them to the Python tracker, not getting mad at me for doubting them.

Moreover, even if they were real bugs in Python (which they aren't), bugs existing in Python still wouldn't change the situation for Julia. The Discourse user who posted it still admitted that they didn't even take the time to verify them.

Surely you must realize how bad it makes Julia look, when its users fling LLM slop to attack Python in response to Julia's issues being brought up? A constructive project should instead talk about what's been done and planned to improve Julia's situation, not tell lies to drag Python down. I liked Julia when I tried it! The JIT plus multiple dispatch is so unique. But this so isn't the way.

Which, apparently, sat in the standard library for almost four years after it was introduced before it was fixed. [1]

Even if there was some merit to your argument, I would still find the attitude disqualifying. While it may be technically true that all programming languages have bugs, software and software communities for numerical computing should take responsibility and treat those bugs seriously, not downplay them by pointing to the fact that other software probably has bugs too.

FWIW I don't have a horse in this race. I've used both before, and I currently make money using neither. I liked Julia. I find that article concerning. And I find the attempts by Julia users to discredit that article in this thread, without addressing its substance, even more concerning and disappointing.

Well, bugs can be fixed. But ideally not by a culture that dismisses them as inevitable or unimportant.

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

[1] https://github.com/JuliaLang/julia/blob/26f2333686ce90331548...

> I think there’s also a mindset split, some people just like to have things more strict and avoid bugs by having their compiler proof everything, and others like more freedom and are fine with occasional mishaps.

> Just for the fun of it, I put claude on Python, and it also found some eye watering correctness issues (to be fair, I haven’t taken the time to verify and judge them, but it seems like that’s a similar situation for the Julia version)

I say "self-soothe" because if the intention were to better understand the correctness situation, presumably one would at least want to evaluate the output before declaring it "eye watering". And then even if the output was real, it would be better to report it to the affected Python projects instead of using it as an excuse to downplay problems in Julia.

But most of the supposed "bugs" seem like totally fine/reasonable behaviors to me, often for clearly nonsensical inputs. Seriously, `np.array([1, 'two', 3.0])`? That's not a bug, the behavior is clearly documented on numpy.org, but really no matter what Python does with that, it's not comparable to issues like `prod([Int8(100), Int8(100)]) != prod((Int8(100), Int8(100)))` from that post about Julia. Which again the linked Discourse post downplays as "freedom and occasional mishaps".

I find it telling that the highest praise for LLMs comes from people using it for something where they admittedly have very little domain knowledge. Domain experts usually mention major caveats. I've been testing them on subjects where I already understand the problem well, and I've yet to see any outputs that would make me trust them on things I don't already know.

https://en.wikipedia.org/wiki/Gell-Mann_Amnesia

https://en.wiktionary.org/wiki/confidence_trick

I suppose everything is okay as long as it's done inside of a building.

We don't know where exactly viruses came from, but one of the leading theories is actually that they are the descendants of bacteria which outcompeted other bacteria. When a parasitic bacterium sheds more and more of its own metabolic capabilities, because it's more efficient to steal those abilities from its host cell, it evolves in a way that looks more and more like a virus.

"More evolved" or "more advanced" in this case doesn't mean "bigger" or "more complex". You can say viruses are equally evolved as bacteria, meaning they've spent equally long being optimized for their ecological niche.

I just checked my `~/.local/share/libvirt/`. It doesn't do this for me, and I don't think it ever has.

I do remember having to set this up at some point. Looks like this is it:

https://unix.stackexchange.com/questions/799034/whats-the-di...

There are some limits around network ports in User Sessions, but it should suffice for anything you'd use Vagrant for.

> Creating a new VM? You're forced to pick an OS by typing the name of your OS into a search box which is tedious and doesnt give you an option for generic x86 machine.

...There is though? It's in the dropdown under "Generic or unknown OS. Usage is not recommended (generic)". Here it is in the code if you don't believe me:

https://github.com/virt-manager/virt-manager/blob/c3df2ba/vi...

And a random tutorial which makes use of it:

https://cyberlab.pacific.edu/courses/comp178/resources/virtu...