There appears to be a few bad actors in the Lemmy community spreading ragebait for personal gain
In fact, the same mechanisms added at the beginning to catch bad human written code are the exact same that catch bad AI code
- No, the Linux kernel won’t use AI to auto approve code for inclusion. And no plans to do so
- The Kernel actually has a huge number of maintainers. As part of the process, all patches are reviewed by a human who provide feedback as part of the process, and patches get bounced back and forth multiple time.
- Patches don’t just magically go straight to master. The maintainers generally have their own branches where it goes to, then it goes to staging trees like Linux-Next. It goes through many eyes, and many tests by the end. The idea that AI code is overrunning the kernel is rediculous
- Maintainers also check that the code meets coding guidelines and is written properly, and solves the problem they are trying to solve. Yes, they also ensure the code isn’t slop
- LLM’s though might be used to identify obvious problems (bugs / coding guideline issues) with the code. These don’t generate “slop” just find issues
- The only thing that matters is the human who submitted the code, as they should be checking the code submitted anyway (including LLM generated code).
Writing bad code isn’t something new, and isn’t unique to LLM’s. Coders (and it seems some “journalists”) have been writing slop since computers were invented.
The process hasn’t gotten less stringent (probably even MORE stringent as there is an additional set of robotic eyes that can also check), and the same mechanisms that were put in place to catch badly written code 10 years ago, are still there now
You must log in or register to comment.
i’m worried about the direction linux is going, and i am particularly worried about linus himself.
that said, the pivot to ai guy gets his bread buttered by being anti-ai. a number of people on the fediverse maintain their followings in part by constant, vociferous ai bashing.
i also hate ai! i think it’s dangerous and one of the worst things humanity has yet created!
but i can read the mailing list, i can look at the patch, and this is so overblown it’s nuts. nothing about what went on with this patch matches the descriptions people are giving it. someone even pulled a “i don’t understand the rcu that well” quote in order to make their point, but that quote isn’t from anyone really involved in the patch at all. it’s just cherry picking a loosely-related message in order to have something to scream at.
and, i hate to say it, but this is pretty common with dave and his crew of hangers-on.
it frustrates me to no end that the people who are most visible in the anti-ai camp are people like this, because it undermines everything when it’s so trivial to point out how they’re blowing things up way out of proportion in order to maintain their rage machine
I wasn’t going to name names… lol.
I think part of the problem though, is it’s like vaccination, where people have jumped online with no actual knowledge and isolate themselves in online communities where they ban anyone who isn’t on their side.
There was a comment here which spoke about the recent “Racing Condition”, which is further evidence they aren’t a dev (devs have been writing “race conditions” since the kernel started)
But, in practice, Linus has no choice here realistically I feel. It’s a huge competitive disadvantage and a security issue NOT to be using it.
It does suck… And I look forward to AI companies HOPEFULLY getting taxed into oblivion
No, the kernel has not gone “Full AI Slop Code” yet. FTFY
Though I’d argue it has since Linus introduced a racing condition with his latest slop contribution.
It’s not called a Racing condition, its called a race condition (so, I already know you’re probably not a dev anyway, and are just repeating info)
The kernel has always had race conditions… A good example is: https://www.networkworld.com/article/4200802/linux-xfs-has-a-decade-old-race-condition-allowing-full-root-access.html (this was decades old code)
In fact, race conditions were a big factor for dropping SysVInit… They’re even easier to do on a multi-threaded system, and become more common when optimising and multiple things are happening at once
And, the simple fact is, the development process is DESIGNED to catch them (and it did), but they are so common, that the news never reports them. If anything, AI is actually making them LESS common
Linus just yeeted a slop bomb before going on vacation. This is the definition of slop. LLMs have no business near the kernel code or being used at all.
https://tech.lgbt/@workingclassgames/117447428388877864
https://lwn.net/ml/all/as6vBoWQGglxXxb0@thinkstation/
https://lwn.net/ml/all/CAHk-=wiCe2H33izZHDyDHEhcFwUr9fXZk27-WZ2vn_pn5FcZTg@mail.gmail.com/
So… your evidence for slop is that he made a patch, they caught an issue in the review process, and then he had to go on vacation so he asked another maintainer to take over to get the change done correctly in the merge window?
How is that not the process working exactly as intended?
People really be thinking every fully human-rolled PR is gonna be flawless, yet the influx of fresh CVEs is higher than it’s ever been right now, because LLMs are busy poking holes in existing human code.
Exactly this.
I’ve been doing code review on some of our code from 10+ years ago and I’m surprised by how many major bugs I’m STILL finding (different ones between Claude and ChatGPT). And this is code that’s been in prod for years, and in heavy usage.
Yeah but
humanSlop = good.
aiSlop = bad.The funny thing is that I wrote a Websocket server library years ago, and recently (as we scaled up), there were reports of bad performance in much larger systems
AI actually basically called my code slop (and it was), and made changes that improved performance, and fixed issues with incomplete frames. The solution it came up with was far better, and far cleaner than mine. I never would have come up with it…
And, I never would have guessed that’s where the performance issues were either
I feel like there are people who are willing to point the finger instantly when AI generates bad code, but, it doesn’t get credit when it improves it
A profiler ought to show you where it’s spending the most time.
I did profiling. But, there were many other more likely candidates, and, its a bit of a weird edgecase in our case (since we don’t control the entire environment… It’s middleware)…
I think we need a redefinition of “bug” though. If something hasn’t been noticed for 10+ years, is it really a “bug”? I think the definition should depend on the probability of negative effects, not just on the possibility.
In fact, my impression is that any piece of code can be shown to have some bug, if taken from a particular angle or in particular contexts or scenarios.
(I think there are also connections with mathematical-logical foundations. For example, it is impossible to build an axiomatic system that is enough powerful and does not have undecidable propositions. Whenever you fix the axioms to fix one of the undecidable propositions, another one automatically pops up.)
If something hasn’t been noticed for 10+ years, is it really a “bug”?
I had to stop reading here because you seem to think the answer is no but it’s actually fuuuuuuuuuck yes.
Just because an issue isn’t reported though, doesn’t mean it hasn’t been noticed by users.
We often see issues which are discussed in private forums, but were never actually reported to us (which is why we check them all)
From my understanding, that was a patch series that was still under development, and NOT in the kernel. And, it was caught in Code reviews.
Code reviews are normal, and stuff like this is NORMAL, and has been well before AI. Are you seriously claiming the kernel never received buggy patch sets (in staging / non-master trees) in the past?
Also, it is interesting that the same 3 links seem to be posted everywhere blindly. Did you even read what I wrote in my post?
Do you mind explaining the technical reasons why the patch is “slop”? Or, did you just see the LLM part and think “this is gonna be great pitchfork material and I’ll pretend like I actually understand whats going on”
Yeah lol also reading through the actually interaction around the patch
> The uptodate check in filemap_read_rcu_can_copy() has to stay, though. > The flag only says the folio was uptodate when it was marked. Some > filesystems clear PG_uptodate on a folio that stays in the page cache, > and that can happen after the folio got the flag. Those filesystems are buggy. We have assertions that the uptodate flag is set on folios mapped into userspace, and filesystems going arund clearing the uptodate bit will cause problems. It's something I'm working on removing, but since it's all connected to writeback errors, it takes a lot of arguing with each filesystem maintainer.So one of the reasons there’s so many changes in the patch series is to account for… human bugs
Was actually going to mention that.
There are also ambiguities in specifications too.
Like one of our libraries is a websocket/http server I developed, that has been working fine for years. However recently, a system broke, and we actually discovered it’s because there are even small ambiguities in http areas too that we need to accomodate, and I couldn’t find anything in the specs that explicitly prevented it either.
Dependencies, dependencies everywhere! https://xkcd.com/2347/
(well, maybe not exactly right, but similar problem.)
LLMs have no business near the kernel code or being used at all.
Cool. Let us know when your fork is packaged and I’ll test it out.
your ai will test it out
Nope. I assisted system test back in '04 when I was doing build/rel for Unix and ent Linux, so it’s no big deal: if you have a test plan I’ll run it too.
