Delay running the notebook when it starts

[ndgnuh]

Hi, thanks for the super awesome package. This is just some suggestion. Sometime I want to edit something before running all the cell, and there will be a very time-taking cell at the end. But stopping after the cell run is not very responsive and might kill the worker. I know I can edit the jl file before running Pluto but it's not very convenient. Also, with delayed run, a run all (*, above, below) button would be nice. :)

[fonsp]

I wrote a bit about it here - it is also a good idea to do this by default for notebooks that were written by someone else.

[j-fu]

In a similar spirit I would like to have this option for running cells one-by one after loading when teaching based on a-priori prepared notebooks.
Another thing nice to have in this context would be the option to hide all source code of markdown cells at once.
Together this would provide an experience similar to that of Jupyter when loading a fresh notebook.

[fonsp]

About automatically hiding markdown: I don't this is necessary when you write your notebooks inside Pluto, but in your case (#132 (comment)), it can be done as part of the export process (the fold info is stored in the file):

c = Pluto.Cell("123")
c.folded = true
# save the notebook

Running cells one by one used to be the default (before d201517), but there were too many problems with this that we could not fix with friendly UI - the issue is that you launch your notebook into a broken state by default - running a cell might error depending on which cells you manually ran before. It had a lot of the same state problems as Jupyter that reactivity should solve. (The goal is not to make 'Jupyter++', but to try something else.)

But if you just want the 'reveal' effect, then you can add a ; at the end, and delete it and re-run when you want the output to show.

[j-fu]

About automatically hiding markdown: I don't this is necessary when you write your notebooks inside Pluto, but in your case (#132 (comment)), it can be done as part of the export process (the fold info is stored in the file):

c = Pluto.Cell("123")
c.folded = true
# save the notebook

This looks good - it seems that it would be easy to set this for all markdown cells bevore saving, at least as an option.

Running cells one by one used to be the default (before d201517), but there were too many problems with this that we could not fix with friendly UI - the issue is that you launch your notebook into a broken state by default - running a cell might error depending on which cells you manually ran before. It had a lot of the same state problems as Jupyter that reactivity should solve. (The goal is not to make 'Jupyter++', but to try something else.)

But if you just want the 'reveal' effect, then you can add a ; at the end, and delete it and re-run when you want the output to show.

This feels a bit awkward to me, in particular when I want to do timing examples etc. With Jupyter, I always intended to start with an empty notebook. I could guarantee that cells are in linear order and that execution is done in this order. In the spirit of c.folded, I very much would prefer to have a flag like c.execute_on_load which I could set to false.

It depends of course how much work it would be for you. I don't see much need to have a friendly UI way to fix a messed up
cell order, responsibility could be loaded off to the creator of the notebook.

[fonsp]

Hm, you could try using Pluto.run(run_notebook_on_load=false), but it's not really within the scope of this project to recreate the jupyter runtime. The flag is only there for some tricky test cases.

[j-fu]

Ok but with this, once I run the first cell, all dependants are triggered.
I tried out

       foldedcells=Array{Cell,1}(undef,0)
        for cell in nb.cells
            if cell.code_folded
                push!(foldedcells,cell)
            end
        end
        println("run folded cells")
        update_save_run!(session, nb, foldedcells; run_async=true, prerender_text=true)

which gives a pretty nice initial state showing the results of folded markdown cells (I created the notebook this way). When I run the first non-folded cell, all dependants are triggered, though.

Having a possibility to run the non-folded code cells one-by-one assuming linear order would be really nice for teaching based on a-priori prepared scripts (sorry for insisting...)
Perhaps another state flag could help here: optionally allow code cells to be blocked from execution after loading. Unblocking via GUI (e.g. by pressing the execute button) then is akin to adding a new cell and executing it, while all dependants still are kept blocked from execution.

[DhruvaSambrani]

Apart from the inconvenient side effects, this also has the security problem of running malicious code without the user being able to prevent it.

[fonsp]

That's right - https://www.notion.so/Notebook-security-d8162867a8c04b1793912d78cefee02a

[pbouffard]

Just came here to mention another use case for the delayed-execution-open: Opening a notebook for the sole purpose of copying some cells for pasting into another notebook.

[cocoa1231]

Hello

I just wanted to ask if there was any update regarding this issue? Is it planned to be implemented?
Thanks!