NIckGeek

I'm honestly shocked how dense the claudisms are here. Even the project description reads as Opus 5 vomit.

You can make a wrapper type that abstracts the offset lookup logic with a safe interface. If it's a transparent struct then rust will compile it away into nothing but you still get the abstraction in your code.

You really don't notice it while you're using a folding phone.

The fundamental issue imo is that LLMs are trained to make believable outputs. They can be complete horseshit, but because they look plausible they get treated like quality.

I swear that the intensity and time I've had to take with code reviews has gone up because LLMs are so good at making flawed code look good. I assume the same goes for everything else we use LLMs for.

I don't think the issue is using declarative UI frameworks, it's that the rendering engines these frameworks are outputting to are not taking accessibility into account.

I feel like ARM wins over even a mobile x86 chip here, right? Like a base Mac Mini sounds ideal.

I'm a big fan of AsciiMath and have been supporting it in my note taking program (MicroPad) since ~2016.

It was the key for me being able to write maths in a classroom/lecture theatre at the same speed (or faster) than those doing it by hand.

Couldn't you just pass a reference to your value (i.e. `&T`)? If you absolutely _need_ ownership the function you call could return back the owned value or you could use one of the mechanisms for shared ownership like `Rc<T>`. In a GC'd functional language, you're effectively getting the latter (although usually a different form of GC instead of reference counting)

> but in practice fails, because of pervasive use of `unsafe`.

Yes, in `unsafe` code typically dynamic checks or careful manual review is needed. However, most code is not `unsafe` and `unsafe` code is wrapped in safe APIs.

I'm aware C already has a runtime, this adds to it.

Fil-C is impressive and neat, but it does add a runtime to enforce memory safety which has a (in most cases acceptable) cost. That's a reasonable strategy, Java and many other langs took this approach. In research, languages like Dala are applying this approach to safe concurrency.

Rust attempts to enforce its guarantees statically which has the advantage of no runtime overhead but the disadvantage of no runtime knowledge.

fwiw in modern-Java they have data classes:

  record Foo(String theImplementationAndStyleOfDataClasses) {}

The string is final. While sadly there is no elvis operator, the Optional type helps:

  evlis.map(e->e.operator).map(e->e.chaining)

I still strongly dislike working in Java but Java 23 is a long way ahead of the Java 6 I first learnt Java with.

You typically have to stop in LA, Singapore, or the UAE. The NZ -> Europe flights are brutal, and the trip back is typically even longer.

About 70% of the programming I'm doing right now is in my own language. But like, my full time work is programming language research so I accept that's an uncommon use-case.

I just tried Zed and it is definitely really pleasant to use. I'd need at least a Java LSP to use it for real (and preferably general LSP support so I can code in my own programming languages with it) but I can see a lot of promise. If they ship a Linux release so I could use it on my desktop too they could win me over from Sublime Text/IntelliJ.