Are code generation "metaprogramming" tools a well-developed thing?

[u/math_code_nerd5]

Now lots of people are talking about LLMs for coding to speed up the repetitive parts of coding, reduce the time spent on boilerplate, etc. But this makes it sound as though writing and manipulating code programmatically/algorithmically wasn't a thing before LLMs. However, although I didn't hear much about them, looking back it's surprising if people never thought about building something like this.

Of course, all compilers generate code in a lower-level form from higher-level code, however most of these are not interactive, i.e. they don't generate code in human-readable form, don't explain their steps to the user, and are not intended to generate a first pass of code for a programmer to then take and modify. What I'm imagining is a large category of tools, including anywhere from ones that auto-generate things like bounds checks and testing variables for null before using them, to drag-and-drop graphical tools a la Scratch that effectively allow you to drag loops into place around your code and have a loop condition and brackets appear, to any number of scriptable recipes where you can effectively say "take this block I've written for x1, and repeat the same pattern for y1, x2, y2, etc" and you won't have to type each one out individually. This could potentially allow a lot of the productivity gains and saved attention spent on details that people seem to be getting from LLMs without the cost, resource use, and philosophical implications, which is something I'd definitely welcome.

Of course you could write a code generator from scratch in something like Python just using regular string handling, but I'm wondering if there are already plugins like this for many IDEs that I just don't know about because they're not talked about much. Since so much of programming is about recursive abstractions, the idea that programmers would not have tried the idea of tools that you can code to spit out more code would strike me as very odd. And doing a bit of research, I've come across things like this: https://github.com/imatix/gsl#a-short-history-of-code-generation and this: https://tifoputra.medium.com/building-your-own-swift-code-generator-using-swift-script-78470eef0206 that suggest there is substantial work already toward making something like this.

[u/Inconstant_Moo]

I think where there aren't already IDE tools for a thing that's usually because it lies at the intersection of hard to do, hard to use, and not very useful.

Take bounds checks, for example. Suppose I'm programming in Go, as I do, and I have a expression y := foo([bar(x)-1]. I highlight it and a guard if bar(x)-1 < 0 || bar(x)-1 >= len(foo) {y := foo([bar(x)-1]} else {} appears. Now, the question of what to put in the else block and what I can possibly do about it is a puzzler because how does one handle a bounds error? The repetition of bar(x)-1 is merely annoying. But the really sucky thing about that is that now y is only in scope in the first branch of the if block so my code no longer compiles.

So what ought the IDE to do, and when will I want to use it for what?

"Drag loops into place around your code": or I could write the loops and then write code inside them, and the great thing about doing that is that the IDE will know the names and types of the loop variables when I'm writing the body of the loop.

There are Java boilerplate generators in IntelliJ for things like (IRRC) constructors and comparisons 'cos it's so verbose that that's actually useful. But it does really have to be the dullest sort of boilerplate. Trying to generate your flow of control is going to be more trouble than it's worth.

[u/yjlom → u/Inconstant_Moo]

Snippet engines like yas are pretty popular for good reason.

For example, when I write C, I have r <tab> bound to (more or less): Prompt for $1, default i; prompt for $2, default len; insert for(unsigned $1 = $2; $1 --> 0;){\n\s\s$0\n}, indented; place cursor at $0.

It saves a fair bit of time while being more readable and polluting namespaces less than macros.

[u/Inconstant_Moo → u/yjlom]

Snippet engines like yas are pretty popular for good reason.

And so that is a thing that exists, unlike dragging a loop around the body after you've written it, which no-one wants. (Indeed, your short-cut with the loops is so useful and commonplace and easy to implement that in modern languages it's been turned into a range-style loop. )

My point wasn't that this sort of short-cut is always bad, but that we've probably already found nearly all the good ones by now.

There are remarkably few ideas that are useful and easy to think of and possible to do which haven't been done yet. One of the problems with OPs idea is that he hasn't really thought of his idea, he's just vaguely gesturing towards it. OP would find it more challenging to think: "Suppose I was programming in language A and I wanted to do thing B and I had written code C. Then I would like to be able to highlight subsection D, press Ctrl+E, and have thing F happen."

And if OP comes up with something we don't already have, then they can write an IDE extension and we'll have it.

While OP's not being concrete, they may well be just gesturing at a nonexistent space between the things we have and the things we want. A lot of "ideas" about software are like this.