Yes, please. Also an R tag, if I may – there is a lot that the programming-languages-for-building-programs can learn from the programming-languages-for-(interactive)-data-analysis, especially if regarding language and library UI/UX.
I’ve been using Pluto for a while (https://computationalthinking.mit.edu/Spring21/ uses them, and that course is FANTASTIC!), and I love them. Such a nice, developer-friendly, and powerful tool.
Another option, based on Pluto.jl, is Neptune.jl.
It removes the Always On interactivity which I find to be a better option for larger documents with more operations.
For me, Pluto.jl is the interactive next step from Jupyter while Neptune.jl is a real replacement for Jupyter.
I notice that Neptune.jl has ripped not just the reactivity, but also the dependency analysis. The sane file format is still a big improvement over .ipynb, but there is another question to which Neptune’s answer is not as good as Jupyter’s:
How do I notice that I’ve run cells out of order (i.e. my session works now, but will fail if I rerun the notebook)?
Pluto: There is no out of order, your cells will always run in dependency order. Duplicate and missing definitions will be highlighted.
Jupyter: Your cell run numbers will be out of order (no longer increasing from top to bottom).
Neptune: No hints. (The Observable/Pluto/Neptune UI doesn’t have cell run numbers because reactivity ensures consistency, but Neptune ditched the reactivity, so…)
RStudio:
the session log won’t match the order of the cells
the values window at the top right shows the current values of variables, this awareness helps
like Pluto has a sane file format (though Pluto’s is even better).
It would have been nice if Neptune had kept the dependency analysis: then it could be like Jupyter, but also highlight the cells that are now troubled because they depend on a cell whose value you just changed. In other words:
(because of no reactivity) you could alter your notebook code once cell at a time;
(because of dependency analysis) Neptune could show you which cells need to be rerun, and which ones to rerun/edit first.
Inspiration: Mercurial/evolve makes the commit graph easier to shape by allowing intermediate inconsistent states. That lets you, for example, rebase commits B-D out of the middle of a branch:
this creates the new, moved, commits B’-D’
B-D still exist, and are marked as obsolete
the descendants of B-D are marked as troubled: you have to rebase them onto a non-obsolete commit, or delete them, to restore consistency
you can see in the commit graph which troubled commits you still have to fix
For me, I don’t want any dependency analysis. This is just a script like any script with some HTML synthetic sugar to be able to produce plots and other visualization within the document.
The code should be written to run serially like a native Julia script.
Quote from the presentation (emphasis in original):
A reactive notebook is based on one important guarantee:
At any instant, the program state is completely described by the code you see.
This requires two things to implement:
Re-evaluate all downstream cells (using a dependency graph among cells).
Clean up scope effects from old/deleted code. [Including removing variables and modules when the definition or import gets removed]
Guide to the extra-interesting bits from the video:
4m19s: Demonstrate of reactivity on tide data (skipping the hello-world part)
7m39s: Bind variable values to HTML input widgets
9m53s: What a reactive notebook guarantees (the slide quoted above)
12m40s: How to delete variables/imports if Julia doesn’t support that? (Use modules as namespaces!)
13m31s: What if I have cells or dependencies that take a long time to run? (You can make multiple edits and then commit them all at once; also some UI quality-of-life things)
16m45s: custom interactive widgets with JavaScript
18m10s: the file format: your notebook is saved as valid Julia. This part shows some REALLY GOOD THINGS and you should watch it. I love the way the cell UUIDs (in comments) are reused instead of regenerated, so the diffs don’t contain any noise.
I am most excited about this as an improvement to Jupyter notebooks – here is what I see as wonderful improvements.
These technical improvements …:
The source file is plain Julia with a few comments to specifiy cell IDs
Code is stored in dependency order, a comment at the bottom specifies display order of the cells.
Reactivity: the output you see is always uptodate with the state of the inputs.
The source contains only inputs: you can capture outputs by exporting to HTML or PDF
… give the following user benefits:
You can edit your notebook in a text editor
Notebook files are small again
Diffs are small again
All normal code tooling works, like linters and test runners
You can import notebooks in other Julia code
You can import other notebooks in your own notebook
Output is always coherent, no more ‘when was this cell run last’?
No more conflict between ‘this notebook contains the latest version of the code -> edits go here’ vs ‘this notebook contains the outputs of the last time we ran it -> please don’t edit it’. Immutable snapshots of a mutable analysis.
Lobste.rs needs a Julia tag. The language has been around for some time now and it doesn’t seem like it is going to vanish.
Yes, please. Also an R tag, if I may – there is a lot that the programming-languages-for-building-programs can learn from the programming-languages-for-(interactive)-data-analysis, especially if regarding language and library UI/UX.
I’ve been using Pluto for a while (https://computationalthinking.mit.edu/Spring21/ uses them, and that course is FANTASTIC!), and I love them. Such a nice, developer-friendly, and powerful tool.
Another option, based on
Pluto.jl, isNeptune.jl.It removes the Always On interactivity which I find to be a better option for larger documents with more operations.
For me,
Pluto.jlis the interactive next step from Jupyter whileNeptune.jlis a real replacement for Jupyter.I notice that Neptune.jl has ripped not just the reactivity, but also the dependency analysis. The sane file format is still a big improvement over .ipynb, but there is another question to which Neptune’s answer is not as good as Jupyter’s:
How do I notice that I’ve run cells out of order (i.e. my session works now, but will fail if I rerun the notebook)?
It would have been nice if Neptune had kept the dependency analysis: then it could be like Jupyter, but also highlight the cells that are now troubled because they depend on a cell whose value you just changed. In other words:
Inspiration: Mercurial/evolve makes the commit graph easier to shape by allowing intermediate inconsistent states. That lets you, for example, rebase commits B-D out of the middle of a branch:
For me, I don’t want any dependency analysis. This is just a script like any script with some HTML synthetic sugar to be able to produce plots and other visualization within the document.
The code should be written to run serially like a native Julia script.
Like Observable notebooks, but with Julia.
Quote from the presentation (emphasis in original):
Guide to the extra-interesting bits from the video:
Further links:
I am most excited about this as an improvement to Jupyter notebooks – here is what I see as wonderful improvements.
These technical improvements …:
… give the following user benefits: