Pluto.jl

Yes! Julia is quite elegant in AoC. I had a blast doing it in Pluto last year: https://github.com/fonsp/Pluto.jl

I agree! As a start, Pluto is quite cool for thinking/learning/discovering/exploring, imho: https://github.com/fonsp/Pluto.jl 3blue1brown helped teach the "Computational Thinking" class at MIT using it: https://computationalthinking.mit.edu/Fall20/lecture2/

I think you're referring to Pluto.jl [1] notebooks? It's an external package, not built in with Julia, but yes it's very nice to just be able to open a notebook in any editor and plays much nicer with version control too. (Or maybe you mean Weave.jl [2] files, though I believe they're the other way around, Markdown with source code sections in it.) [1] https://github.com/fonsp/Pluto.jl [2] http://weavejl.mpastell.com/stable/

I tried to write this article via the awesome Pluto.jl[1]. However, defining module within a reactive environment is quite error-prone. So there you go, a simple, basic, static blog post! [1] https://github.com/fonsp/Pluto.jl

Congrats! I tried Julia for the first time last week and it was great. I've been playing with the idea of defining a hash function for lists that can be composed with other hashes to find the hash of the concatenation of the lists. I tried to do this with matrix multiplication of the hash of each list item, but with integer mod 256 elements random matrices are very likely to be singular and after enough multiplications degenerates to the zero matrix. However, with finite field (aka Galois fields) elements, such a matrix is much more likely to be invertible and therefore not degenerate. But I don't really know anything about finite fields, so how should I approach it? Here's where Julia comes in: with some help I was able to combine two libraries, LinearAlgebraX.jl which has functions for matrices with exact elements, with GaloisFields.jl

I honestly haven't thought much about Jupyter since I moved to Pluto.jl (Observable-style reactive notebook): https://github.com/fonsp/Pluto.jl

Yes. A Jupyter notebook is only reproducible in my opinion if you can hit "Restart Kernell and execute all cells" and get the same result. Otherwise, it should never been shared with other people or even contain relevant analysis you may need for yourself later. But this is not enough - also the library dependencies need to be fixed. Pluto will make this very easy in the near-future: https://github.com/fonsp/Pluto.jl/pull/844

We are working on it and the functionality is already usable - try it out! https://github.com/fonsp/Pluto.jl/pull/985 (Note that the UI for activating / deactivating the barrier will likely be changed before merging this PR)

I used Pluto for last year's Advent of Code. It's extremely good for these sorts of problems — rapid iteration with modest computational requirements. Think of something you might use a spreadsheet for — Pluto has a similar feeling of instant feedback. --- Some features that are missing: – Some things are difficult to do with the keyboard; I used my mouse more than with other tools. The author doesn't like modal editing, but ideally they could be implemented with modifier keys (https://github.com/fonsp/Pluto.jl/issues/65) - It's hard to understand what happens _within_ a cell — logging goes to the terminal rather than the notebook — and there aren't many introspection tools. This is an environment where transparency / introspection would be particularly helpful. --- Pluto doesn't solve every problem, or completely replace notebooks; to r

I have played around with Pluto.jl, and colleagues of mine use it for research, but I keep going back to Jupyter. I tend to have long running cells that are pulling information from external sources or training models, and triggering one of those cells accidentally will waste a lot of time running something that may not be reliably interrupted. There is talk about putting in execution barriers that would help with this, at the risk of making Pluto more complicated for users: https://github.com/fonsp/Pluto.jl/discussions/298

I'm a big fan of Weave/knitr/Rmd style notebooks over Jupyter for reproducibility. I've had a great experience with parameterized Weave.jl reports. My one complaint is that a streamlined dev workflow depends on good caching. knitr nailed that part, checking code hashes and checking dependencies between chunks. Weave.jl caching has been... finicky. For a completely different style of notebook, folks should check out Pluto.jl https://github.com/fonsp/Pluto.jl

This has been discussed before but I am watching the development of https://github.com/fonsp/Pluto.jl so that it can provide some solid alternative.

There's Pluto for Julia: https://github.com/fonsp/Pluto.jl

For Julia you might as well use Pluto (https://github.com/fonsp/Pluto.jl) or an IDE.