This is Windows, but it might shed some light on the situation. I have a Qt application that I made, and occasionally when I switch from one window to another, the cursor doesn't switch from resize to normal, or vice versa, until I move the mouse. The precise effect is consistent, but difficult to describe, hence why the "sometimes". I think it happens because I'm not handling the window switch event as one that may require re-evaluating the cursor shape.
I don't understand. First, how is that a problem? Second, why is it the default expectation that different operating systems will have the same set of flaws?
That's like asking, "if the title bar can have different sizes, should we make the hot area for moving the window also of different sizes?" The answer to both questions is "obviously yes!" The shape of the thing and how it responds to user input do not match by coincidence.
The start screen is something you just had to get used to. I think it's more comfortable than the menu. Effectively it works as a second desktop to put application shortcuts on. I have about 30-40 on mine (on Windows 10, mind you), which is way more than would fit on a menu without submenus.
I'm pretty sure "slop" in the sense used in "AI slop" is a word in common usage for any kind of cheap, low-quality, unpalatable edible paste, like gruel or anything of that nature, especially when it has a homogeneous consistency. It can also appear in verb form such as "slop it onto a plate", that is to scoop up the slop with a ladle or some other utensil and messily splat in onto a dining plate. It very much is not Internet slang, and I'd say it's quite an appropriate term for what it describes in its new meaning.
"AI slop" is an internet meme that bears a strking resemblance to another, older meme, "goyslop"; why is it such a stretch to believe the former derived from the latter? "AI slop" was being used on 4chan as far back as November, 2022 on /g/:
It also saw its first use that month on /pol/, though I won't link to the archived threads (for obvious reasons). Unless you can provide earlier prior art, the most likely etymology of the term is 4chan, November, 2022, derived from "goyslop."
Because we’ve fed slop to pigs since the 1600s? It’s a commonly known word with a clearly understood meaning. It didn’t come from or is a shortening of goyslop, you’re just flat out wrong.
Right.. but it’s WOTY in 2025 not 1600. The reason this word and many others (including doomer, neckbeard, zoomer, etc) are popular can easily be traced back to 4chan.
There’s a book called“Algospeak” by Adam Alekaik specifically talks about how internet slang terms often originate from radicalized communities like 4chan and slowly filter into the mainstream while losing their original political meaning. Goyslop-> AI slop is a textbook example of this.
Where's the evidence that "AI slop" actually originates from "goyslop", though? Just because one predates the other and both contain the same root word? It's equally if not more likely that both terms were derived independently. Like I said, "slop" is a word in common usage that precisely matches the usage of both terms: something bland, low-quality, and high-quantity.
The way “slop” is used here is very specific. It implies a power dynamic between the slop producer and consumer where the consumer is viewed as cattle, and the producer feeds the cheapest possible product.
GP cities specific examples of this usage on 4chan in 2022 which is proof until someone can find a counter example.
I'm not sure that connotation is all that present in the way it's commonly used, but I'll grant it. However, like the other person you responded to has said, "slop" already had that meaning, because it is the low-grade cattle feed. So If both "AI slop" and "goyslop" carry these shades of meaning, it would not suggest one descends from the other, but that both descend directly from "slop".
That's maybe true, but "goyslop" was specifically referring to vapes, processed food and tiktok. Then shortly after people started calling tiktok "slop" and ai tiktok "ai slop".
I think its a stretch to declare there is zero relation considering how much internet language originates from 4chan.
>"goyslop" was specifically referring to vapes, processed food and tiktok
That doesn't sound very specific, that sounds quite broad. Looking around posts up to 2023 I can see the word used for just about anything, including HDMI and Disney. Honestly, this says to me it's just used as synonymous with "slop" in the broad sense, with no added meaning.
>I think its a stretch to declare there is zero relation considering how much internet language originates from 4chan.
There's no zero relation. The relation between the two terms is just not parent-child, but fraternal. Both simply inherit their meaning from "slop". "Slop" already has connotations of cheapness, low quality, high quantity, and cattle feed, and is a word that has existed since Old English. There's literally no reason to think "AI slop" is descended from "goyslop". At best someone heard the latter and by analogy coined the former, but given that "goyslop" had already been coined by simply prepending a modifier to "slop", there's not even any need for that explanation.
"gas" as in "natural gas" is not a shortening of "gas the Jews" either. Just because antisemites used a word, that doesn't mean the word is antisemitic.
If the term originated on 4chan, then there's little doubt it derived from "goyslop," given how common the usage of "goyslop" was and is there, and how similar are the connotations: overlords feeding their "cattle" an unhealthy facsimile of something, editable or digital, to physically or mentally sicken them and render them docile & subservient. The people here who don't see the connection also fail to demonstrate any familiarity with imageboard culture and its memes. Even in this thread, at least one other person noted the link before me (and got flagged for it)[1], and the Wiktionary entry cites "goyslop" as a related term[2].
The only question remaining is whether it did, in fact, originate on 4chan. If it saw some usage outside of imageboards before November, 2022, then that undermines the argument. But if 4chan birthed it, then "goyslop" was surely its inspiration.
Nah... I've heard the term slop used all my lifetime. Very common word, as is "sloppy". In fact, I'd connect it with sloppy in the sense of poor workmanship.
Goy is the Hebrew for a Gentile (or a nation). However, while goyslop is an earlier coinage I certainly do not link it to AI-slop, but more to "sloppy".
"Goyslop" and "sloppy" are both derived from "slop". "Goyslop" meaning "slop of the goy variety" (equivalently to "AI slop"), and "sloppy" meaning "having the qualities of slop".
I was already aware of the term "goyslop" but I see it as a parallel development rather than the origin. I heard daytime TV programming being referred to as slop over twenty years ago. I don't think there are any antisemitic undertones for the word outwith the "goyslop" coinage.
Same source shows 'slop' alone being used as far back as 2008: https://desuarchive.org/_/search/text/slop/order/asc/ Some of these uses are the verb form, but most are the noun form, being used in pretty much the same sense it has been used for generations, and is in use today.
In that sense, std::move() is no different than other passing semantics. Just because you wrote at the call site that you want to pass a copy of your object doesn't mean that the callee will actually make a copy of it.
Who says there's only one resolution candidate? A different overload could be defined elsewhere that the compiler prefers for that particular combination of arguments, that doesn't cause a copy. std::move() works the same way. The semantics of the operation is defined not by what's at the call site, but by the context.
Sure overload resolution happens first, but once the compiler has found the correct match then the way arguments are passed depends only on the function signature of that match (callee), and how the caller is passing.
An argument passed to a value parameter will be passed by copying, unless it's an rvalue (e.g. forced with std:move) where a move constructor has been defined for that type, in which case it will be moved. The callee has no say in this.
>Sure overload resolution happens first, but once the compiler has found the correct match then the way arguments are passed depends only on the function signature of that match (callee), and how the caller is passing.
Yes, and std::move() works exactly the same. The compiler first determines whether to move or to copy, and then generates the call to the corresponding constructor or assignment operator. Just like how foo(x) doesn't tell you anything about whether a value is being copied, foo(std::move(x)) doesn't tell you anything about whether a value is being moved.
You might say "well, you need to look at all the signatures of foo() to tell if there's a copy", and to that I say, "yeah, and you need to look at what x is to tell if there's a move".
Meaning, just like move semantics, overload resolution can sometimes be surprising, and the compiler may not always do what you expected if you don't fully understand the types you're working with. std::move() is not special in this sense.
Ah, yes, unfortunately the language says that a value parameter of type T and an rvalue parameter of type T (T&&) are both equal priority "exact matches" to a call passing an rvalue argument, but at least if that was the only difference between two functions you'd get an ambiguous overload compilation error rather than it just selecting an unexpected one.
A workaround for this, if you want an rvalue parameter to match an rvalue argument during overload resolution, is to make the alternate "value" (vs rvalue) overload a const reference argument vs a value one.
So, if you have f(T&&) and f(T), and call f(std::move(t)) then you'll get an ambiguous overload compilation error, but if you instead had f(T&&) and f(const T&), then f(std::move(t)) will match the rvalue one as you may hope for.
>So, if you have f(T&&) and f(T), and call f(std::move(t)) then you'll get an ambiguous overload compilation error [...]
Okay, but that's not what I'm saying. I'm not talking about the program being invalid, I'm talking about the program being confusing to the programmer, which is what this article is about. Sure, in that case the program is ill-formed. What if you have f(const T &, double) and f(T, int)? If you call f(x, 0) you cause a copy, and if you call f(x, 0.0) you don't. A programmer who's not aware that the second overload exists will not realize this is happening, in the same way that he will not realize std::move() is not moving anything if they don't realize, for example, that the argument is const.
There are cases where you would not want to reject such code, though. For example, if std::move() is called inside a template function where the type in some instantiations resolves to const T, and the intent is indeed for the value to be copied. If move may in some cases cause a compiler error, then you would need to write specializations that don't call it.
reply