Gary Trakhman

That's the one

I was just joking, I like labeled args. It's kind of weird with currying in ocaml iirc.

That's why rust gives you more string types for the positional args

This feels like trying to beat HFT firms as a solo investor

You're absolutely right. Here's why

- standard intuition, but..
- a few good points

would you like to spend more tokens on me elaborating?

I will parse CSVs on hard mode

And algebraic effects now, which generalize exceptions

Doing this for 14 years without LLMs might have something to do with using LLMs effectively, but I can't tell you how much of a timesaver it is, either.

It's possibly just a crutch, but every technology is kind of like that.

Yeah, I think someone with situational awareness could have presented it as a proof-of-concept, and asked if there's any interest in turning it into a real contribution and what that might take. A PR presented as a real contribution puts maintainers on the defensive and weaponizes their politeness.

What a colossal waste of time for everyone involved. I use LLMs for code generation, too, but if I get a plausible implementation out of it in a day, I expect to take about 4x as long reviewing it, refactoring it, and making it more robust, and then I still don't entirely trust it.

The committer 'keeping AI on the straight and narrow' somehow resulted in headers crediting someone else. Pretty funny.

That author seems a bit biased against Rust.

Here's more about the rewrite blog.cloudflare.com/20-percent-i...

This is likely a lot better than my combination of thiserror nested enums for lib-code, wrappers around anyhow for bubbling stuff up to the edges, and From<> impls to convert from one to the other. I'll have to try it out.

People are just bad about understanding and weighing the abstract tail risks from something like that. I don't think making the code extra beautiful and organized is a good use of time, but if I intend to work on something for a while, it's in my best interest to have few bugs and make changes easy

This is related to the only argument I have against(?) type-safety. It makes bad code more maintainable, too, and maybe even a bit more than what it does for good code.

This is timely b/c of all the unwraps everyone is having lately.

It's actually awesome, though.

If you follow that principle, you end up pushing input validation to the edges of the application, which I think is a sensible way to do a lot of things. I'm not sure I understand why this use-case needed to be different.

this is an interesting Result type I saw recently: docs.rs/async-nats/l...

docs.rs/async-nats/l...

The Ok side is another future with another Result type, and they both have the same Error type, which is weird. 2 awaits, and I think some variants can only happen in one or the other.

Yeah but lib authors shouldn't bucket them for you. Just give me all the info, and I'll decide.

But I wish there were an easier way to move parts of enums around.

It doesn't really matter if an outage still would have happened. If this was in there, maybe there's another unwrap in there that causes outages all by itself and we haven't hit it yet.

Re cloudflare/rust, from a Postel's Law perspective.

If I find an unwrap deep in a stack, I'm not going to be thinking about what everything upstream might send into this function and if the unwrap should change if I change one of those things. Why not write it robustly once and forget about it?

Also traits. Sometimes I miss ocaml functors in rust, but in ocaml I always missed all kinds of polymorphism. FCMs were too awkward to use regularly.

I worked in Ocaml for five years, and I had a lot of surface criticisms but mostly liked it and would again.

Rust can do most of the same stuff and is more productive on some key dimensions that have nothing to do with memory safety or the borrow checker. Libraries, community, and flexibility.

I haven't had to recalibrate my 3d printer bed mesh in a year until today. Is everything ok out there?

Worth asking when solving a problem: 'Why do we need to be smart about this?'

Maybe you do, maybe you don't.

Why call other build systems instead of rewrite them?

I've seen this in ocaml, eg starting up an async scheduler:

let () =
don't_wait_for (main ());
never_returns (Scheduler.go ())

never_returns is an uninhabited type.

I don't know how it works in rust.

I work there but I would like to know more about the camera

HM type inference is a set of defaults you work within, not something you have expend mental load to keep doing like tests.

I don't want to forget to handle an error case, I don't have to remember to write any test assertions that types give me for free.

Less smug, more fear.

Some people simply can't take a week off, but if you can, you're making more money that week.