Here are some things that I've done/found out manually that I want my IDE to do for me:
1. General inter-procedural analysis queries: - Does anyone pass in null? - Is X set in each path that can be taken? - Take a theory, for example numerical ranges, what can you tell me about this function? - Is this probably a hot function? - Are any of these sum type ctrs unused?
2. Show me counter-examples of things I believe about the code, don't force me to find them myself.
3. Predictable, but non-standard (not pre-rolled by IDE), refactoring. I had to grep and do an Emacs macro that went through the list of matches, one execution at a time. Why can't the IDE record my actions, show me the AST transformation that I did, and let me apply them for some qualifying criteria across the whole codebase?
4. Let me apply semantically equivalent code refactorings within a function by picking cost-based heuristics. For example, "flatten indentation levels".
5. Do coarse-grained semantic analysis for me, "are these the same on a type-level? OK, now apply this theory, still the same? Aah, I'm about to go for lunch, just run the whole analysis".
6. Let me save any thing I've done, so that I can use it in the future
Something like that, that'd be great. I have 128GB of RAM and like 64 CPU cores and I'm using my brain on this 1M+LoC codebase while they sit idle. Lazy bums, I tell ya!
Is that what you really want or is that a tradeoff point short of ideal that you’ve selected as acceptable?
To put it more concretely, if you could have alive programs and alive tools, would that not be the pinnacle? Well categorically yes because an alive program has every capability a dead one has, including the ability to mimic “dead” one.
The problem as we all know is it appears to be impossible to write maximally alive tooling in the presence of alive programs because there’s no way to analyse them sufficiently with the compute available to us.
And so we select a trade off.
Aiming for the tradeoff point as the ultimate solution does us all a disservice though. We should call out that it’s a trade off (and a reasonable one at that) but what we really want is alive/alive!
No, they do not. What they are lacking isn't in what they can or cannot execute, it's what we can say about them. If your PL has eval, then you don't know if foo is ever called or not, for example.
I'm not interested in talking about the currently running instance of a program, but all possible running instances of it.