Automatic disabling of cells to resolve multiple defs

[yha]

In the most recent version of Pluto, re-defining a new cell automatically disables the old cell which defined that variable (#2273).
I find this choice pretty odd. For me, automatically disabling the new cell would be an awesome feature. Disabling the old one just seems pointless: I fail to see how it can be useful.

The main annoyances with accidentally re-defining a variable and creating a conflict are:

• possibly triggering a big update to the notebook by disabling all cells dependent on the old cell
• possibly losing the result of a long-running computation that would need to be repeated when the conflict is resolved

Neither of these is solved by disabling the old cell.
Disable the new cell instead would solve both these issues, and would make conflict a lot less disruptive. I would almost always want to correct the new cell rather than the old anyway.

What was the rationale behind disabling the old cell? Can we disable the new one instead?

[disberd]

@fonsp After reading the points raised by @yha I admit I agree with him, putting some sort of confirmation action on the new cell re-defining the variable before triggering a disabling of the old cell seems to allow you to prevent potentially very expensive effects of the disabling.
You do get more effort if your use case it's simply just redefining stuff and you don't care anymore about the previous set of computations with the old value of the variable, but you avoid the potential side-effects of long recomputations.

It's true that the current situation with respect to the 2 points of @yha is probably similar to what we had before, as redefinition errors were thrown on both cells (if I remember correctly) so the re-computation would be triggered anyhow.

[yha]

Having used the new version with #2273 for a bit, I can say that I find it pretty annoying: I accidentally redefine the same name which creates errors in some other cells, which I may or may not immediately notice (the notification is usually invisible due to #2401, since the redefinition creates some error stacktraces causing the view to scroll). I later fix the problem, but it's still not fixed because the old cell is still disabled. I need to locate it and re-enable it (also, the intuitive way of trying to do that by re-running the cell doesn't work. The way to actually do it may not be apparent to someone new to Pluto).
I would be better once #2401 is fixed, but I think reverting #2273 would be even better.
Ideally, I think redefining an existing variable should be behave as an error, and the new cell shouldn't run. Similar to what currently happens when a cell contains multiple statements, there should be an error message like this:

Cannot re-define variable x which is defined in another cell [link]
You may fix this by:
Renaming x in this cell [maybe with a link to the specific code line in the cell]
Renaming x in the other cell [link]
Disabling [clickable] the other cell

[unnamedunknownusername]

I just wanted to second these thoughts/add another user experience to this thread

In long notebooks (particularly exploratory ones) I often, by mistake, use variables names I have defined above, and the old way was better at handling this use case. Because now I just define the new variable it "overwrites" the old one and now some other bit of code (that depended on the old variable errors/doesn't work, because for example the new variable is being used.

It is also sometimes hard to find the old variable/cell that was just disabled because the small message box with the link shown below

only appears when the variable is initially create. If one is working quite fast or experimenting/prototyping as many beginners are - then one might not notice the hint box appear and then after clicking somewhere else and it disappears, wonder why the code that depended on the old variable isn't working now. Or even worse still, wonder why the disabled cell is disabled.

It was very nice to get an explicit message and decide "in that moment" what to do. Either rename the new variable or disable the old one.
Similar to this suggestion:

Cannot re-define variable x which is defined in another cell [link]
You may fix this by:
Renaming x in this cell [maybe with a link to the specific code line in the cell]
Renaming x in the other cell [link]
Disabling [clickable] the other cell

There are drawbacks as mentioned

You do get more effort if your use case it's simply just redefining stuff and you don't care anymore about the previous set of computations with the old value of the variable, but you avoid the potential side-effects of long recomputations.

But overall I think the benefit of not redo-ing computations and explicitness is better and actually more beneficial in an ad-hoc exploratory setting/ helping novices understand what is happening.

I also understand that there may be reasons that this was decided that I am not aware of. I just wanted to share my use-case

P.S. also wanted to send through some love and thanks for all the hard work done by the Pluto team. Pluto rocks! :)

[fonsp]

We want to implement #1859 to improve this, and maybe more in the future.

PS in the future, try to think about the phrasing of your posts on OSS communities: calling our work useless, then a feature request with "why not?" is not a nice start of a conversation.