But there are multiple ways to have execution leave a function.
The function could return.
The function could be aborted by SIGKILL.
The function could be aborted by a non-SIGKILL signal that preserves subsequent execution invariants.
The function could be aborted by a non-SIGKILL signal that doesn't preserve subsequent execution invariants (SIGSEGV in most--but not all--cases).
The function could abort(2) (not always the same as SIGABRT, but usually).
The function could overflow its stack (not always the same as abort(2)).
The computer could lose power.
...and that's without violating the spirit of the law with weird instruction-level stuff (e.g. is pop/jmp the same as ret? If I move the stack pointer and re-set all the argument registers, did I return?)
I know this is a joke, but pretending for a moment that it isn’t: this would immediately result in the rep system being gamed the same way it is on eBay: scam sellers can purchase feedback on cheap or self-shipping auctions and then pivot into defrauding people on high-dollar sales before being banned, rinse, and repeat.
Let's also see the differences: On github you can always see the interactions. On ebay, once a sale has been made, you have no idea what happens next. On Github you always have all the artifacts of where the reputation comes from.
What on earth makes you think that denouncing a bot PR with stronger language would deter it? The bot does not and cannot care.
If that worked, then there would be an epidemic of phone scammers or email phishers having epiphanies and changing careers when their victims reply with (well deserved) angry screeds.
I didn't mean the "fuck off" part to be quite verbatim... this ghostty PR[0] is a good example of how this stuff should be handled. Notably: there's no attempt to review or provide feedback--it's instantly recognized as a slop PR--and it's an instant ban from repo.
This is the level of response these PRs deserve. What people shouldn't be doing is treating these as good-faith requests and trying to provide feedback or asking them to refactor, like they're mentoring a junior dev. It'll just fall on deaf ears.
Sure, but that pull request is blatantly unreviewable because of how it bundles dozens of entirely unrelated commits together. Just say that and move on: it only takes a one-line comment and it informs potential contributors about what to avoid if any of them is lurking the repo.
If they immediately make another low-quality PR that's when you ban them because they're clearly behaving like a bad actor. But providing even trivial, boilerplate feedback like that is an easy way of drawing a bright line for contributors: you're not going to review contributions that are blatantly low-quality, and that's why they must refrain from trying to post raw AI slop.
Sounds like we're largely saying the same thing. Open source maintainers should feel empowered to say "nope, this is slop, not reading, bye" and ban you from the repo, without worrying if that seems unprofessional.
If you explicitly say "this is unreviewable junk, kthxbye" there's nothing unprofessional about it. But just blaming "AI slop" runs into the obvious issue that most people may be quite unaware that AI will generate unreviewable junk by default, unless it's being very carefully directed by an expert user.
Fair (and you’re basically describing the xz hack; vouching is done for online identities and not the people behind them).
Even with that risk I think a reputation based WoT is preferable to most alternatives. Put another way: in the current Wild West, there’s no way to identify, or track, or impose opportunity costs on transacting with (committing or using commits by) “Epstein but in code”.
I was disappointed that your paper devoted less than a sentence in the introduction to qualifying "slop" before spending many pages quantifying it.
The definitions you're operating under are mentioned thus:
> characteristic repetitive phraseology, termed “slop,” which degrades output quality and makes AI-generated text immediately recognizable. (abstract)
> ... some patterns occur over 1000× more frequently in LLM text than in human writing, leading to the perception of repetition and over-use – i.e. "slop". (introduction)
And that's ... it, I think. No further effort is visible towards a definition of the term, nor do the background citations propose one that I could see (I'll admit to skimming them, though I did read most of your paper--if I missed something, let me know).
That might be suitable as an operating definition of "slop" to explain the techniques in your paper, but neither your paper nor any of your citations defend it as the common definition of an established term. Your paper's not making an incorrect claim per se, rather, it's taking your definition of "slop" for granted without evidence.
That doesn't bode well for the rigor of the rest of the paper.
Like, look: I get that this is an extremely fraught and important/popular area of research, and that your approach has "antislop" in the name. That's all great; I hope your approach is beneficial--truly. But you aren't claiming a definition of slop in your paper; you're just assuming one. Then you're coming here and asserting a definition citing "the LLM creative writing community circa 2022-2023" and asserting redefinition-after-the-fact, both of which are extraordinary claims that require evidence.
Again, not only do I think that mis-definition is untrue, I also think that you're not actually defining "slop" (the irony of my emphasizing that in a not-just-x-but-y sentence is not lost on me).
I don't know which of the authors you are, but Ravid, at least, should know better: this is not how you establish terminology in academic writing, nor how you defend it.
The copy on the linked "UK geoblocking" page doesn't contradict that, though.
The authors say, basically, that there's a risk of prosecution in the UK that would financially devastate anyone that works on the project, and that the act of determining how to comply with UK laws is itself an extremely resource-intensive legal task that they can't or won't do. In other words, they're geoblocking the UK not out of activism but out of pragmatic self-preservation.
That's not in any way mutually exclusive with collective action.
...also, couldn't deciding to geoblock the UK be a form of collective action? If that's what you originally meant, I sincerely apologize for reading it backwards.
The challenge with that approach is memory: trigger conditions, if added irresponsibly, can result in unbounded memory and (depending on implementation) potentially linear performance degradation of filesystem operations as well. Unbounded kernel memory growth leads to stability or security risks.
That tradeoff is at the root of why most notify APIs are either approximate (events can be dropped) or rigidly bounded by kernel settings that prevent truly arbitrary numbers of watches. fanotify and some implementations of kqueue are better at efficiently triggering large recursive watches, but that’s still just a mitigation on the underlying memory/performance tradeoffs, not a full solution.
Depending on metadata cache behavior configuration, if the system is powered off immediately after the first command, then that could indeed happen I think.
As to whether it’s technically possible for it to happen on a system that stays on, I’m not sure, but it’s certainly vanishingly rare and likely requires very specific circumstances—not just a random race condition.
Uhh, if the system powers off immediately after the first command (mv a b), the second command (mv c d) would never run. So where would d come from if the command that created it never executed?
Sure, but splitting "atomic" operations across a reboot is an interesting design choice. Surely upon reboot you would re-try the first `mv a b` before doing other things.
The function could return.
The function could be aborted by SIGKILL.
The function could be aborted by a non-SIGKILL signal that preserves subsequent execution invariants.
The function could be aborted by a non-SIGKILL signal that doesn't preserve subsequent execution invariants (SIGSEGV in most--but not all--cases).
The function could abort(2) (not always the same as SIGABRT, but usually).
The function could overflow its stack (not always the same as abort(2)).
The computer could lose power.
...and that's without violating the spirit of the law with weird instruction-level stuff (e.g. is pop/jmp the same as ret? If I move the stack pointer and re-set all the argument registers, did I return?)
reply