rmarkdown VS Pluto.jl

I am surprised they didn't mention RMarkdown (https://rmarkdown.rstudio.com/), which was developed in parallel to Jupyter Notebooks, with lots of convergent evolution.

RMarkdown is essentially Markdown with executable code blocks. While it comes from an R background, code blocks can be written in any language (and you can mix multiple languages).

The biggest difference (and, I would say, advantage) is that it separates code from output, making it work well with version control.

Pardon me for shooting from the hip here, but IMO if you're using R for something radically different than statistical analysis and data visualization, there might be another tool/language that's more purpose-suited.

> As someone who basically uses R as a nice LISP-y scripting language to orchestrate calling low-level compiled code from other languages

When I read this, I think, would `bash` or something equally portable/universally installed work?

R is a beautiful thing when limited to its core uses (I use it every day ([0]). But in my experience, the more we build away from those core uses, the more brittleness we introduce. I wish the Posit team would focus on the core R experience, resolve some of the hundreds of open issues on its core packages in a timely way, [1,2] and just generally play to R's strengths.

[0] https://github.com/hsflabstanford/vegan-meta

[1] https://github.com/rstudio/rmarkdown/issues

[2] https://github.com/tidyverse/ggplot2/issues

reminds me a lot of rmarkdown - which allows you to run many languages in a similar fashion https://rmarkdown.rstudio.com/

I'm surprised to see no one has pointed out [RMarkdown + RStudio](https://rmarkdown.rstudio.com) as one way to immediately interface with Pandoc.

I used to write papers and slides in LaTeX (using vim, because who needs render previews), then eventually switched to Pandoc (also vim). I eventually discovered RMarkdown+RStudio. I was looking for a nice way to format a simple table and discovered that rmarkdown had nice extensions of basic markdown (this was many years ago so maybe that is incorporated into vanilla markdown/pandoc).

The RMarkdown page claims:

> R Markdown supports dozens of static and dynamic output formats including HTML, PDF, MS Word, Beamer, HTML5 slides, Tufte-style handouts, books, dashboards, shiny applications, scientific articles, websites, and more.

...which I think is largely due to using pandoc as the core generator.

RStudio shows you the pandoc command it runs to generate your document, which I've used to figure out the pandoc command I want to run when I've switched to using pandoc directly.

This is a bit of a "lazy" way to interact with pandoc. Maybe the "laziest" aspect: when I get a new computer, I can install the entire stack by installing Rstudio, then opening a new rmarkdown document. Rstudio asks whether I'd like to install all the necessary libraries -- click "yes" and that's it. Maybe that sounds silly but it used to be a lot of work to manage your LaTeX install. These days I greatly favor things that save me time, which seems to get more precious every year.

Then, I worked on a Shiny project where I had to learn R Markdown. I was very excited about it because being paid to learn a new technology is something I have always preferred. I also worked with Highcharts graphs, which I didn’t do for years. It was also the first time I was being paid to design something. I didn’t enjoy that part as much as development, but I cannot say it was a bother either.

files/figure-latex/unnamed-chunk-2-1.pdf) Try to find the following text in midterm-question.Rmd: . See https://github.com/rstudio/rmarkdown/issues/385 for more info.

We used R Markdown for cleaning and analysis, creating updateable web pages we could share with everyone involved. Similarweb’s categories were useful, but too niche for us. So we spent a lot of time recategorizing and redefining the groupings. We used the token count for each website — how many words or phrases — to measure it’s importance in the overall training data.

In [R Markdown](https://rmarkdown.rstudio.com/) or [Quarto](https://quarto.org/), I can include inline code in a math equation, e.g.,

you probably want an rmd file with html output

In this post, I’m exploring dev tools for data scientists, specifically Julia and Pluto.jl. I interviewed Mandar, a data scientist and software engineer, about his experience adopting Pluto, a reactive notebook environment similar to Jupyter notebooks. What’s different about Pluto is that it’s designed specifically for Julia, a programming language built for scientific computing and machine learning.

So we discuss this briefly on our FAQ but let me try to expand on it.

Our goal is to make a modern literate programming tool. On a surface level, a tool like that would end up looking very similar to Jupyter, though with better features. We've mentioned some things we'd like to have in this final tool in our README and also in the post above.

Our first thought was to make a tool from scratch. The challenge was, it's very hard to get people to switch and so, we had to go where people already are - that meant Jupyter.

We could've made this one feature an extension with some difficulty (in-fact, our early experiments, we started by making an extension). It would have some downsides - we wouldn't have granular control over certain core Jupyter behaviours like we do right now (for eg, we wanted to allow creating hidden folders to store some files). But we probably could have made a 95% working version of Pretzel work as a jupyter extension.

The bigger reason we chose to fork was because down the line, we want to completely change the code execution model to being DAG based to allow for reproducible notebooks (similar to https://plutojl.org/ for eg). Similarly, we want to completely remove Codemirror and replace it with Monaco (the core editor engine in VSCode) to provide a more IDE like experience in Jupyter. These things simply couldn't have been done as extensions.

I thought that notebook based development and package based development were diametrically opposed in the past, but Pluto.jl notebooks have changed my mind about this.

A Pluto.jl notebook is a human readable Julia source file. The Pluto.jl package is itself developed via Pluto.jl notebooks.

https://github.com/fonsp/Pluto.jl

Also, the VSCode Julia plugin tooling has really expanded in functionality and usability for me in the past year. The integrated debugging took some work to setup, but is fast enough to drop into a local frame.

https://code.visualstudio.com/docs/languages/julia

Julia is the first language I have achieved full life cycle integration between exploratory code to sharable package. It even runs quite well on my Android. 2023 is the first year I was able to solve a differential equation or render a 3D surface from a calculated mesh with the hardware in my pocket.

Re Julia there is also pluto.jl that is another notebook-like environment for julia. It's been a few years since I played with it but it looked cool, for example it handles state differently so you don't get into the same messes as with ipython notebooks. https://plutojl.org/

For this, Notebooks are often used. Julia offers a uniquely nice and interactive Pluto notebook for the web https://github.com/fonsp/Pluto.jl

I believe this is what Pluto sets out to do for Julia.

I used it as part of the “Computational Thinking” with Julia course a year or two back. Even then the beta software was very good and some of the demos the Pluto dev showed were nothing short of amazing

https://plutojl.org/