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.
LaTeX spitting out an immaculate pdf with carefully calculated text distribution and vectorized fonts just to have it printed and scanned by the camera on a razr flip phone:
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.
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.
I can sorta see that. An exit code is an exit code. But exit codes, like words, have meanings. Sometimes that meaning is a boolean value, as is the case in e.g. GNU Coreutils conditions: https://www.gnu.org/software/coreutils/manual/coreutils.html#Conditions
Yes, it is used consistently in GNU Coreutils: https://www.gnu.org/software/coreutils/manual/coreutils.html#Conditions
false: do nothing, unsuccessfully (returns 1)
true: do nothing, successfully (returns 0)
test: check file types and compare values is documented as “returns a status of 0 (true) or 1 (false)”
What you’re saying is irrelevant. In the real world, when an exit code is a boolean, 0 is true.
Every time an exit code is a boolean, 0 is true. Shell scripting would be very annoying if this were inconsistent
Not quadratic in the length of the input. Assuming replace is linear this is also linear
Smarmy grifter who caused irreparable and immeasurable harm
Content of the image is unrelated to this post FYI
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.
I dunno if you’re joking, but yeah there’s IDE plugins that do this. GitHub Copilot grabs context from files in your edit history and you can tell it to edit, refactor, “fix” etc. selections. The more complex actions, the less likely to succeed, though.
“Don’t mention the war”
It’s a different situation, as a dev I’d happily bet my life on this assumption.
Dropping support for that stuff means breaking 95% of the websites people currently use. It’s a non-starter, it cannot ever happen, even if you think it would be for the best.
The standard .NET C# compiler and CLI run on and build for Windows, MacOS, and Linux. You can run your ASP.NET webapps in a Linux docker container, or write console apps and run them on Linux, it doesn’t matter anymore. As a .NET dev I have literally no reason to ever touch Windows, unless I’m touching legacy code from before .NET Core or building a Windows-exclusive app using a Windows app framework.
Ok, there’s no such thing as native Windows apps for Linux, but there are cross platform GUI frameworks like Avalonia and Uno that can produce apps with a polished identical experience across all platforms, no electron needed
Systemd has something like this. I don’t know if the kernel itself does.