I didn’t know you could do that! Oh wait, you can’t yet, I guess — looks like that would require some features still in prototype stage (Generic Constant Arguments MVP)?

score 1 · canonical

To my inexpert eye it looks like the subset search (the aforementioned unordered set trick) is quadratic to solve — but at least not exponential, and perhaps not a problem with a typical number of error types in the set? (I also see it’s arbitrarily limited to 26 error types, because the tuple generics have to be done explicitly.)

score 1 · canonical

Sure, that part makes sense. I guess since this doesn’t have any actual participation in the type system (unlike marker traits) I would have expected it to be a builtin attribute instead.

    // Tell the borrow checker that multiple references can be made to the
    // same place at the same time:
    #[access_kind(Shared)]
    unsafe impl<'a, T> BorrowPlace<&'a T> for RefHandle<'a, T> {

score 1 · canonical

This looks fantastic! Is there a downside?

I’m vaguely wondering if there could be an anyhow adapter so you could transform errors into this when you call existing code.

score 1 · canonical

In this proposal it looks like you put “feature flags” in the trait impl to tell the compiler the semantics?

        // Tell the borrow checker that multiple references can be made to the
        // same place at the same time:
        const ACCESS: AccessKind = AccessKind::Shared;

That seems…odd. Aren’t marker traits the normal way to communicate semantics? Are there other things like this in Rust that I haven’t noticed or is this a new technique?

score 1 · canonical

Sorry, I misread your earlier comment. In my reply when I said “mental model” I meant your mental model of the thing you’re trying to build, not of the tool.

The output of LLMs is defined as much as optimizing compilers is

It definitely is not. Compilers perform a very well defined transformation from input to behavior (not 100% defined, but as close as practical politics can get it). A compiler that “optimizes” by violating that definition is a broken compiler. (The 1% that’s undefined causes a lot of discussion, which takes place while everyone relies absolutely on the other 99% being correct.)

Whereas in most cases you can’t even tell if the output of an LLM did achieve desired behavior, because the input isn’t precise enough to determine the desired behavior in the first place. LLMs not backstopped by deterministic tools (compilers, test harnesses, proof engines, even just plain reliable arithmetic) in a loop have a hard time even making artifacts that are functional.

score 1 · canonical

I agree it’s a spectrum, but at some point just saying “it’s a spectrum” erases the interesting distinctions. The boundary of impreciseness that can’t be crossed by the “compiler” used to be limited to a fairly narrow range. Think of the possible abstracts of a paper in a PLT journal.

But with an LLM you can literally say nothing but “make a website for scheduling a kids’ soccer league” and it will do it. That is, even if I had a mental model, I didn’t tell the “compiler” what it was. Not only that, while it’s working the “compiler” can ask me what my mental model is, rather than just telling me the model I gave it is incomplete or inconsistent and stopping.

And where it really gets into a new category for me is that the output of the compiler isn’t even defined. You could just as well say “make a presentation for a soccer league” or “get the accounting in order for my soccer league” or “automatically answer questions about our soccer league”. The analogy just seems to completely fall apart at that point.

score 1 · canonical

I’d say the closer analogy to CNC is the compiler. The input to CNC is still a precise transformation of the intent of the designer. It does the work faster but it’s the same work. On the other hand, sometimes a human needs to precisely define the lower level, doing some manual filing because the cutting tool won’t fit in the space, or writing some assembly because the compiler doesn’t know how to do indirect threaded code.

As a craftsperson or client you may look at the result and miss the imperfections (the “hand”, it’s called) of the old way: the curvature is implausibly perfect, or the assembly is too clever to have been written by a human. But you can always see the human intent everywhere.

LLMs, on the other hand, take imprecise descriptions and turn them into precise output by making stuff up instead of waiting for the human to fill the gap. It’s the “imprecise description” part that’s really new. I don’t know of a very good analogy for that in any pre-existing tool.

score 1 · canonical

Yes, it is mind boggling. A while back, there was a heisenbug in a distributed lighting controller I designed. I connected two boards to SWD, connected the serial bus to my scope, told Claude how to get to the scope over TCP, and let it loose. After a few hours it handed me a reproducible case and I was able to fix my hardware mistake that was glitching the serial port.

score 1 · canonical

…one does not simply publish TypeScript packages to NPM. … TypeScript is a Microsoft product. … Nobody wants more Microsoft.

But…NPM is also a Microsoft product.

score 1 · canonical

Right. I suspect what the author meant was more like “you can’t write a useful Rust program without using lots of external packages”. A comment on the ecosystem, not the language.

Of course, you could also say “you can’t write a useful C++ program without reinventing a bunch of wheels insecurely”.

score 1 · canonical

The author seems to conflate “using programming language package managers” with “having uncontrolled dependencies”, which I don’t think is valid. I’m pretty sure you could configure a Rust build with controlled dependencies. (And a C++ build with uncontrolled ones.)

score 1 · canonical

deleted by creator

I’m sorry I used the imprecise term “relational algebra” to refer to the semantic model of SQL. My point is that the expression tree of a SQL statement is not made of loops, it’s made of table expressions (with join operations), column references, aggregates, filters, CTEs, etc. To oversimplify again, it’s mostly about set operations, not loops.

Of course in the query planner it gets turned into something executable, which will sometimes involve loops, but that’s not the model of the language itself. Python expressions get turned into bytecode so they can be executed, but you don’t write Python as a way of expressing bytecode.

To be concrete, the semantic expression tree of

select users.id, (select sum(posts.likes) from posts where posts.user_id = users.id) from users

isn’t

R=[]
for (u in users) {
  x=[]; for (p in posts) { if (p.user_id = u.id) x+=p.likes }
  R+=(u.id, sum(x))
}
return R

it’s more like

users
  .join(posts
    .filter(user_id=users.id)
    .groupby()
    .project(sum(likes) as sum))
  .project(users.id, posts.sum)

(Which in 2024 would be a much more natural way to write it in the first place, which is why I mentioned LINQ.)

In my experience writing and helping others to write SQL, if you write it thinking that you’re writing loops, it’s not as effective as if you write it thinking about set operations, especially as the queries get more complex. Not to mention that the error messages will actually make sense! To me this is like writing Rust thinking about structs, traits, borrows, etc. rather than thinking about assembly (99% of the time).

I’m not a SQL expert (though I have dug into the PG query planner on occasion) so maybe I’ve been doing this wrong, but it does seem to work.

score 3 · canonical

This goes wrong in the very first paragraph. That query does not, “read literally”, say to do two nested loops. SQL is a clunky way of writing an expression in relational algebra, not a clunky way of writing a series of operations. That’s what “declarative” is really trying to say. The Python equivalent would construct an expression tree from primitives, and then it would be fairly obvious that you could run an optimizing transform on it.

Using LINQ in C# as the example would have taken this post in a completely different direction.

score 7 · canonical

I guess we can’t put 100% of the blame on the LLM…humans came up with “cookies”, after all. Somehow it’s less charming when the computer does it.

I never in my life heard of “minting” a unique ID until Claude started saying it. (Of course, I am old…no one’s ever said “no cap” to me either and I’m pretty sure that’s real.)

score 1 · canonical

Having a shared vocabulary of concepts is essential for all programming, in no way limited to AI. (It’s the key feature of Domain Driven Design, for example.) But LLMs tend to invent new confusing names even more freely than humans, and the names tend to be worse! So anything you can do to rein in the naming conventions is helpful. I just use a glossary section of the design overview document.

score 1 · canonical

It should be a semicolon, the clauses are independent. A lot of people make this mistake, that doesn’t make it right. One of my teachers said “if you can replace it with a period, it should be a semicolon”, she was a great teacher. I hope these are clearly examples of what not to do, I know sometimes irony doesn’t come across on the internet.

score 2 · canonical

Kudos to them for starting from a consistent outcome goal (“access to the preferred form to make modifications”) and making an honest effort to apply it to AI models, as opposed to just coming up with some rationalization for using the words “open source”, as so many AI companies have been doing.

Nobody seems to be willing to explore the idea that there is actually no practical way large AI models can be open source, and we just need to come up with a different, accurate term. I would rather have that than confuse the meaning of the existing term by stretching it to fit.

score 3 · canonical

But is ChatGPT actually “rational” by whatever definition these esteemed folks were using? It seems more analogous to supercharged “dream logic” based on associations than “rationality” — but perhaps until now we just didn’t see that as a continuous spectrum. (See other comment.)

score 3 · canonical