Hacker News Reader

Comment by jlarocco | Hacker News Reader

Not surprising given the discussion I've seen about these AIs on HN and other sites.

AFAICT, they're generally treated as a shortcut to avoid learning an API or library, or as a shortcut to avoid boilerplate by essentially copying somebody else's boilerplate.

Both cases boil down to using other people's code for purposes that it wasn't built for, which is obviously going to be error prone.

The AI has no idea how this particular case differs from the sample code it was trained on, so it's up to the developer to go back and correct the details - which is precisely what they were trying to avoid with the AI. It's basically a fancy version of code "templates" available in some IDEs, but fewer people know to go back and fill in the correct details.

View on HN

> The AI has no idea how this particular case differs from the sample code it was trained on

It can eventually figure a lot of things out if you provide the correct requirements and examples. However, the caveat with all of this is that you already have to be a good programmer to:

- know what is needed

- know what the solution should more or less look like

- spot bugs in the AI's solution

- describe the problem, examples etc in a way that the AI can work with

If you're already a good programmer, the time spent wrangling the AI could be spent writing the solution yourself.

My feeling is that the most value from AIs will come from when you get hopelessly stuck on a problem. An AI could provide some initial steps or ideas that can get you unstuck, effectively working as a rubber ducky. You're unlikely to copy the AI's solution, but it could provide some random insight that helps you take a step forward.

> My feeling is that the most value from AIs will come from when you get hopelessly stuck on a problem.

This sounds about right.

It may also help you to find related areas to study. I was throwing rocket optimization problems at ChatGPT and it was horrible, but I think it was finding some related code from vehicle navigation optimization problems which I found interesting.

It does reasonably well at simple kinds of symbol manipulation and might be able to replace matlab/mathematica at some point, but the problem is that you always have to double-check the results. I'm not sure it is really that much better than just knowing your way around wikipedia (which has its own accuracy issues, but for straightforward things it is usually pretty good).

I hadn't considered the "hopelessly stuck" aspect, and that does seem promising.

I fully agree on your other points, though. Communicating the requirements to the AI in a non-ambiguous way is more-or-less equivalent to just writing the code. I can't even get firm requirements from my coworkers, and we all presumably have "real" intelligence.

TL;DR - Models can learn from massive validation, not just massive text prediction.

I agree our current crop of Copilot, GPT-3 and chatGPT can introduce subtle bugs, and that's a big problem. Checking for such bugs takes time. They code like someone who read a lot and has good memory, but never implemented anything complex.

But there is no reason to be the same in the next iteration. Language models can be fine-tuned on code execution, that means giving sufficient exposure to trial and error to learn how to avoid such bugs.

Having a way to test its outputs is the key to self improvement. It works the same with AlphaGo - the model is generating its own training data, and this process can eventually surpass human level. It just needs tons of compute to iron out a lot of bad ideas.

Alternatively, the model could use a code execution environment at runtime, too. So it could iterate a few times on an error, eventually using web search if it cannot solve it alone, instead of simply failing and leaving it to the human to fix. It is pretty good at proposing fixes and will recover most of the times, like human devs.

I'm leaving this for further reading. It's fascinating.

> Evolution through Large Models

> Large language models (LLMs) trained to generate code can vastly improve the effectiveness of mutation operators applied to programs in genetic programming.

https://arxiv.org/abs/2206.08896

The paper is from OpenAI, Ken Stanley who works on opendedness is the last author.

Reply on news.ycombinator.com