Shouldn’t errors be in the bottom of the output if you don’t want to scroll?

Switch to Kagi

Why? Not making the connection.

For Google, nothing is too dumb! Not even joking. They’re absolute trash nowadays at almost everything they do, even for normal / startup standards.

deleted by creator

What’s interesting to me is that IMO Rust is fun because of legit, pragmatic benefits. E.g. I don’t think debugging runtime errors is fun. Seeing all the compile time stuff Rust catches is fun for me. My employer doesn’t care what’s fun, but they do care about me shipping features instead of bugs, so we’re kind of on the same page.

This should 100% be illegal.

Either way, it’s pretty useful to communicate this to everyone else.

Context?

What community/ instance is that in?

deleted by creator

Actually, buying a new electric car is better for the environment than keeping your current car.

https://arstechnica.com/cars/2022/04/new-ev-vs-old-beater-which-is-better-for-the-environment/

Not when the planet and future generations are at stake.

Aside from even that, I rolled down my window this morning on my way to work to enjoy some fresh air and I got a big blast of toxic exhaust fumes. It’s literally poisoning the air around us. IMO people’s right to not breathe toxic fumes is more important than someone else’s right to drive a gas car just because they like it.

We aren’t there yet in terms of cost or electric charger availability, but once we are we should 100% ban gas cars.

Yeah, at this point I’m talking about Rust’s fit as a general purpose language and being good at refactoring. I think Rust is great for both of those and that it isn’t very subjective.

But regarding Rust for game dev, I have no idea. I have never done game dev, so it’s definitely possible it isn’t good for it for some reason.

I’m also saying scripting languages will break very easily when you refactor things. I didn’t think that was that controversial…

That’s a sad attitude to have. Rust is really great, but it does have a learning curve. If you do want to give it a shot, just reach out online and there are many people who can help with suggestions.

Ive used Rust professionally for six years now and have done many quick hacks. It is really easy to do. Basically just don’t use references / clone everything to avoid lifetime and ownership issues, and use unwrap everywhere to avoid proper error handling. It’s really that easy almost all the time.

The nice thing about that is once you’re done with the prototype, just remove the unwraps and you can optimize stuff by removing the clones.

The borrow checker is useful for a lot more than memory safety. This is something I have been repeating for years, but unfortunately people new to the language don’t understand it yet.

E.g. Rust is the only mainstream language where it isn’t possible to read from a file handle after it’s been closed. There are numerous other common benefits of it that apply to general purpose programming, like not being able to mutate a collection while you’re iterating over it.

It’s a very common practice in Rust to enforce domain invariants using Rust’s ownership rules, and those things cannot be enforced at compile time in other languages that don’t have ownership.

The borrow checker is also usually pretty easy to get around with just a bit of experience in Rust.

What I’m curious about - this function was already const, so for stuff like this, I’d think there’s basically a 100% chance the compiler would optimize this too, just implicitly.

AFAIK this new feature is just for times when it isn’t an optimization, but more your own domain invariants. E.g. assertions.

But I could be wrong. I wonder if this can be used for actual optimizations in some places that the compiler couldn’t figure out by itself.

What I said isn’t even what I’d consider subjective. There is a very clear, logical, scientific reason for that. Not sure what you think I’m wrong about.

Can you give an example of why you think Rust just makes it needlessly hard to refactor?

Rust is probably great for systems that don’t have a lot of changing requirements, but fast iteration and big changes probably aren’t its strong suit.

I agreed up until this. Fearless refactoring is a huge benefit of Rust. If the type system of another language allows the refactoring more easily without as many compilation failures, it will probably surface more runtime bugs.