News for hackers. Stuff that matters.
Re:GitHub Copilot Loses an Average of $20 per User per Month by bryanlarsen on Tuesday October 10, 2023 @10:18AM (#37832459)
AI is such a huge expectations dichotomy. For those of us used to the continual disappointment that pre-LLM AI was, the current crop of LLM's are amazing, mind blowing things. We start raving about them, so other people take a look expecting that modern LLM's are the greatest thing since sliced bread. They're not quite that, so we get HN comments complaining that AI sucks.
Re:GitHub Copilot Loses an Average of $20 per User per Month by finnthehuman on Tuesday October 10, 2023 @10:34AM (#37832652)
> We start raving about them, so other people take a look expecting…

If that’s what you want to call it.

I see hypemen overpromising and product underdelivering. And when pressed about specifics, attempts to drown queries in jargon or an ass-covering retreat to treating it like it’s just a tech demo not intended to be used for anything ever.

Re:GitHub Copilot Loses an Average of $20 per User per Month by lukeschlather on Tuesday October 10, 2023 @11:07AM (#37833036)
It looks like it's capable of anything, so it's easy to point out that it's pretty bad at certain things, but that's an easy way to miss the things it's actually very good at. Also even if it's bad at most things it's still often good enough to be useful.

And it seems likely that with an order of magnitude better hardware it might be good at some things that it seems really bad at now. So yes, it's a tech demo for a lot of things that aren't quite ready, and it's also very useful as it is.

Re:GitHub Copilot Loses an Average of $20 per User per Month by cm2187 on Tuesday October 10, 2023 @11:23AM (#37833264)
And management consultants solving every problem in the world by adding a “AI” box in their powerpoint flow diagram.
Re:GitHub Copilot Loses an Average of $20 per User per Month by chasd00 on Tuesday October 10, 2023 @12:01PM (#37833889)
> And management consultants solving every problem in the world by adding a “AI” box in their powerpoint flow diagram.

i work at a large consulting firm everyone knows and am seeing this first hand. I'm not on the bandwagon until i see real money in the bank from large AI projects succeeding. It's not happening yet. I not a naysayer but am still very skeptical.

Re:GitHub Copilot Loses an Average of $20 per User per Month by antisthenes on Tuesday October 10, 2023 @01:03PM (#37834649)
Yep, just like "crypto" before that, and "big data" before that and "social media presence" before that and so on and so forth...
Re:GitHub Copilot Loses an Average of $20 per User per Month by bryanlarsen on Tuesday October 10, 2023 @07:15PM (#37838984)
And "on the internet" before that. Which eventually happened, but the crash of 2002 happened between.
Re:GitHub Copilot Loses an Average of $20 per User per Month by xctr94 on Tuesday October 10, 2023 @10:29AM (#37832575)
I think the problem is that they aren’t mind-blowing, but an improvement.

I resent some LLM implementations on principle, but decided to give these code helpers a try. What I found was they’re reasonably bad, and I kept telling them the solution doesn’t work, only to be presented with a little tweak.

So I don’t see the point of outsourcing my thinking, I’d rather remain intelligent and do the search/try/tweak on my own, instead of pretending a half-assed LLM is genius.

That doesn’t mean they don’t have good use cases, or aren’t an improvement on previous tech. But we definitely should stop calling them mind-blowing. Jaron Lanier had long ago predicted we’d willingly downplay human intelligence to pretend AI was… I.

Re:GitHub Copilot Loses an Average of $20 per User per Month by ryanklee on Tuesday October 10, 2023 @10:42AM (#37832734)
> I think the problem is that they aren’t mind-blowing, but an improvement.

You seem to be doing what GP is pointing out.

GP's claim is that the relative improvement itself is mind-blowing, not that the tech is mind-blowing in an absolute sense.

I tend to agree: much of the detraction hangs on current-state rather than a probable potential-state informed by recent relative advancements.

In other words, many proponents are chuffed because of that potential; not because actuality. Likewise, skeptics are reserved because of the actuality, and not because of potential, for whatever reason (there are at least a few main ones, I think).

Re:GitHub Copilot Loses an Average of $20 per User per Month by mandevil on Tuesday October 10, 2023 @01:32PM (#37834978)
See, I'm very skeptical that we can guess at the potential, because so much of it depends on research and figuring out better ways to do things going forward, and successful research programs are very unpredictable.

I feel like people are taking Moore's Law, which is definitely a real thing, and thinking that everything else is going to advance like semiconductors did, and I just am not seeing it in any other field. It's not true in software development (where gains, such as they are, are more linear than exponential) its definitely not true in rockets or civil engineering or steel or anything like that. So I am afraid a whole lot of people are expecting Moore's Law type improvements in AI, when really AI advances more like punctuated equilibrium: a sudden dramatic improvement, then a long period of consolidation and stasis, then another sudden dramatic improvement, often in a totally different unpredictable area.

But I've just been keeping tabs on AI since the hot way to do it was Expert Systems back in the 1990's, and I'm aware of its history since Norbert Weiner wrote Cybernetics back in 1947, and this seems to be a repeating pattern: a single major breakthrough (in this case, honestly, the combination of large quantities of data with NN's- with driving and natural language being the two easiest to get, and so the most prominent examples) followed by a lengthy fallow period where not much appreciable progress happens, then another breakthrough, often orthogonal to where earlier breakthroughs happened.

Re:GitHub Copilot Loses an Average of $20 per User per Month by baz00 on Tuesday October 10, 2023 @12:17PM (#37834107)
They do suck unconditionally. They're like having a mediocre person working with you that you have to verify and validate all the time that sucks up a ton of money and electricity and generally does bad things to the environment.

Edit: I haven't even started on the social and political impact this has either.

Re:GitHub Copilot Loses an Average of $20 per User per Month by IshKebab on Tuesday October 10, 2023 @02:57PM (#37835998)
You missed the point. And you're also completely wrong. Copilot is extremely useful and in general a huge timesaver.

Yes if you tell it to write an entire program it will get it wrong and you'll spend some time verifying things. But that's not a sane way to use it. As a very clever auto-complete it's fantastic. It's also pretty great at getting past "blank page syndrome". Even if what it spits out is wrong it's still helpful to get you started.

Re:GitHub Copilot Loses an Average of $20 per User per Month by baz00 on Tuesday October 10, 2023 @03:04PM (#37836100)
No I didn't miss the point, not even slightly. You didn't read mine and are blinded by the insane virtues.

Do you really think it's fine blowing 400 watts because you can't be arsed to think or do not have the creative intelligence to get over the blank page syndrome and have to lean on a crutch?

Re:GitHub Copilot Loses an Average of $20 per User per Month by hazard on Tuesday October 10, 2023 @03:21PM (#37836284)
> Do you really think it's fine blowing 400 watts because you can't be arsed to think or do not have the creative intelligence to get over the blank page syndrome and have to lean on a crutch?

Yes, I think it is absolutely 100% fine.

Re:GitHub Copilot Loses an Average of $20 per User per Month by Leherenn on Tuesday October 10, 2023 @04:07PM (#37836808)
I don't know if I'm doing something wrong, and admittedly I have only tried the free version of ChatGPT (3.5), but it basically never works for me. Not even for relatively simple things.

From my past history:

"Is "192.168.1.4" included in the subnet "192.168.0.0/16"?" -> No

"Check whether a widget overflows in flutter" -> returns a function that cannot be made to works even with a lot of massaging (uses stuff that does not exist)

"Write a parser for this multiline format in C++ (describe format)" -> parser only read first line

Admittedly a trick one: "Can you give me a C++ function to merge 2 uint32_t and one uint16_t into a unique uint64_t?" -> happily gives an answer

Sometimes it is salvageable, and sometimes it can provide ways I did not consider to solve a problem (though the proposed solution is usually broken), but usually I would have been faster to do it myself than to try to fix whatever it gives me.

I have basically given up on it, except for some generic "how would you solve problem X?", and when I see people talking about it, it feels like a totally different world.

Re:GitHub Copilot Loses an Average of $20 per User per Month by IshKebab on Tuesday October 10, 2023 @04:29PM (#37837045)
Yeah you are doing it wrong.

> "Is "192.168.1.4" included in the subnet "192.168.0.0/16"?" -> No

ChatGPT is not good at numbers or complex maths like this.

> Check whether a widget overflows in flutter

I mean this would be closed as unclear on StackOverflow, but again, this is basically asking ChatGPT to write an entire function. It can do a good stab but it's not going to get it correct.

Copilot isn't for that sort of thing. Let me give you a more realistic autocomplete example from my code:

    std::fs::write(&sv_path, sv).expect("error writing top.sv");
    std::fs::write(&rs_path, rs).expect("error writing top.rs");
    std::fs::write(&cargo_toml_path, cargo_toml).expect("error writing Cargo.toml");
    std::fs::write(&cpp_path
It completes `, cpp).expect("error writing main.cpp");` which is actually exactly what I had. I may have used Copilot to write that; I don't remember. The point is it is 100% correct and saved me writing all that. Traditional autocomplete can't compete with that.

However even for "do it all for me" queries it can still be useful. For example I asked:

> I have a C++ process paused in a debugger (lldb). It is consuming a lot of memory. Is there any way I can see what is using the memory? E.g. a heap profiler that can attach to the process?

It got it wrong and told me to run the process under Valgrind. I said:

> Those instructions aren't for attaching to an existing process.

And it told me about the Heaptrack project with can do exactly what I want. I can see why search engines are integrating this asap. Even though it hallucinates, it does that infrequently enough that it's still really useful. I mean it hallucinates frequently but even so it is very useful.

Perhaps a better example is this:

> Write a C++ program to run a child process and send data to its stdin and stdout while it is running.

After 2 more prompts I got it to output the code below. This code is not correct. But the fixes to make it work are relatively minor, and EASILY less work than writing it all from scratch.

In a few years we will look on people that don't use Copilot (or similar) like people that don't use IDEs. They're hurting their own productivity out of principal.

-------

    #include <iostream>
    #include <unistd.h>
    #include <sys/types.h>
    #include <sys/wait.h>
    #include <vector>

    class ChildProcess {
    public:
        ChildProcess() : pid(-1), pipefd{-1, -1} {}

        ~ChildProcess() {
            if (pid != -1) {
                close(pipefd[1]);  // Close write end of the pipe
                waitpid(pid, nullptr, 0);
            }
        }

        bool create(const std::string& command, const std::vector<std::string>& arguments) {
            if (pipe(pipefd) == -1) {
                std::cerr << "Failed to create pipe." << std::endl;
                return false;
            }

            pid = fork();
            if (pid < 0) {
                std::cerr << "Failed to fork process." << std::endl;
                return false;
            } else if (pid == 0) {
                // Child process
                close(pipefd[0]);  // Close unused read end of the pipe

                // Redirect stdin and stdout to the pipe
                if (dup2(pipefd[1], STDIN_FILENO) == -1) {
                    std::cerr << "Failed to redirect stdin." << std::endl;
                    return false;
                }

                if (dup2(pipefd[1], STDOUT_FILENO) == -1) {
                    std::cerr << "Failed to redirect stdout." << std::endl;
                    return false;
                }

                // Convert arguments to a C-style array
                std::vector<char*> args;
                args.reserve(arguments.size() + 2);
                args.push_back(const_cast<char*>(command.c_str()));
                for (const std::string& arg : arguments) {
                    args.push_back(const_cast<char*>(arg.c_str()));
                }
                args.push_back(nullptr);

                // Execute the child process
                execvp(command.c_str(), args.data());

                // execvp() only returns if there's an error
                std::cerr << "Failed to execute child process." << std::endl;
                return false;
            } else {
                // Parent process
                close(pipefd[1]);  // Close unused write end of the pipe
            }

            return true;
        }

        void write(const std::string& data) {
            if (pid != -1) {
                ::write(pipefd[1], data.c_str(), data.size());
            }
        }

        std::string read(size_t numBytes) {
            std::string output;
            if (pid != -1) {
                char buffer[numBytes + 1];
                ssize_t bytesRead = ::read(pipefd[0], buffer, numBytes);
                if (bytesRead > 0) {
                    buffer[bytesRead] = '\0';
                    output = buffer;
                }
            }
            return output;
        }

        std::string readLine() {
            std::string output;
            if (pid != -1) {
                char buffer;
                ssize_t bytesRead;
                while ((bytesRead = ::read(pipefd[0], &buffer, 1)) > 0) {
                    output.push_back(buffer);
                    if (buffer == '\n') {
                        break;
                    }
                }
            }
            return output;
        }

    private:
        pid_t pid;
        int pipefd[2];
    };

    int main() {
        ChildProcess childProcess;
        std::vector<std::string> arguments = {"arg1", "arg2"};
        if (childProcess.create("child_process", arguments)) {
            childProcess.write("Hello, child process!");

            std::string output = childProcess.read(1024);
            std::cout << "Child process output: " << output << std::endl;

            std::string line = childProcess.readLine();
            std::cout << "Child process line: " << line << std::endl;
        }

        return 0;
    }
Re:GitHub Copilot Loses an Average of $20 per User per Month by pseudalopex on Tuesday October 10, 2023 @04:59PM (#37837370)
I got tired of it recommending imaginary libraries. Or saying real libraries couldn't do things they could.
Re:GitHub Copilot Loses an Average of $20 per User per Month by YeGoblynQueenne on Tuesday October 10, 2023 @01:58PM (#37835290)
>> For those of us used to the continual disappointment that pre-LLM AI was, the current crop of LLM's are amazing, mind blowing things.

Aren't you overgeneralising a bit? Not even I would say that CNNs for image classification, or Deep-RL for board game-playing are a "continual disappointment" and they certainly predate LLMs. Are you talking about NLP? Even Neural Turing Machines were quite capable in language pairs with large parallel corpora (and similar linguistic structure).

Basically, what do you mean by "continual disappointment"? What I'm aware of is an incessant hype crescendo that crashing over everything like a relentless wave.

Re:GitHub Copilot Loses an Average of $20 per User per Month by nvm0n2 on Tuesday October 10, 2023 @02:19PM (#37835547)
Pre-2022 most AI was disappointing not because it was unimpressive but because it near exclusively took the form of blog posts or university papers that announced something interesting but unusable. Either because it was merely an academic curiosity (AlphaGo) or because the tech wasn't being released for public usage at all, and wasn't really easy to replicate externally either, or because there was no obvious way to apply it to normal problems. So we all got used to this constant year-in-year-out stream of "amazing" "breakthroughs" that ended up being a thats-cool followed by a shrug.

RLHF trained GPT3 and then DALLE/Midjourney/Stable Diffusion changed all that. Suddenly AI not only got good, but the field broke loose of the inane and insane obsession with pseudo-safety that had been holding it back. Now the rest of us can use it without dropping $5M on a GPU cluster and hiring a dozen researchers first. AI is no longer a disappointment.

Re:GitHub Copilot Loses an Average of $20 per User per Month by bdavbdav on Tuesday October 10, 2023 @04:43PM (#37837218)
I’m not sure about this pre-LLM AI being disappointing take. What are we considering as AI? AI encompasses all manner of fields. The face detection in my iPhone, nest doorbell works fantastically. The DSG in my car learns how I shift, fraud detection in finance is heavily driven by ML and typically very effective. It may not be helpful to you, but product recommendations and targeted advertising are ML driven and incredibly effective. They may not be exciting uses, but they’re incredibly helpful.
Re:GitHub Copilot Loses an Average of $20 per User per Month by fennecfoxy on Wednesday October 11, 2023 @10:37AM (#37844965)
Eh I think people's expectations for things they don't understand are always overblown.

One thing I always find funny is the general expectation that machine learning models are both incredibly generalised and designed based on the way biological systems work, but should also be 100% perfect and never be wrong just like a machine and NOT like a biological system, those things are mutually exclusive; even the best, smartest most physically capable humans will still sometimes spill their coffee, yet we expect coffee-bot 2024 not to do this.

Certainly machines can be much better at a task than humans are, but if that tasks requires generalisation then it's still gonna fuck up from time to time.

Machine learning programs may think a dog is actually a cat sometimes, but afaik they ain't ever called their teacher "Mum" yet.