We should be stopping it wherever we can. It doesn’t need to be one before another. Being conscious about where you can get more of it is helpful.

Water - we distill our water, and you can also use other types of filters which remove it. Absorbing through skin - we know we should be wary about what products use it now, so can do some research and be careful about touching stuff.

This is similar to global warming. The biggest issue is large corporations. That doesn’t mean consumers shouldn’t stop worrying about littering or driving gas cars until corporations stop.

I’d think any sane society, business, or institution would blacklist him / remove any certifications he has, sue him, and possibly other courses of legal action like fraud.

I get that there are lessons learned for new advances in technology and society, but companies like DuPont and 3M knew about this and hid it. Then when legislation comes out banning chemicals they use, they change basically one atom in the molecule to avoid the regulation and keep going. They aren’t honest mistakes.

Yeah, it absolutely astounds me that they polluted the entire world and poisoned everyone and everything within it, and then the people are footing the bill for trying to cleaning it up. And that’s only our drinking water, not all the plants and animals we eat all the time that have it in them in probably huge amounts. AFAIK there is no plan for that at all so our cells will still be swimming in them.

3M and others should be taken over by the government and turned into nonprofits where 100% of their profit goes to cleaning up the world.

Do we have any plan for how to avoid colliding with asteroids or other things while traveling so fast?

Why do potatoes need to be wrapped in plastic at all?

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.

deleted by creator

Hyper was the standard for Rust web servers way before it was used by curl for anything.

A lot of it is about moving problems from runtime to compile time. JS, for example, has most problems live in runtime.

Imagine you’re hiring an event planner for your wedding. It’s an important day, and you want it to go well and focus on the things that matter to you. Would you rather hire an even planner that barely interacts with you up until the wedding because they’re so “easy to work with”? Or one that gets a ton of info and meets with you to make sure they can get everything they need as early as possible?

Rust is like the latter. JS is like an even planner who is just lazy and says “we’ll cross that bridge when we come to it” all the time.

C++ is like a meth addict.

Ah, I see. You’re talking about object properties. I don’t see any issue with finding references to variables, but for properties, yeah.

deleted by creator

I didn’t say types. I said find references / go to definition / rename.

1. That isn’t what I said at all. Reread?
2. Find references / go to definition / rename has absolutely nothing to do with types.