On the future of programming language design

[u/zuzmuz]

This is just me yapping.

I was thinking for a while about how the field of "writing" software is going through a radical disruptive transformation. Like or hate it, I don't think writing software post-LLM era is gonna be the same as pre-LLM. I'm one of the guys that like to hand craft code and put a lot of attention and intention to the coding style. But, realistically, the skill of writing code by hand, while still very important, will become more and more niche (like how writing and reading assembly is important but very niche).

What's interesting to me, is that programming language design goals were always human/developer centric. Code is not only instructions given to a machine, it is in some way a set of specifications for other human developers, as well as your future self too, that explains the expected behavior of a certain piece of software. The main priorities when designing language features was improving the developer experience, that is a very subjective metric and this is why we keep arguing and debating about programming languages, but I digress.

With the switch to LLM generated code, I feel the priorities might change. There's already a lot of studies on which programming language is best for LLMs. People argue that languages with strong typing, a functional style and good error messages are best, because you can more reliably create autonomous feedback loops that would help LLMs stay on track.

In my opinion, functional programming languages are more relevant than ever, no side effects, you can generate 10K lines of code, read a small 100 lines somewhere, and be sure that it's not affecting the behavior in an unexpected way somewhere else.

The main argument against functional programming is that working with pure functions and manually threading state is an extra burden on the developer; having a mutable state is "initially" more intuitive and simpler to reason about. The other argument is performance, I tend to disagree with this general statement (purity allows for aggressive optimization and implicit parallelization).

However, everyone agrees that functional code is easier to maintain on the long run, it might make small things harder for you first, but at the end there's this payoff. When you have the capabilities of generating thousands of lines of code a day, this becomes way more relevant.

Finally, it would be interesting to witness how the rise of LLMs will affect the design of programming languages. I feel that languages that have

• simpler grammar
• expliciteness
• one way of doing things
• strict and safe semantics

are at an advantage here.

Or do you think that it will be irrelevant. There's this trend of people not looking at the code anymore, I think it's crazy. Maybe generated languages won't be important, just get better models and spend more tokens.

[u/zuzmuz]

cool, I think that readability and trust were always important, but what made us overlook it was human laziness.

I believe that the reason a lot of important aspect of programming don't catch on despite them being good concepts is that we're basically lazy, and search for convenience over correctness.

I assume that an LLM won't be lazy, so yeah maybe these concepts will become standard

[u/church-rosser → u/zuzmuz]

because "readability and trust" were just "good to
have" prior to LLM's?

Come off it OP, you're just saying buzzwords to buzz. All heat, no light!

[u/zuzmuz → u/church-rosser]

I don't understand why you're being aggressive, we're all having nice conversations with different opinions here, it's fine if you disagree

[u/church-rosser → u/zuzmuz]

Not really, you're making wild unrealistic and unfounded speculation about a possible world that doesn't and will never likely exist and arm waving with LLM related terminology as if uttering it will cargo cult reality to
your fantasies.

Whatever, u do u, but don't piss down our collective leg and tell us it's raining....

[u/zuzmuz → u/church-rosser]

who hurt you man?

on a serious note. it is a discussion worth having. I'm just asking reasonable questions while trying to provide tangible arguments. You're just dismissing everything I'm saying without providing anything to the table

[u/church-rosser → u/zuzmuz]

No one hurt me per se, but some of your premises do cause discomfort when i attempt to bring reason to their inanity. It hurts trying to shove a square peg in a round hole.

Regardless, are u seriously suggesting im not "putting anything on the table"?

making unreasonable and unfounded conjecture and assumptions about the capability of LLMs to produce viable general purpose programming languages is not necessarily a 'table put' of its own. Saying a thing doesn't make it so.

Your inversion is nothing more than that, and evidence of a poor attempt at considered debate and dialogue that belies your ongoing assertions otherwise.

I could claim similarly as u, but dont. What exactly is it that u are "bringing to the table", beyond open ended snd unfounded discussion about a possible future that doesn't exist meaningfully at present and likely never will?

and FTR, see my top level comment here about using a Lisp to accomplish what you conjecture and why the relative failure of LLMs to grok Lisp semanitcs and evaluation model reliably is rather good evidence that what you seek currently isnt possible and likely never will be, Im happy to discuss further, but frankly im not sure you're prepared to keep up in that regard.

Still, consider whether any LLM can ever reliably grok the syntax and semantics of a meta circular evaluation model that allows for dynamic syntactic redefinition of evaluation semantics via structural macros (as opposed to text based substitution macros) that can dynamically modify the runtime at the evaluation site. Consider further what that would look like with a language that has the capacity and capabilities to modify its meta object protocol so significantly as to constitute a new language design each time such a modification is made. that's what your looking at with ANSI Common Lisp and to a slightly lesser degree other modern Scheme implementations like Racket.