LLMs are likely to entrench existing popular languages, because:
LLMs have better results with more data
popular languages, with the most data, are likely to reap the most benefit from LLMs, making them more popular
but, perhaps a sufficiently trained LLM, will "discover" an underlying universal model (like human language translation models), thus increasing the quality of niche language code generation with more data from popular languages
this is probably already happening in existing LLMs
likely to help with superficial syntactical differences, but unlikely to help with languages that have dramatically different "operating models" / paradigms
ie. easy transfer between, say, C++, Java, Javascript, Python
ie. difficult transfer between Python (procedural / OOP), Clojure (LISP + functional), Prolog (logic), Forth (stack)
(as with human developers)
a limiting factor to LLMs improvement may be that, as LLM code generation increases, the code training dataset becomes overwhelmed by LLM generated code, not human generated code
human code ~= "low background steel" (https://en.wikipedia.org/wiki/Low-background_steel)
but, this may take a while, because in the interim, the "editorial" input of humans is still there (ie. humans are still in the coding loop, and are accepting/modifying LLM code output), and in effect, human developers are gatekeeping "good enough code" and increasing samples of it in the wild
long term, use of LLMs will likely lead to a more verbose, but machine friendly style of writing
boilerplate and excessive structure is a already "optimal" in programming environments with a lot of churn, giant codebases, and average developers (ex. enterprise and Java enterprise coding style)
LLMs like boilerplate, b/c it provides more training context
use of LLMs to generate boilerplate is effective low hanging fruit
they can do it quite well (accurately, faster than humans)
it speeds up something developers "dislike"
LLMs being to learn from their own code (as mentioned above)
typed languages particularly likely to benefit from LLMs
because...
types are more boilerplate
types provide automated checks, so an LLM code generator could be wired to re-run automatically upon type failures
personally, the above predictions "sadden" me
I like Clojure and Clojure coding philosophy, because it offers an alternative to boilerplate
little of the code I write I feel is boilerplate
and if I do find I am writing boilerplate, I tend to eliminate it from my projects
through abstraction or declarative programming / code generation / meta-programming
ie. I find I am either writing:
core business / domain logic unique to my system ("domain modeling")
novel and somewhat complex algorithms to solve a niche problem
abstractions (rare, because clojure + java + clojure libs have so many very good ones)