Intralexical

Alpine Linux is not statically linked. It provides a musl environment which makes it easy to statically link your own builds, but software shipped as part of the distro is usually dynamically linked.

  $ docker run -it --rm alpine

  / # apk add cmd:ldd
  / # ldd $(which ash)
          /lib/ld-musl-x86_64.so.1 (0x7f4cb4d1d000)
          libc.musl-x86_64.so.1 => /lib/ld-musl-x86_64.so.1 (0x7f4cb4d1d000)

  / # apk add cmd:python3
  / # ldd $(which python3)
          /lib/ld-musl-x86_64.so.1 (0x7fd630cab000)
          libpython3.12.so.1.0 => /usr/lib/libpython3.12.so.1.0 (0x7fd63069a000)
          libc.musl-x86_64.so.1 => /lib/ld-musl-x86_64.so.1 (0x7fd630cab000)

> 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.

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."

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

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.

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".

It's not the exterior facade that people have an issue with.

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.

That seems closer to addiction symptoms than joy.

The systems used for LLMs are several times more power-hungry than traditional servers. Like, 50-100kW per rack of B200s.

...I don't think you can declare that something is a non-issue without having spent at least some resources to determine whether it is?

I'd be willing to bet almonds bring more joy to more people in a single year than AI data centres ever will.