> And yes, data has entered politics at a level it could not before computing power and data collection and our understanding of human manipulation didn't reach those levels. It has understood you only need 50%+1 of the votes and efforts to get 50%+2 are a waste and less efficient.
>
> So politicians, especially in weaker democracies characterized by winner-takes-all mechanics, are incentivized to be divisive, not representing the majority of the citizens.
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.
Yeah, this is crazy. It's literally a cliché for most programming languages that it's never the compiler's fault. Granted a lot of the Julia bugs seem to be in the standard/core libraries, but still. Even if the bugs are overstated, this cavalier attitude towards correctness in a numerical language is super disconcerting to me.
Corner cases like `prod([Int8(100), Int8(100)]) != prod((Int8(100), Int8(100)))`? Both returned integers, but the left was 10000 while the right was 16. [0]
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.
That reads to me more like a long-winded example of a Julia user refusing to take correctness issues seriously, and instead using an LLM to self-soothe by deflecting onto other projects:
> 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".
You can not be serious in suggesting these aren’t straight up Python correctness bugs. Exactly the same kind that Yuri brought up as damning evidence of Julia unseriousness, but for Python with easily 25x the user base.
Most (all?) aren't bugs by any stretch of the imagination, no. Let's go over the first 5.
1. random.choices(['a','b','c'], weights=[-1,5,1], k=10000)
Negative weight on 'a' silently shifts
Python docs say, "Weights are assumed to be non-negative and finite." Garbage in, garbage out.
2. random.choices(['a','b','c'], cum_weights=[5,2,7], k=10000)
Non-monotone cum_weights makes 'b' unselectable.
...Those weights aren't cumulative, which the docs say they should be. Again, garbage in, garbage out.
3. statistics.fmean([1,2,3], weights=[-1,1,1])
“Mean” of three values in [1,3] returns 4 — outside the convex hull.
This is just straight-up mathematically correct behavior. It preserves linearity. It fits the commonly accepted definition of weighted mean as `(w1*x1+w2*x2...)/(w1+w2...)`.
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.
Again, documented behavior/GIGO. Docs say, "loads(dumps(x)) != x if x has non-string keys."
This is literally just what geturl() is supposed to do. It's the whole point. Docs say "empty parameters, queries, and fragment identifiers will be removed". The LLM is claiming that geturl()'s primary intended purpose is a bug.
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.
python has plenty of bugs like these too. is this example also "LLM slop" ? I think it's frankly delusional to somehow believe that these issues are unique to Julia.
> But most of the supposed "bugs" seem like totally fine/reasonable behaviors to me
exactly. and the same is true for many of the bugs that have been presented as indictments of Julia. but when the same is said of those, the community is called "defensive." so it's a lose-lose.
There is no equivalence here. The Julia bugs were real. They were reported, accepted, and fixed. The Python bugs you linked to are fake LLM slop, see my other comment right above/below this one. [0] If anyone really believes the Python bugs are real, they should report it to Python, not use it to deflect from Julia's issues.
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.
> This was my first exposure to any kind of outdoor plumbing, I'd never touched PVC before.
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.
When I apply LLMs to domains where I'm already an expert, I find it particularly lacking when I want it to do deep, difficult, novel work that requires precision. On the surface, the output looks pretty amazing at first. But when I turn a critical eye to every detail, I end up finding a lot of flawed "thinking", and the lengthy process of fully understanding what it generated and cleaning it up to my standards makes me question the entire value proposition. However, I find it does a great job being a low-level automaton sort of assistant.
For instance, in the domain of software engineering: I would not trust it to implement a major architectural change, or a groundbreaking, complex new feature. I would trust it more (but not completely) on something like a refactoring that may touch thousands of lines in a fairly mechanistic way, but that was a little too-complicated for simpler tools likes regexes. While that's kind of a nifty use, I think it's fair to say that non-LLM software purpose-built for such tasks can probably do the same thing more effectively for less real cost (meaning the currently-subsidized real cost of all the training and inference power burn, etc)
That's a good point - I've heard people make the same one whenever LLMs are brought up. I hope someday you're able to get more value from them.
Anyway, my pool's looking great and I gained some new skills. I probably could have gotten there with books and YouTube alone, but having another tool at my disposal made me a bit more confident.
That's the entire problem. The main thing LLMs gave you was confidence, and the thing to understand is that the confidence an LLM gives you is often utterly false and baseless.
Why were you not confident with literal how to videos and documentation, but became confident when a chatbot generated probable text?
I remember this was brought up about a month or so on HN, in the context of describing how one person's experience using LLMs can be so vastly different than another person's:
"LLMs seem good at things you are not good at."
So, if you've never touched PVC before, LLM sounds plausibly competent--it may actually be or it may not be, but you'll walk away from it thinking you learned something. If you are a professional plumber and ask an LLM the same thing, the output will more look flawed and possibly dangerous.
Same for software writing: If you're not a good software developer, you probably think an LLM is great and writes much better code faster than a human developer can. But if you are a good software developer, LLM output is slop and requires huge rework to be passable.
> So, if you've never touched PVC before, LLM sounds plausibly competent
well to be fair, it's sounds about as competent as your average homedepot employee. He's wasn't doing something super complicated, cutting and gluing PVC for an above ground pool is very common and doesn't require a plumber. I used some youtube videos to fix my dishwasher, i didn't need a professional service agent from the manufacturer I just needed some pointers.
as for software writing, for standard everyday enterprise app work which is typically just CRUD and moving data around it works fine. That kind of software does not need to be a highly tuned work of art to meet the requirements.
LLMs seem good at things you are not good at... primarily because you lack the skill to actually judge the goodness of their work, and they present their work confidently with an air of authority.
I am not a mechanic by trade, but I know nearly everything there is to know about working on an ICE car. I did paint cars professionally for a bit.
LLMs are absolutely full of garbage advice, when I try to use it for troubleshooting. However, people who don't know anything about cars are telling me it helped them fix issues. I am assuming their issues were maybe surface level and something I would just know without even looking at any manuals, because when I use it for complex problems it just doesn't work for me.
if it helped them fix issues then it helped them fix issues. Good for them. Maybe their problems didn't rise to your bar but at least they were able to get it solved. That's very useful and empowering to people without the direct knowledge and experience themselves.
Well, I guess another plausible explanation is that usually "domain experts" are people that get paid for their expertise, and have a vested interest in saying that LLMs cannot replicate what they want people to pay them for.
I've noticed these big tech companies use the word "democratize" when they do something that looks more like commoditizing. Flooding a market with supply consolidates their own power, by suppressing other economic actors' bargaining power and making quality controls uncompetitive.
I’m familiar with datacentres, I’ve helped build a few, so I kept up with the new systems, they still aren’t that lossy last time I checked their specs.. however obviously I don’t have access to all the designs popping up in this mad rush.
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.
reply