HNHacker News
TopNewBestAskShowJobs

Intralexical

1,384 karma · joined December 24, 2022

submissionscomments
Intralexical··on Mark Zuckerberg: "Cambridge Analytica" (2017)
> 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.

Intralexical··on Mark Zuckerberg: "Cambridge Analytica" (2017)
Data is what neurotic people hide behind because they can't stand not being in control. Often to disastrous results.

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

Intralexical··on How an MIT research project became the Julia programming language
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.
Intralexical··on How an MIT research project became the Julia programming language
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.

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

Intralexical··on How an MIT research project became the Julia programming language
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.

Intralexical··on How an MIT research project became the Julia programming language
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.

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

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

Intralexical··on How an MIT research project became the Julia programming language
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".

Intralexical··on Anger over Data Centers Is Fueling a New Political Movementtca
It's not the exterior facade that people have an issue with.
Intralexical··on As AI eats the web, the internet’s collective memory is disappearing
> 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.

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

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

Intralexical··on As AI eats the web, the internet’s collective memory is disappearing
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.
Intralexical··on The Water Footprint of AI
That seems closer to addiction symptoms than joy.
Intralexical··on The Water Footprint of AI
The systems used for LLMs are several times more power-hungry than traditional servers. Like, 50-100kW per rack of B200s.
Intralexical··on The Water Footprint of AI
...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?
Intralexical··on The Water Footprint of AI
I'd be willing to bet almonds bring more joy to more people in a single year than AI data centres ever will.
Intralexical··on The Water Footprint of AI
I agree energy use is the more concerning issue, while water has probably caught more press because it's more tangible. But there's no getting around thermodynamics. That "wasted energy" is dissipated using large amounts of water.
Intralexical··on The Water Footprint of AI
The Californian almond industry has had over 100 years to develop. The AI data centre industry has had 4.
Intralexical··on Anger over Data Centers Is Fueling a New Political Movementtca
What a strange fantasy.

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

Intralexical··on Radical Study Suggests Life on Earth Arose Twice
Nope. It would suggest that new viruses could not spontaneously appear from abiotic matter, because they'd be outcompeted by existing viruses. Which may well be true.

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.

Intralexical··on Protobuf-py: Protobuf for Python, without compromises
This is concerning to hear. What do Protobufs accomplish, that requires them to be a constantly moving target?
Intralexical··on Ditching Vagrant: VMs with KVM and Virsh on Debian
> Virt manager drives me crazy because it hides the VM files in its own directory with permissions that aren't yours forcing you to use sudo to manually manage your own fucking vm files.

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

Intralexical··on Rotman Lens
> By... plugging and unplugging antenna elements?

No. The antenna elements are always plugged in the same way. By sampling/introducing the signal at a different physical position on the lens (or multiple positions simultaneously), you create different physical distances and phase shifts for each element, and therefore a different beam direction.

...Apropos of nothing, this reminds me that a long ago, I played on a Minecraft server where one of the boys made a piston display with controlled by a pressure plate array. I was shocked by how he managed to transmit the signal with a simple wire. Maybe it was a similar idea, using the propagation distance...

Intralexical··on Januscape: Guest-to-Host Escape in KVM/x86 [CVE-2026-53359]
Would capabilities enable granting access to specific programs and not just users? Like using AppArmor profiles. So QEMU, gVisor, Docker etc. can still use KVM for unprivileged users, but malware wouldn't be able to access it directly.
Intralexical··on Januscape: Guest-to-Host Escape in KVM/x86 [CVE-2026-53359]
Because if /dev/kvm isn't accessible to unprivileged users, then people will start using `sudo` to run anything involving virtualization, which would be much worse for security overall.
Intralexical··on Rotman Lens
If you monitored all the inputs simultaneously instead of switching, you could make a low-tech radio-wavelength camera. Presumably with less SNR per "pixel" than you'd get from monitoring just one input though.
Intralexical··on Rotman Lens
It does do directional steering. No active array components or physical movement are needed.

> If the output ports are connected to individual antennas in an antenna array, this allows shaping the beam in different directions by switching which input port the signal is sent to.

From TFA.

Presumably the geometrical shape of the lens is dictated by solving for useful phase shifts for different input points. Otherwise you could just use a bunch of delay lines.

I wonder if anybody's ever designed a 3D version of this. You might get a wider range of inputs, or more precise steering, by shaping the delays on a non-Euclidean (curved) surface (like a sphere or a saddle).

Intralexical··on IBM debuts sub-1 nanometer chip technology
Plus heat dissipation is a limiting factor, which scales with area.
Intralexical··on MicroUI – A tiny, portable, immediate-mode UI library written in ANSI C
> Literally none of the examples of large companies using it in the comment I replied to are game companies or using it for game debug menus.

Literally all of them are using it as part of non-user-facing debug tools for 3D graphics:

https://github.com/ocornut/imgui/wiki/Software-using-dear-im...

Meta as part of their VR/gaming division, Google in their VR division and 3D rendering engine, Ikea in a 3D material editor, and Intel in a 3D SDK.

And again, the intended use is immediately explained on the project repo no matter what the comment you were replying to said.

Intralexical··on MicroUI – A tiny, portable, immediate-mode UI library written in ANSI C
Looks like the rendering functions used in the demo are doing antialiasing without font hinting?
Intralexical··on MicroUI – A tiny, portable, immediate-mode UI library written in ANSI C
Additionally the developer of this library is active in the indie game scene, so "twelfth member of the team" is hardly a relevant issue.

I find it so unfortunate how many of the criticisms raised here are mooted by simply glancing at the README.

There's an interesting conversation that could be had about the needs and limitations for debug UIs, and how to balance that with minimal code. (E.G. Would feeding this library's text-and-rectangles output into an accessible renderer be enough?) But blanket rejections and reflexive judgement aren't helpful.

Intralexical··on MicroUI – A tiny, portable, immediate-mode UI library written in ANSI C
> Any project that uses Dear Imgui for end-user applications has already made a bad design choice.

Note that any project using Dear ImGui will presumably have read the README for it, the second paragraph of which starts:

> Dear ImGui is designed to enable fast iterations and to empower programmers to create content creation tools and visualization / debug tools (as opposed to UI for the average end-user).

Page 1 of 19Next →