🤔 last generation of programming languages

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)
    - code generation / meta-programming of boilerplate

2023-11-17

#artificial-intelligence #programming