☆ Yσɠƚԋσʂ ☆

  • 651 Posts
  • 774 Comments
Joined 7 年前
cake
Cake day: 2020年1月18日

help-circle
  • This is the exact same mentality as trying to arrest the climate crisis by using paper straws. Not only does this accomplish nothing of value in the long term, it’s actually actively harmful because it gives people the feeling like they’re doing something which takes energy away from actually addressing the problems in a meaningful way.

    And the whole AI boycott movement is a great illustration of why people who don’t learn from history are doomed to repeat it. Back in the dawn of the Industrial Revolution, the Luddites were highly skilled workers who saw a few capitalists growing rich by introducing machinery to substitute for their own skill. And they set to work to burn the factories down because they thought that if they could only destroy the machines, the problem would be solved. They ultimately failed in their efforts because they failed to grasp the material forces driving the march of history. The machines prevailed because the ruling class wanted to cut costs and increase profits. The evils of the Industrial Revolution grew out of the possession of the means of production which grants the power to determine how technology is used. The same is true today, and it is why similar attempts to boycott AI are doomed to fail. Those who want to stop these systems from being put into production are merely attacking the symptoms of the underlying material relations.

    Attacking the machinery amount to barking at the wrong tree because it’s the class relations within which it happens to be applied that are the problem. As Marx put it, technology does not exist as an isolated phenomenon, but is dominated by the social structure of the society in which it happens to occur. To control the means of production collectively is to make technology serve human needs rather than merely increase the profits of the rich. That is the very lesson that the Luddites missed, and that many critics of AI are missing today as well.

    On top of all that, these companies are literally telling us what they fear most. They don’t care in the slightest that some niche community is going to make code artisanally. It doesn’t affect the overall dynamic in any way for them. Data centres are still going to be built, and the models will still be rented. What they fear are open models that people can run locally which the corps can’t control and that don’t have a moat. That’s what companies like Anthropic and OpenAI are trying to prevent right as we speak because that’s what directly hits their revenue streams and undermines their whole business model.

    If people genuinely cared about doing something useful they’d spend their time figuring out how to run models more efficiently, how to train them in a distributed fashion, and to lower the barriers for people running them locally. But instead we just get performative liberal brain rot as usual.















  • Any project is a sum of its parts, and if you’re talking about maintainability, then the parts you could easily point to would be things like high coupling, overly large file sizes, functions that are too big and should be broken up.

    Meanwhile, your own link shows that it’s roughly within the ballpark of industry average. And if you look through issues for any large project on github you’ll see similar types of issues. Given how new the project is, none of this is really surprising or out of the ordinary.

    As a note, nowhere did I suggest they do manual code reviews of everything at this speed. What I do think they have is a regression test suite which they build out as issues come up and they fix them.


  • I keep hearing people talk about trust, and it’s really doesn’t make sense to me because we’ve never done software development based on trust. Humans make mistakes all the time, and I’ve seen plenty far worse human code than anything an LLM has crapped out over my career. The way we ensure quality is through having a process. It’s done by having good specifications, testing, code reviews, planning, and so on. All these things equally apply to code written by hand and that’s generated by an LLM, and trust has nothing to do with it.







  • The only studies I’m aware of used tiny samples and produced muddled conclusions. If you have some conclusive empirical research then do feel free to share it though. Meanwhile, using LLMs doesn’t mean doing less, it just means focusing on different things. The skill deficit here is the same kind as the skill deficit people have using punch cards or writing assembly by hand today. As more aspects of coding become automated, different things become relevant and that’s what people shift their attention to.



  • Assuming that Linux kernel team continues to use the same review process they always had, there’s zero reason to think that there would be an increased rates of bugs due to LLM generated code. This seems to be something people without programming experience don’t understand. Code quality isn’t premised on trust, it’s a product of the development process. Projects ensure quality by having specifications, tests, doing code reviews, and so on. As long as the practices the kernel team has established continue to be applied, they will catch the bugs made by LLMs or humans exactly the same way.





  • You have absolutely no clue how LLMs work. It’s a neural network generalizes patterns that get imprinted onto it during training. And then these patterns are expressed in the given context during inference. People tend to confuse the output looking similar to training data with the mechanism being simple retrieval. While these agents do not think or feel, describing what they do as storing things in a database and pulling them up later is grossly incorrect. This framing fundamentally misrepresents how LLMs actually store and retrieve information.

    There is no database or a lookup table, and there is no copy of any text they were trained on tucked away somewhere inside the weights. What they have is a compressed statistical model of the patterns that exist across trillions of tokens the text was broken down into. When you ask an LLM a question it does not go find the relevant passage and regurgitate it. What actually happens is that it generates text token by token based on the probability distribution it learned during training. It’s more akin to the way state machines like Markov chains work.

    If anything, the way LLMs work is actually much closer to how humans improvise or combine ideas than to how a search engine or database works. When you write a sentence, you don’t pull up a specific sentence you memorized from a book and copy it. You’ve absorbed the patterns from countless examples of language over your lifetime and internalized them. Writing is a process of generating novel combinations based on those patterns.

    Similarly, the weights of a model encode statistical regularities about word co occurrence, syntactic structures, semantic relationships, and higher level conceptual patterns. When it generates text it is combining those patterns in ways that were never present in the training data. That’s how LLMs produce entirely novel sentences that have never been written before, and why they can be prompted to combine ideas from different domains in creative ways.

    LLMs do reproduce training data verbatim in some cases, but this happens because of overfitting on rare or repeated sequences. When a specific string appears many times in the training data like a famous quote or a common error message the model learns to assign an extremely high probability to each token in that exact sequence. So when it generates it follows the most likely path to reproduce the original text. It is similar to how a human can memorize a song or a poem by hearing it many times but that does not mean our general language ability works by pulling up stored copies from memory.

    The notion that LLM assisted coding is equivalent to ordering from the menu at a restaurant is laughably naive. You seem to think that it’s like a slot machine where you put a query in and then you either get a correct result or some nonsense and you have to try again.

    The way this process actually works is that you start by understanding the problem and figuring out how you want to solve it in terms of architecture, data structures, and algorithms that will be used. Then you get the LLM to come up with a rough shape of the solution, and iterate on it until it works the way you want. In practice, it’s like working with a genetic algorithm.

    The core skill in using these tools is the same as the skill you need when writing code by hand. You have to understand the given requirement, the shape of the solution, and how to verify that the code that was produced actually matches the intent.

    It’s ironic that you talk about AI only copying while uncritically regurgitating nonsense yourself.