With the introduction of debugging tools, software developers were empowered to interactively investigate the control flow of software programs to find bugs in live environments. At JetBrains, we've a
Out of curiosity, can anyone here think of a bug they’ve faced which would, identifiably, have been made easier by preemptively running source as it was written? This looks like it’s preemptive compiling, which isn’t just unwise, it’s potentially dangerous.
To be honest, I used to be a big fan of Eclipse and Jet Brains, but at this point I’ll just take Vim over either any day. It took a little time to get used to, but it saves me from the wait time of a load and doesn’t plaster my screen with highlighter and pop ups while I’m just trying to finish a module.
The code is already compiled. what do you mean it’s preemptively compiled? If you’re talking about executed, they explicitly called that out…
A prediction can also end at a function call the debugger is cautious about evaluating. That is for your own (or your software’s) well-being. Since code is executed during debugging, the debugger has to be sure that it’s not causing any mutations. When running the above example, we must confirm the evaluation of the int.TryParse method (more about that later):
As mentioned in the previous section, the predictive debugger won’t evaluate possibly impure functions to avoid side effects. As a human developer, you most certainly have more knowledge about the code, which is why we give you the possibility to forcefully evaluate a call by clicking the hint:
I mean that in running it, it is by basic definition compiling what it is running into machine language. So no, code is most certainly not already compiled into machine language as I’m writing or reviewing it.
By necessity, when you’re in the debugger your code has already been compiled either way, no? Or am I missing something here?
This isn’t executing your code as you’re writing it (though it does support Edit & Continue), this is preemptively executing the next lines in your code when you’re already paused in the debugger - which means it’s been compiled and already running.
you’re misunderstanding. this is a function of the debugger. Your code has already been compiled and is currently running if you are using this feature.
It’s not preemptively running source as it’s being written, it’s preemptively evaluating methods as you’re debugging it
This looks like it’s preemptive compiling, which isn’t just unwise, it’s potentially dangerous.
So I think what you might mean is preemptively evaluating methods at runtime? - which would be unwise / potentially dangerous - since it could cause side effect
For example, evaluating a method that increments something and modifies the state. So if it’s preemptively called by the debugger, the state would be modified, and the actual invocation would be different
I installed the Resharper RC, and this is how it looks like in a small project that parses an excel file: https://i.imgur.com/g4s0P3h.png
So, in the example my debugger is still on the allTheFieldsEmpty line and hasn’t ran it yet, but resharper already evaluated it to false. Then it also greyed out everything in the if(allTheFieldsEmpty) block, since it knows it wouldn’t hit that
The next line you can see there was a warning, “Possible impure evaluation” - which is that I assume you were talking about, and it didn’t evaluate that yet. I can click the box and make it evaluation it.
The debugger inspects the method, as the article mentions, it check for the PureAttribute - indicating that it’s safe to use
After I marked that GetMappingField method as Pure, it actually did evaluate it without any interaction, and it predicted it would throw an exception https://i.imgur.com/zQ0K3Ge.png - seems pretty useful so far
I don’t think this will necessarily help solve issues you wouldn’t be able to solve without this, though I used similar tools in the past (Ozcode) and it did make debugging easier / faster
Out of curiosity, can anyone here think of a bug they’ve faced which would, identifiably, have been made easier by preemptively running source as it was written? This looks like it’s preemptive compiling, which isn’t just unwise, it’s potentially dangerous.
To be honest, I used to be a big fan of Eclipse and Jet Brains, but at this point I’ll just take Vim over either any day. It took a little time to get used to, but it saves me from the wait time of a load and doesn’t plaster my screen with highlighter and pop ups while I’m just trying to finish a module.
The code is already compiled. what do you mean it’s preemptively compiled? If you’re talking about executed, they explicitly called that out…
I mean that in running it, it is by basic definition compiling what it is running into machine language. So no, code is most certainly not already compiled into machine language as I’m writing or reviewing it.
You question doesn’t make much sense to me.
By necessity, when you’re in the debugger your code has already been compiled either way, no? Or am I missing something here?
This isn’t executing your code as you’re writing it (though it does support Edit & Continue), this is preemptively executing the next lines in your code when you’re already paused in the debugger - which means it’s been compiled and already running.
you’re misunderstanding. this is a function of the debugger. Your code has already been compiled and is currently running if you are using this feature.
Ah, you’re right, that does make more sense. So this runs while the program is in debug mode.
That relieves me a bit. I just feel like a lot of these new IDE features are things that no one specifically asked for.
It’s not preemptively running source as it’s being written, it’s preemptively evaluating methods as you’re debugging it
So I think what you might mean is preemptively evaluating methods at runtime? - which would be unwise / potentially dangerous - since it could cause side effect
For example, evaluating a method that increments something and modifies the state. So if it’s preemptively called by the debugger, the state would be modified, and the actual invocation would be different
I installed the Resharper RC, and this is how it looks like in a small project that parses an excel file: https://i.imgur.com/g4s0P3h.png
So, in the example my debugger is still on the
allTheFieldsEmptyline and hasn’t ran it yet, but resharper already evaluated it to false. Then it also greyed out everything in theif(allTheFieldsEmpty)block, since it knows it wouldn’t hit thatThe next line you can see there was a warning, “Possible impure evaluation” - which is that I assume you were talking about, and it didn’t evaluate that yet. I can click the box and make it evaluation it.
The debugger inspects the method, as the article mentions, it check for the PureAttribute - indicating that it’s safe to use
After I marked that
GetMappingFieldmethod as Pure, it actually did evaluate it without any interaction, and it predicted it would throw an exception https://i.imgur.com/zQ0K3Ge.png - seems pretty useful so farDon’t get me wrong, I hope this works out, but I still think it’s trusting far too many decisions to the IDE. It feels like feature bloat.
Which, is why I’m asking if anyone has had an issue which this would legitimately have helped solve.
I don’t think this will necessarily help solve issues you wouldn’t be able to solve without this, though I used similar tools in the past (Ozcode) and it did make debugging easier / faster