legobmw99

> and nobody gets upset

[citation needed]

> Sounds like the author’s experience is strictly in Python

This is funny, matklad is probably one of the more well known Rust-and-zig contributors I regularly see posted on HN. They're the original author of rust-analyzer.

Here's the X that Ys the Z:

On the off chance this isn't just trolling: Getting linux to work on M-series Macs was a ton of work and basically none of it was done by the folks behind Omarchy. Exactly the point being made in this argument and elsewhere is that the funding would be better off going to the people who really did the hard parts of that work (e.g. Ashai developers among others)

Is "loving math for maths sake" just about knowing the answers? I think one can love math for exactly the process and understanding that a several-thousand-line uncommented Lean proof denies. If a deity rearranged the stars to spell out "The Riemann hypothesis is false" for a night, would that be intellectually sufficient?

I think this is a fine distinction to make, though it's worth noting that function arguments _can be_ colors as the author describes if the arguments have to come from a specific place, e.g. in languages where only `main` receives certain arguments relating to system functionality, or a capability framework where only the top-level function receives the capability token.

Better control over the async nature of the hardware is part of what makes GPU kernels efficient, but I'm not terribly sure the same thing would be the case on the other side of the PCIe bus.

But even before you get to out-of-order/speculative execution, I think most languages lack good (i.e. non-intrinsic-based) support for wide registers or anything SIMD related. I know C++ and Rust are both working on this

That seems fair, CUDA kernels and shader code do feel like they're at a similar level of abstraction over the hardware as C was to the PDP-11. But I do think there isn't really an equivalent for modern CPU ISAs

I’ve been a fan of this article for years, though it does often make me think that there really aren’t any true low level languages for our super scalar modern CPUs. Does anyone know of any?

I've started being driven mad by the number of times I've gotten a PR or proposed solution with 'sidecar' mentioned. First of all, it's often some hack to shove extra data into another place rather than actually rethink an existing data structure, and second of all, it is just not a word I almost ever heard in technical discussions pre-2026

The search on this website suggests it is indeed 3.6x more likely in the claude cluster

Huh, first time getting called a bot for me. I assume it’s the “Zed is an editor”, I was originally going to say something like “Zed is one of those editors like VScode that requires plugins for LSPs” and then shortened it

Zed is an editor that requires you to still write a tiny plugin basically telling it how to download and start the server, unlike something like emacs where this is just user config

I suspect both may be interesting to study more!

Several existing studies I’ve seen have done things like prompt the LLM to produce a poem in a certain poets style, then ask people to spot the fake in a collection of poems, which they aren’t great at. This is, I would argue, an extremely different context than what most of us are encountering AI text in, and the people sending me text aren’t prompting it stylistically like that.

On your second question, I definitely feel like I can tell the first time a coworker sends me AI text masquerading as their own thoughts, even if they had previously been opposed to such a thing. So it could be that familiarity is more important than my prior on whether they’d use AI? But interesting to think about either way

I partially think the difference is “can you tell something is the output of Claude without any real prompting”. People can absolutely use LLMs to generate text that I wouldn’t recognize, but people who don’t care and are producing slop with the major models set to default settings leave these incredibly obvious signatures behind

A democratic movement leading to increased regulation, even if you think such a thing would be misguided, is hardly a jihad…

Everybody is also different at different times in their life. Many people will develop at least one disability as they age, but even in temporary scenarios good design is accessible design. Consider opening a door when holding a heavy package by yourself. Good doorknobs, as mentioned in the article, make a world of difference

I think it is reasonable to have a higher (or at least, different) standard for Emacs core than for packages.

I also feel compelled to say that I personally think a lot of what has brought more energy into Emacs world recently is treesit and eglot becoming widely available in distributions, neither of which involved any AI

How pessimistic you are on this subject depends on how much you believe in domain transfer for these tools. No programming language sprung out of a vacuum, and it seems reasonable to think that a LLM sufficiently trained on all the C++, Haskell, and OCaml in the world could probably do a decent job at writing Rust, even if it had never seen it before, given the rust compiler as a tool and rust documentation as input

It certainly does worry me, though. As does the increasing amount of materials and manuals that seem to be written assuming the LLMs will be the (only? primary?) audience

It's hard to articulate why, but 35 layers of deterministic abstraction feels very different from 1 layer of nondeterministic one.

In particular, I think every developer has experienced the need to jump "down the stack" to debug or understand something (even if not all the way down). Certainly, I think any senior developer should be at least conversant in the first few levels below wherever they "live". But this seemingly ends up looking fundamentally different in the interaction mode of an LLM, because you'd just ask it to jump down the stack for you

I attended one of the better (read: top ~200) public high schools in the US, and you could graduate without even taking trigonometry

what’s wrong with make is largely that people are bad at writing makefiles. A tool like dune is able to enable cross compilation of a massive number of libraries out of the box, but make based projects that weren’t designed with it in mind almost always require someone to go through and separate out the mess of what needs to run on the host vs be built for the target, etc, etc

I think that’s not true; vanilla OCaml is already a competitor to Go, etc. OxCaml is explicitly an effort to compete more with Rust (the “Ox” in the name is to evoke “oxidizing” = rusting)

2026 is the year I stop reading blogs with headers like “The big unlock:”

It is rude to share AI written text for others to read. You are violating a social norm that has existed implicitly forever, that you invested at least as much effort in producing some text as you are asking me to put in to reading it

I could imagine something like the mastodon protocol but for git forges, where even though they are separate websites there would be no true boundary to discoverability/interaction

You’re not putting a municipal grocery store on the same block as an existing big box and saying “wow, savings!”

Food deserts exist in NYC, and many New Yorkers buy staples at corner stores that charge significantly more than a standard grocery store. Your second paragraph implies that this policy is due to some dislike of existing grocery stores, but that assumes these communities are actually being currently served by grocers at all

Seems like its p3125r0

I am a recent 5070ti purchaser so I'm also feeling lucky, though if they exit the gaming market entirely I suspect the drivers will all go to crap soon thereafter

The poor resale market for EVs just means that people who actually have some understanding of the battery lifespans can get very good deals on 1-2 year old cars

There are some interesting experiments going on in the OCaml world that involve what they call 'modes', essentially a second type system for how a value is used separate from what it is. One goal of modes is to solve this problem. It ends up looking a bit like opting-in to a Rust-style borrow-checker for the relevant functions

https://oxcaml.org/documentation/modes/intro/

Yeah, I think people find C appealing because it feels like you can fit the whole language in your head. I’ve yet to meet someone who has actually accomplished this in practice