How many of us remember that at the beginning of last year the fear was that programming by programmers will get obsolete by 2024 and LLMs will be doing all the job?
How much has changed?
How much has changed?
What has happened is GPT-4 came out (which is certainly better in some domains but not everywhere), but mainly the models have become much cheaper and slightly easier to run, and people are pairing LLMs with other things rather than using them as a single solution for all possible tasks — which they probably could do in principle if scaled up sufficiently, but there may well not be enough training data and there certainly aren't computers with enough RAM.
And, like with the self-driving cars, we've learned a lot of surprising failure modes.
(As I'm currently job-hunting, I hope what I wrote here is true and not just… is "copium" the appropriate neologism?)
> I regret to say it, but it's true: most of today's programming consists of regurgitating the same things in slightly different forms. High levels of reasoning are not required. LLMs are quite good at doing this, although they remain strongly limited by the maximum size of their context. This should really make programmers think. Is it worth writing programs of this kind? Sure, you get paid, and quite handsomely, but if an LLM can do part of it, maybe it's not the best place to be in five or ten years.
I wonder how different this would be if software was not hindered by "intellectual property" laws.
As for demand, that's difficult to predict. I'd argue a lot of software being written today doesn't really need to be written. Lots of weird ideas were being tried because the money was there, pursuing ever new hypes, with an entire sub industry building ever more specialised tools fueling all this. And with all that growth, ever more programmers have been thrown at dysfunctional organisations to get a little more work done. My gut tells me that we'll see less of that in the next years, but I feel even less competent to predict where the market will go than where the tech will go.
So long story short, I guess we'll still need programmers until there's a major leap towards GAI, but less than today.
This is the holy grail of low-code products.
See all the SaaS products, without any access to their implementation, programable via graphical tooling, or orchestrated via Web API integration tools, e.g. Boomi.
Where does the trust in a binary spit out by an LLM come from? The binary is likely unique and therefore your trust can't be based on other users' experience, there likely isn't any financial incentive or risk on the part of the LLM should the binary have bugs or vulnerabilities, and you can't audit it if you wanted to.
QA, acceptance testing whatever, no different from buying closed source software.
Only those that never observed the replacement of factory workers by complete robot based chains can think this will never happen to them.
Here is a taste of the future,
https://www.microsoft.com/en-us/power-platform/products/powe...
An assembly line robot is programmed with a very specific repeatable task that can easily be quality tested to ensure that there aren't manufacturing defects. An LLM generating binaries is doing this one off, meaning it isn't repeatable, and the logic of the binary isn't human auditable meaning we have to trust that it does what was asked of it and nothing more.
There are ACM papers about it.
It didn't hold on.
Do you really inspect the machine code generated by your AOT or JIT compilers, in every single execution of the compiler?
Do you manually inspect every single binary installed into the computer?
Would you trust a compiler's byte code if it spit out slightly different instructions every time you gave it the same input? Would you feel confident in the reliability and performance of the output? How can you meaningfully debug or performance profile your program when you don't know what the LLM did and can't reproduce the issue locally short of running the exact copy of the deployed binary?
Comparing compilers and LLMs really is apples and oranges. That doesn't mean LLMs aren't sometimes helpful or that they should never be used in any situation, but LLM fundamentally are a bad fit for the requirements of a compiler.
Instead of warm bodies somewhere on the other side of the planet, it is a LLM.
It's just a scam to keep you scared and stop you from empathizing with your fellow workers.
This is what happened to America's manufacturing industry. Shouldn't emphasizing with fellow workers mean recognizing the pattern instead of dismissing it as FUD?
I am quite unconvinced this is the reason. Seems rather conspiratorial.