Exactly - purely "data driven" decisions are how we end up with ads really close to (or overlapping with) some button you want to press, because the data says that increase click-through rate! But it's actually a user-hostile feature that everyone hates.

The reason that feature gets implemented is not because the devs think users will like it ... they know users don't want it, but it drives revenue and pays salaries.

If we were perfectly rational, then yeah, more data should never lead to worse decisions. However, it's easy to fall into the trap where being data-driven makes you only work on those things that you know how to measure.

Or worse, it makes you go look for data backing up the assumptions you already made.

It's easier to not care about users if they are just numbers and you can tell yourself to ignore what they actually say.

I've never really had the urge to use GC in Rust, but if I were to speculate, I'd say easier cyclic references would be one benefit. And depending on the specific GC implementation, you can probably get around many of Rust's ownership rules because Gc<T> pointers are usually `Copy`, so you can pass things around everywhere and not think about references/ownership as much.

Okay I could see that - like implementing linked lists would be easier yeah?

I just feel like not having GC is sort of a deliberate, core design choice for the language. Having strict ownership rules and being forced to think about references feels like a feature not a bug you know? Adding GC feels analogous to the "++" in C++ to me.

Not that I have anything against the efforts people are putting into it though - I'm genuinely curious about what it lets me do better/faster within rust.

GC is a similar but different set of strict ownership rules (and its own versions of being forced to think about reference invariants). There's an inherently interesting Venn Diagram overlap between Rust borrow mechanics and GC, they aren't entirely separate worlds. They are more like related worlds with slightly different trade-offs. (Similarly there's C# and .NET actively exploring GC-safe relatives of Rust's borrow mechanics in Memory<T>/Span<T> space right now, to great effect.)

In terms of practical, yeah a doubly linked list (or trees with bidirectional pointers to both parent and children, etc) is especially easier to implement in a GC environment than with Rust borrow checking alone. You can do it without a GC, but a GC can be a helpful intermediary.

I agree completely; I think choosing Rust and then adding a GC is a weird design choice. If I was in a situation where I really, truly needed GC for my memory management, I wouldn't use Rust.

I think you're misunderstanding - most people's beef with AI art isn't that it "isn't made by experts", it's that

1) it's made from copyrighted works, and the original authors receive no credit; 2) it is (typically) low-effort; 3) there are numerous negative environmental effects of the AI industry in general; 4) there are numerous negative social effects of AI in general, and more specifically AI generated imagery is used a lot for spreading misinformation; 5) there are numerous negative economic effects of AI, and specifically with art, it means real human artists are being replaced by AI slop, which is of significantly lower quality than the equivalent human output. Also, instead of supporting multiple different artists, you're siphoning your money to a few billion dollar companies (this is terrible for the economy)

As a side note, if you have a business which truly cannot afford to pay any artists, there are a lot of cheaper, (sometimes free!) pre-paid art bundles that are much less morally dubious than AI. Plus, then you're not siphoning all of your cash to tech oligarchs.

I think there's a difference between

"Hey boss, this isn't practical with the requirements you've given. We need to revise them to continue, here are my suggestions"

and

"Task completed! Btw, I ignored all of the constraints because I didn't like them."

Humans do the former quite often. When we do the latter, our employment tends not to last very long. I've only seen AIs choose the latter option.

Or the "find all references" feature almost every code editor has...

Increasing skin temperature is known to induce sleep (can't find a source currently, sorry). Something about your skin being warmer allowing your body to cool more effectively, I think.

So a hot shower before bed is actually great for sleep, because you get the increased skin temp, relaxed muscles from the warm water, and general relaxation because showers are (for many people) relaxing.

That's funny, I find it much easier to fall asleep in a cold environment. Then again, I also like to use a heavy blanket, so maybe it's the weight more than the cold that's helping me.

I think that's also consistent with the idea behind a hot shower. The shower doesn't help by increasing your body temperature, in fact it does the opposite. The hot shower induces the body to try to cool down, so near-skin blood vessels swell, and that dumps heat into the cold air, which reduces your core temperature, and a reduced core temperature helps you fall asleep.

I think where I read about this was Why We Sleep from Matthew Walker. But he suggests just washing your face with warm water, as opposed to a shower.

Hot shower heats up your body, which causes it to direct blood away from the core to cool it down so it doesn't overheat. Dropping core temp triggers the brain to ramp up melatonin production. Or so I heard.

Conversely, when the temperature drops, your body directs blood away from your hands and legs because core has higher priority for survival

I think that's only because electricity is the bottleneck, though. If it was no longer the bottleneck, crypto miners would expand rapidly with more hardware, mining difficulty would increase, and eventually the bottleneck is storage space for all your GPUs, if not the GPUs themselves.

I dunno, I've worked on some pretty big projects that have used lots of coroutines, and it's pretty easy to avoid all of the footguns.

I'm not advocating for the ubiquitous use of coroutines (there's a time and place), but they're like anything else: if you don't know what you're doing, you'll misuse them and cause problems. If you RTFM and understand how they work, you won't have any issues.

They're a crutch for people who don't know what they're doing, so of course they invite a whole host of problems that are harder to solve than doing it right in the first place.

If you strictly require people to know exactly what they're doing and always RTFM and perfectly understand how everything works, then they already know well enough to avoid coroutines and SendMessage and UnityEvents and other footguns in the first place.

It's much easier and more efficient to avoid all of the footguns when you simply don't use any of the footguns.

I'm curious about Hashibashi as well. I've seen lots of Japanese people doing it, and now I'm worried I look like a total poser from copying them.

I think many people know how to google "what is my IP" and send that to a friend, but don't necessarily know what a port is.

NAT randomization, I don't know. Depends on your setup, I guess.