Why care about programming languages

But doesn't that sound like cope? It's like an old ASM programmer telling himself that his obscure assembly knowledge will surely still give him great advantages as he is forced to switch to React.js development.

- Simple robust syntax

> - One obvious way to do things

That always leads to more verbosity. Much syntactic sugar is a more specialized way to do a subset of a more general thing. Why have `a + b` when you could just write `a.add(b)`? Because it's easier to read. The general functionality needs to account for all cases, the specialized one can cut that down just the things that matter to a specific common use case.

- Static type checking

\Which one?\

That's a very, very deep can of worms. One could argue that of an LLM is generating the code, then the type system doesn't need to be understandable to humans, so throw in all the features you'd ever want and just have the LLM change the code if it's not valid. Unions of higher order generic functions, sure! Or one could argue that there should be minimal magic, because the LLM understands the language only by its source, so everything should be explicit. If the LLM can prove that something is sounds to the compiler, accept it. Give ways to give extra evidence of soundness, like declaring invariants and contacts.

- Purely functional encouraged, escape hatches for performance

"One obvious way to do things", except when you need two. Purely functional except when it matters.

Why doesn't performance always matter? (And how will an LLM know if it does?)

Being purely functional is nice for data, but not for data structures that are updated in place. If all you do is stream data from one DB query into another, then your mutable state is the database. Otherwise might as well accept that it's a multiparadigmatic language with both imperative, functional and OO features. Just like all the others.

- Inspect-able, testable, and reviewable in small pieces

Good modularity and abstraction. No global scope. Maybe something like dependency injection to decouple from dependencies? (That does not make code readable, though.)

- Something like formal predicates, preconditions, post-conditions, assertions, or effects typing

That! LLMs look at the source. The more explicit the source is, the less it has to infer from context or existing knowledge. If the LLM can create its own predicates, accepted by the static type/analysis system, to prove that it's code is sounds, that allows more flexibility than having to fit into any fixed type system. Do we want or need that flexibility? Maybe. Most LLM-generated code is directly inspired by existing idiomatic code in the same language. Some is translated from other languages, trying to match up idioms. Some is just blindly trying to make unit tests pass. We could end up with generated predicates tailored to specific unit tests, not the actual concept.

Natural languages are not logically sound, because meaning of words can shift. We need to express ideas about programs, desired properties, and specification in a language that is semantically sound and thus gives consistent solutions to consistent requirements.

Of course, the metalanguage can have the same foundation as the programming language itself. It could be expressed in Lean for instance.

What is needed is to build a library of abstractions in the metalanguage that are similar to words understood by an LLM, but in a logically consistent manner.

Everyone wants to build another iteration of a C style language with incremental improvement for little benefit.

The problem is that we probably reached the general purpose frontier a long time ago and there are just a few surface level things that need to be changed here and there, which is not worth a whole new language.

It goes against the programmer's ego, but the way forward is by adding more restrictions. The people complaining about the borrow checker in Rust just don't get it. If you want programming to improve, you will have to give up the ability to write every conceivable program.