The biggest unsolved issue in programming language design is a social one:
How to stop “well-intentioned” people from suggesting/demanding/adding features until the language collapses under its own complexity.
For this reason, I believe it is unlikely that there will be any lasting progress in language design within my lifetime.
Clojure does this well. Want something added? Make it a library. No adding operators to the core language or changing syntaxes.
This is related to https://erikbern.com/2016/12/05/the-half-life-of-code.html because clojure more looks like each year adds a thin layer of bedrock
Remove the social element and have a benevolent dictator?
Jonathan Blow’s Jai language looks interesting and takes such an approach. (Now if only he’d release a publicly available beta)
Elm’s Evan (I think that’s his name) is another language dictator. I think Elm is quite a nice language, and is extremely simple. A lot of thought goes into each new feature of the language. However, people have voiced concerns with Evan’s leadership; I don’t quite know enough about that.
That may help for your personal project, but doesn’t stop the decay of languages (that many people depend on) out there.
E. g. if the reaction to not wanting another feature is basically HOW DARE YOU, EXPLAIN YOURSELF then there is no chance of ever getting language growth under control.
The bit about GOTO is literally the last thing mentioned in the transcript, and that’s all it is—mentioned as being “great” without going into any real detail. Personally, I think it sounds horrible, but since it’s not described much past the concept, I can’t say for sure.
They are referring to Algebraic Effects, which are something like goto or call/cc and are getting a lot of attention on the PL community atm.
Isn’t this what call/cc is for?
I think the problem with call/cc is that it’s a powerful side effect, but doesn’t give you a way to sandbox that power. Sometimes you want to call some code without giving it permission to grab your continuation. For example, if you have a Scheme REPL written in Scheme, when you (eval user-expression) you might want a guarantee that it only returns once.
So there’s a variant called composable continuations, or shift/reset. shift grabs the continuation, like call/cc, and reset puts a boundary on the stack that prevents shift from grabbing any frames beyond the boundary. It seems similar to how catch lets you sandbox throw. (You could look at An argument against call/cc and the discussion on Lambda the Ultimate for more.)
I think algebraic effects are a bit like shift/reset. Or a bit like resumable exceptions. If you call some code that tries to write to a file, you can intercept the write, handle it however you like, then resume.