Hacker News Board Hacker News, browsed like a classic message board
Live data from Hacker News

Pluto.jl – a reactive, lightweight, simple notebook

github.com

Post reply on HN
Print view View original

21–30 of 63 posts

Re: Pluto.jl – a reactive, lightweight, simple notebook

#21

Post by jakobnissen »

I've switched from Jupyter to Pluto recently. Here's a few experiences with it.

* The fact that I can actually use the source files later because they're just Julia files is incredibly useful. I often copy-paste from them into actual REPL-code, and sometimes I just polish the notebook until its source becomes usable as a command-line tool.

* I like the reactive notebook concept. It does really help with bugs

* Pluto is still rough around the edges. Too few keyboard shortcuts. Buttons and text are tiny, afloat in an ocean of useless whitespace. pushing to LOAD_PATH doesn't work properly. Pluto is a very young project and just now gaining attention in the Julia community, so I'm confident these usability issues will improve.

Re: Pluto.jl – a reactive, lightweight, simple notebook

#22

Post by joshday »

xiaodai wrote: post #18
joshday wrote: post #14

I've been using Pluto for several weeks and I absolutely love it for quickly iterating on plots and making small UIs for interactively showing off results. It's altogether a much better experience than Jupyter for me.

wonder if you have tried it on large datasets given ur background. Does it work well with large-datasets given its reactive nature?

Everything is cached unless something upstream changes, so it should work just fine with big datasets. I've only been using relatively small datasets so far, though.

Re: Pluto.jl – a reactive, lightweight, simple notebook

#23

Post by jonniedie »

WolfOliver wrote: post #3
Tarq0n wrote: post #2

Sounds like they fixed a bunch of things that are broken about Jupyter notebooks. I still don't understand why anyone would want to do work in their browser though.

would be curious what Jupyter notebooks things are better with Pluto.jl, can you name some concrete points?

Reproducibility is a huge one for me. I’m often doing exploratory work that I’ll want to save in its current state and pick back up a few months (or even years) later. With Jupyter, this almost never works because I am constantly editing and running cells out of order as I’m exploring things. If I save at any given point, there is no guarantee that the notebook will be in the same state when I reopen it and re-run the cells.

With Pluto and other reactive notebooks, you have a guarantee that the code you see on the screen will produce the same results. So if you go back and edit cells out of order, save the notebook, then open it and re-run later, it will always be in the same state you left it in.

Re: Pluto.jl – a reactive, lightweight, simple notebook

#24

Post by g0wda »

jakobnissen wrote: post #21

I've switched from Jupyter to Pluto recently. Here's a few experiences with it. * The fact that I can actually use the source files later because they're just Julia files is incredibly useful. I often copy-paste from them into actual REPL-code, and sometimes I just polish the notebook until its source becomes usable as a command-line tool. * I like the reactive notebook concept. It does really help with bugs * Pluto…

> I like the reactive notebook concept. It does really help with bugs

Can you say more? An example, maybe?

Re: Pluto.jl – a reactive, lightweight, simple notebook

#25

Post by jakobnissen »

g0wda wrote: post #24
jakobnissen wrote: post #21

I've switched from Jupyter to Pluto recently. Here's a few experiences with it. * The fact that I can actually use the source files later because they're just Julia files is incredibly useful. I often copy-paste from them into actual REPL-code, and sometimes I just polish the notebook until its source becomes usable as a command-line tool. * I like the reactive notebook concept. It does really help with bugs * Pluto…

> I like the reactive notebook concept. It does really help with bugs Can you say more? An example, maybe?

The idea is to keep the amount of global state as low as possible. Pluto.jl creates a dependency graph between cells: If cell A defines foo, and cell B uses foo, then cell B depends on cell A. Whenever cell A is updated, cell B will automatically be re-evaluated.

(edit: I suppose it's not really global state I'm talking about as much as hidden state left over from overwritten or deleted cells)

For example, I typically create tonnes of code cells when I visualize and try to get a sense of some data. The large majority of cells (probably >80%) are then deleted, and whenever I find a trivial bug in some code, I fix the cell where the bug occured.

But now - which cells had I rerun after fixing the bug? And did any of the run cells depend on some variable in a deleted cell? If so, the notebook will no longer be reproducible when I re-run it? It's impossible to keep track of. So when I use Jupyter, I frequently press the "restart kernel and run all" option. But of course, that is slow. So I need to serialize a lot of data, which is troublesome. Pluto completely circumvents that problem.

Re: Pluto.jl – a reactive, lightweight, simple notebook

#26

Post by sradman »

jakobnissen wrote: post #19
sradman wrote: post #16

Pluto.jl appears to be a Julia centric notebook alternative to Jupyter and its multi-language Kernels, including IJulia [1]. I imagine there are many trade-offs between the two but the primary one I see is the runtime size/Python-dependencies of Jupyter versus the reach of the platform. There is also a great deal of overlap between IDEs and Notebook platforms. [1] https://github.com/JuliaLang/IJulia.jl Edit: "pure Ju…

Not quite. Pluto is also built on JavaScript (of course, since it's a browser notebook). The main advantages of Pluto is that * The sources files are executable Julia files with minimal metadata, so it plays nice with Git. Also, the code of the source files is ordered to reflect the execution order of the cells, to keep the source code and the notebook in sync. * It attempts to remove all global state. If you change…

Git friendly native Julia files and clean cell reordering/refactoring are very nice features. Julia seems like a compelling data science platform, especially for greenfield projects.

Re: Pluto.jl – a reactive, lightweight, simple notebook

#27

Post by Certhas »

jakobnissen wrote: post #19
sradman wrote: post #16

Pluto.jl appears to be a Julia centric notebook alternative to Jupyter and its multi-language Kernels, including IJulia [1]. I imagine there are many trade-offs between the two but the primary one I see is the runtime size/Python-dependencies of Jupyter versus the reach of the platform. There is also a great deal of overlap between IDEs and Notebook platforms. [1] https://github.com/JuliaLang/IJulia.jl Edit: "pure Ju…

Not quite. Pluto is also built on JavaScript (of course, since it's a browser notebook). The main advantages of Pluto is that * The sources files are executable Julia files with minimal metadata, so it plays nice with Git. Also, the code of the source files is ordered to reflect the execution order of the cells, to keep the source code and the notebook in sync. * It attempts to remove all global state. If you change…

To me this makes it a fundamentally different thing to jupyter.

Re: Pluto.jl – a reactive, lightweight, simple notebook

#28

Post by 3JPLW »

g0wda wrote: post #24
jakobnissen wrote: post #21

I've switched from Jupyter to Pluto recently. Here's a few experiences with it. * The fact that I can actually use the source files later because they're just Julia files is incredibly useful. I often copy-paste from them into actual REPL-code, and sometimes I just polish the notebook until its source becomes usable as a command-line tool. * I like the reactive notebook concept. It does really help with bugs * Pluto…

> I like the reactive notebook concept. It does really help with bugs Can you say more? An example, maybe?

It completely fixes a huge number of the gripes in the JupyterCon talk I don't like notebooks by Joel Grus.

The primary complaint there is that notebooks have a disconnect between the state of the program and the display of the cells. By using a completely reactive mode the state is no longer hidden. It's more akin to a spreadsheet than a notebook. A number of other complaints are completely circumvented by using a file format that's simply a pure Julia file with clever comments.

Video: https://www.youtube.com/watch?v=7jiPeIFXb6U

Slides: https://docs.google.com/presentation/d/1n2RlMdmv1p25Xy5thJUh...

Previous discussion: https://news.ycombinator.com/item?id=17856700

Re: Pluto.jl – a reactive, lightweight, simple notebook

#29

Post by benhurmarcel »

vanderZwan wrote: post #10

Really happy to see that the good ideas from Observable notebooks are being copied elsewhere. I don't use Julia myself at the moment (although I think it's a beautiful language), but I know some people who will be very happy with this! Also, the playful enthusiasm in the presentation video linked in the description just makes me smile: https://www.youtube.com/watch?v=IAF8DjrQSSk

Very interesting, thanks.

I don't understand the point of the "reactive" cell order, instead of conventionally doing top to bottom. It seems like it goes against the idea of "the program state being completely described by the code you see".

Re: Pluto.jl – a reactive, lightweight, simple notebook

#30

Post by benhurmarcel »

jakobnissen wrote: post #25
g0wda wrote: post #24

Earlier quoted context omitted.

> I like the reactive notebook concept. It does really help with bugs Can you say more? An example, maybe?

The idea is to keep the amount of global state as low as possible. Pluto.jl creates a dependency graph between cells: If cell A defines foo, and cell B uses foo, then cell B depends on cell A. Whenever cell A is updated, cell B will automatically be re-evaluated. (edit: I suppose it's not really global state I'm talking about as much as hidden state left over from overwritten or deleted cells) For example, I typicall…

What happens if you reassign a variable below? Like:

  a = 1
  println(a)
  a = 2
Does it show 1 or 2?

Edit: tested it, it throws an error "Multiple definitions for a: Combine all definitions into a single reactive cell using a `begin ... end` block."

Not sure I like that way of working.

Post reply on HN