Performance improvements in libffi
25 points by atgreen
25 points by atgreen
It's rare that I feel like LLM scent gradually increases throughout an article. I'm going to guess that the author started writing and just got tired at some point. Independent of the LLMness, it also has too much empty text and misses most of the interesting details. For example, it doesn't talk about how executing the plan avoids clobbering registers across different ABIs. It also doesn't seem to motivate why not simply jit, since the plan is already not portable.
The code is almost entirely Claude.
Felt the same way about the post. Went to the repo, saw all the work had the Claude co-authorship.
Felt the same way. In particular:
Most of those instructions aren’t moving argument bytes. They’re deciding where the bytes go. The x86-64 calling convention has genuine rules,
What is the function of the word 'genuine' here? Which ABI doesn't have genuine rules? You can't just vibe your arguments into registers
I've made some edits for clarity. The reason not to JIT is to maintain the W^X memory promise, which a JIT can't keep since it writes code into a writable-executable page.
This is a solved problem for over a decade. The mprotect() syscall can dynamically change the permissions of pages; the W^X constraint merely implies that pages must be toggled between RW and RX. For example, SBCL respects W^X constraints while supporting dynamic compilation and garbage-collection of JIT pages. Since native calls shouldn't need to be repeatedly patched, this actually could fit the even stronger constraint that some systems configure where executable pages may never become writable in the future.
Please consider that Claude misrepresented reality to you and confabulated technical facts.
This site has self-promotion guidelines that the author does not follow so I have flagged this as spam.
This is a good idea. It reduces FFI overhead without the complexity and security issues associated with a JIT.
I'm so tired of reading comments saying that code or writing were written by LLMs. They're so boring, and are a form of ad hominem attack. In fact, it happens so much, and follows the same recipe so closely, that I'm left wondering whether the haters are themselves LLMs. If you have a substantial complaint to make about a piece of code or text, make a specific, concrete complaint. Don't just tar the whole project with your "LLM scent" brush. Doing that has all of the courage of a drive-by shooting.
"This smells like it was written by an LLM" is a substantial, specific, concrete complaint about the text. I don't understand how you could possibly classify it as an ad-hominem; it has absolutely nothing to do with the person who made the blog post, it's entirely a complaint about the text they made.
How can smelling like something be substantial and concrete? What if the smell is wrong and the author is just bad at writing?
It's bad for something to smell like LLM slop because that smell stems from a bunch of rather tedious aspects of the writing; over-use of literary devices like "it's not just X, it's Y", structure which implies a connection that's not there, lazy not-quite-correct statements which sound reasonable at a glance, extreme unnecessary verbosity, that sort of stuff. People dislike AI writing both because it feels disrespectful, and because it's genuinely bad writing.
Though I have never actually seen someone who's bad at writing produce LLM-like text. Human "bad writing" tends to look different.
https://lcamtuf.substack.com/p/the-100000-whys-of-ai
And, yes, if the author writes poorly, picking the same empty phrases and high verbosilty as AI, that's a substantial and concrete problem with their writing.
People do that because the text really is tiresome to read, and people want to vent, maybe in hopes the author catches the hint and stops annoying his readership? I had the same experience, though I generally don't go around "accusing" people of using LLMs, it's obvious and annoying enough that IMO it speaks for itself.
I've written many comments which do not directly assume that the author used a chatbot, and instead offer generic writing advice which could help any author, human or otherwise. Curiously, as measured by unkind flags, it appears that people are more offended by a comment explaining how to improve their writing than by a comment accusing them of using a chatbot.
Well, you took the high road, and those authors did themselves a disservice.
Now I want to do the same thing to see if I can repro the flags you were getting. (While staying maximally tactful and being a good garden-party guest, of course!)