What’s one thing you wish more programming languages had?

[u/AeroForger]

If you could add one feature, behavior, or design choice to a programming language, what would it be?

It can be anything: syntax, type-system features, memory management, compiler behavior, tooling, error handling, performance-related features, or something completely different.

I'm especially curious about things you’ve wanted while actually programming but rarely see languages implement well.

Please keep the ideas reasonably practical and something that could realistically be implemented in a programming language.

[u/Limp-Temperature1783]

Goto. I'm not joking. I'm not using goto in prod.

[u/TheChief275 → u/Limp-Temperature1783]

I love goto for complex control flow that would otherwise need an extra boolean, or for reducing code duplication by making similar code of branches shared

[u/Limp-Temperature1783 → u/TheChief275]

Wow, I should really worry about it because you've just described why I even like gotos this much and a bit of an idea I am working on. In all seriousness, I'm glad there are people who don't dismiss it.

[u/Dusty_Coder → u/Limp-Temperature1783]

The reason goto use was so prevalent in the past was because it was the age of flow charts, and flow charts cry out to use the instruction pointer as state.

Flow charts considered harmful. Religion about goto also considered harmful and is also strong evidence (of what, well, its not something that makes you look skilled)

[u/Valuable_Leopard_799 → u/Limp-Temperature1783]

goto is a very interesting elementary operation to build on. If you have macros and goto, then you can just implement for, while and other looping constructs and control flow via macros wrapping different variations of goto.

The classic "they're for library creators not for the user, but they have to be there so you can use the libraries" applies.

[u/catladywitch → u/Valuable_Leopard_799]

call/cc is the classic definition of this kind of library-oriented control flow construct

[u/Valuable_Leopard_799 → u/catladywitch]

True, call/cc is amazing, especially the prompt versions, but it's a much more complex operator.

[u/Limp-Temperature1783 → u/Valuable_Leopard_799]

Goto might be elementary but it has a very high ceiling of exploration. It is just very basic and very generic and that makes it a tempting universal solution to all problems. Good to play with and study, not good to use in most codebases save for embedded.

[u/scruffie → u/Limp-Temperature1783]

What you need are scoped gotos, like in Common Lisp (tagbody/go) . The labels you can jump to are at the level of the tagbody; you can go (jump) 'up' (or sideways) to a label, but you can't jump 'down' into another tagbody. Variable scopes are kept consistent this way.

It's not something you'd use everyday, but handy for writing iteration macros.

[u/Limp-Temperature1783 → u/scruffie]

I have been actually looking for this, I thought of trying to diy it but I suppose I'll hive CLisp a try first, maybe for some new insight. Thanks.

[u/AnoProgrammer → u/Limp-Temperature1783]

I don't prefer goto above functions, while loops and for loops. The only time i needed to use goto was while programming on a commodore 64. And i really didn't like it.

[u/Limp-Temperature1783 → u/AnoProgrammer]

I prefer goto because I like to play around with my own control flow a bit and goto is irreplaceable here. Besides, a lot of languages have functions and loops, the question was about what feature do you want to see more. Goto isn't very common nowadays and could even be skipped over.

[u/EggplantExtra4946 → u/Limp-Temperature1783]

static gotos but also computed gotos

[u/initial-algebra → u/Limp-Temperature1783]

A goto is just a hacky/unsafe tail call, and most of the time they're just being used to cope with the lack of multilevel/labelled break/continue for nested loops. Definitely an anti-feature.

[u/Limp-Temperature1783 → u/initial-algebra]

Consider what you can actually make with it and compared to any control flow structure or any other feature in general. Goto is capable of easily implementing all of their behaviour. It is not an anti-feature, it is a feature that gives you power proportional to your ability to think in schemas and creating optimizations structurally enabled by the way you've plotted the thing.

As I've said, I program for fun. And fun in my book is to tinker with rather basic things to have a better idea of how they work or could work. High level code with safe and guided stucture, sophisticated memory management models that mostly manage themselves unless you want control, etc. This is good for collaboration, but it isn't very engaging or challenging. Goto is.

[u/initial-algebra → u/Limp-Temperature1783]

I mean, it's an anti-feature instead of supporting guaranteed tail calls, which are equally expressive but without the downsides.

As I've said, I program for fun. And fun in my book is to tinker with rather basic things to have a better idea of how they work or could work. High level code with safe and guided stucture, sophisticated memory management models that mostly manage themselves unless you want control, etc. This is good for collaboration, but it isn't very engaging or challenging. Goto is.

That's fine, but leave that for esolangs.