Let's examine exactly what you said from the beginning so that we can put the goal post back from where you moved it with this ridiculous paragraph: > Just to

Let's examine exactly what you said from the beginning so that we can put the goal post back from where you moved it with this ridiculous paragraph: > Just to underscore the source of conflict here: you don't seem to understand that hot code reloading (especially hot code reloading with "no stop-and-recompile"—a constraint that was explicitly mentioned not once, but twice in my original comment) is a far more general subject than hot module reloading, which is what you're describing. ... > In other words, rather than having a graphical interface for tweaking values at runtime, you interface with it the same way you normally would—by changing the constants in the original source file, but the difference between the ordinary stop-and-recompile way of doing it is that the changes get picked up live, so there is no stop-and-recompile. You've had it explained to you that "stop-and-recompile" isn't even a factor because you can pick up these changes live regardless and you've been shown how. > Let's ignore the overhead of having to refactor your code for a quasi-plugin architecture in the first place. You keep pushing this idea that this is somehow difficult and takes a ton of time. It's not and it doesn't. How am I supposed to assume you're competent and knowledgeable when what you write says you're not and you aren't? > How do you reload a shared library using dlopen after changing a source file without recompiling it? You recompile it because recompiling it and reloading the code isn't an issue. > The wounded tone suggests that you're reading way too much out of the (true, and what should be totally uncontroversial) statement that, in order for edit-and-continue to work when debugging an arbitrary program they're working on, "the conventional static languages folks have generally needed to rely on support in sophisticated IDEs". This was not a challenge in a static-vs-dynamic (or PL-vs-PL) holy war, and your taking it as such has you behaving with insolent irrationality. This word salad suggests that you're butthurt about having your programming chops challenged when you make bullshit statements about reloading code. I'm sorry, but I'm well and truly done with this. You say to assume competence and stuff but you seem to not understand at all that the things you're saying go against that entirely. You've now sort-of redefined what the original problem was to make it seem like hot-reloading shared libraries doesn't solve it. Honestly, just learn to not make these silly statements from the beginning instead when you're out of your element.