Kogasa

Thinking has nothing to do with it. The positive context in which the bot was trained made it unlikely for a sentence describing a likely negative reaction to be output.

People on Lemmy are absolutely rabid about “AI” they can’t help attacking people who don’t even disagree with them.

Honestly this is the first I’ve heard of groff, but I’d be surprised if it’s not easy to transpile a Markdown document into the format. Have written only Markdown-based docs for a decade

A placeholder isn’t what they’re working on either. It’s a placeholder for something someone else is working on but hasn’t completed yet.

It was a placeholder texture that was always intended to be replaced by actual art made by a human. It was overlooked accidentally and promptly replaced. So no, it isn’t a very different thing. It was never supposed to be part of the game or even a significant part of its development.

A stance that is perfectly relatable in 2025, but not as much when Expedition 33 was in early development.

Why not? If the tools weren’t available, they’d have used stock art or something super basic and crappy looking, which would’ve been just as good as a placeholder. But the tools were available.

In 2025 it makes sense for companies to have policies against using generative AI tools even for stuff like this because of the systemic effects of normalized use. But in 2022, it wouldn’t have been a thing. Nobody would have thought twice about it. Just a neat new thing that does the job.

The only takeaway is that the Indie Game Awards’ rule is overly restrictive. Woops, one of your contracted artists used a GenAI model to generate a music playlist to set the mood while he was working on your game, you’re disqualified and the fact that you didn’t come forward with this information immediately makes you a liar. Obviously absurd. If they’re going to take a strong anti-AI stance, it should be more realistic. At some point, maybe even already, every single competitor should be disqualified but isn’t aware or forthcoming about it, so what’s the rule actually doing except rewarding dishonesty?

“the truth” being that a few generated placeholder textures were accidentally left in and promptly replaced? crazy

Pure mathematicians often answer questions that really only other pure mathematicians care about, but occasionally their results or techniques have relevance in other fields, so universities will pay them to work on this stuff and publish papers. Usually part of the job is applying for grants to fund your research and teaching students.

cats just do that sometimes

Not quadratic in the length of the input. Assuming replace is linear this is also linear

Smarmy grifter who caused irreparable and immeasurable harm

If you mostly play Souls games, I have to lean towards E33 due to the real-time parry mechanic. Both games are amazing and you won’t regret playing either.

I’ve been using a reverse proxy on a Hetzner VPS pointing at my home plex server for years without issue. Maybe this only applies to people running the actual Plex software on a Hetzner VPS?

Content of the image is unrelated to this post FYI

Wayland support for multi-monitor configurations is better than X11. Whatever performance degradation you claim to experience is also a “you” thing, not a “Wayland” thing. There’s an underlying issue with your setup.

What I described isn’t necessarily functional. This is just a principle for ensuring objects represent clear and well-defined contracts. The idea is that to mutate something, you should own it; that means interfaces / public APIs, which can be called externally, should take immutable arguments. You can still mutate instance members internally because those are owned by the instance. If mutation is really necessary between two objects then it should be coordinated by an object owning them both.

That’s a footgun sure but at least you can avoid it once you’re aware of the problem.

I never write function signatures with mutable interfaces. It’s always IEnumerable, IReadOnlyCollection, or IReadOnlyList; otherwise, use a concrete type. The latter is typical for private/protected methods that are called with instance members of a concrete type rather than public interfaces. If you want to mutate an object, you should own it. Public methods are invoked with data not owned by the instance.

For example, a lot of extension methods in LINQ have a signature IEnumerable<T> --> IEnumerable<T>, and internally the first thing they do is call .ToList(). The interface makes minimal assumptions about the input data, then puts it into a concrete type you can manipulate efficiently. You can similarly define a method for IReadOnlyList and explicitly make it mutable via .ToList(), rather than use IList and check .IsReadOnly. Both ensure correctness but the former does it at the type level, at design time, instead of relying on runtime checks.

C# is old and full of oldness. But it’s also an excellent language that can be written beautifully if you know how. And there’s lots of great code to learn from in the open-source dotnet core runtime repo and related projects.

“Don’t mention the war”

Sounds like a skill issue. If that ruined the game for you, I dunno what to say. Might be a replicant?