I'm slowly starting a blog, and this is something I have struggled with. For now, I am writing the blog posts in markdown but then supplement the posts with notebooks so that there's clean and complete code without in-between versions.
I have often thought that it would be nice to just write the articles fully in the notebooks, but it's not ideal. One thing is that articles often build up ideas where providing code is often better to just show the complete pieces. Having everything in one notebook muddles these two things. Also, converting notebooks to markdown ot HTML/CSS/JavaScript is not all that straightforward when your notebook includes LaTeX and Mermaid diagrams.
So for now, I'm sticking with articles in markdown supplemented with notebooks. The downside is that the notebooks are not standalone.
For what it's worth, I've found it ok (not great, but just ok) to write in Colab notebooks (maybe because I use it at work and I'm familiar with it). Here are a couple of such "blog posts" (which are basically just explorations for myself, but still clean enough to share):
Pros: Can just type Markdown and LaTeX math; don't need a separate step to convert to HTML/CSS/JavaScript.
Cons: URL is ugly, code can only be Python (I think?), the UI is janky, can list lots more. But the friction was low enough that it got me to write at all (and move on without endlessly fiddling and never posting), and that's the most important thing for me.
I imagine if I were more comfortable doing everything in Javascript I could use Observable notebooks, as suggested in a sibling comment.
That doesn't solve my problems though. F# notebooks with Polyglot Notebooks or Elixir notebooks with Livebook, which are what I use, are much more advanced than Jupyter notebooks and likely anything Emacs provides.
For example, in a Polyglot Notebook in VS Code, I can freely mix markdown, F#, C#, JavaScript, HTML, Python, LaTeX, Mermaid diagrams, images, and more.
I can only assume Emacs provides nothing close to this.
Your assumption is incorrect, I don't know how it works is VSCode, but what you described is exactly my flow in Emacs org-mode.
I can even annotate my code blocks to execute on remote machines, or to "tangle" my code blocks together to deploy standalone files my local or remote machines.
The meta language in tangle let's me reuse code snippets for machine specific configurations. I can almost replace my DevOps workflows with Emacs Org-mode.
It takes practice to use, and the documentation isn't very good though. Too terse for my preferences, but ChatGPT is really good at helping me understand.
I don't think the parent asks "what is available in Emacs in different places" or "what is theorically possible", but whether org mode has feature parity with what he uses, and the answer is not.
There might be a way to have plots inside org mode (e.g. org-plot) but you don't have "arbitrary html/js" plots (except as links to other in a browser, and I doubt you get even close to the same level of interactivity.
And even what you get regarding plotting is not turn-key that way VSCode Jupiter and Polyglot are.
Thanks for getting it. Steps to run my F# or Elixir notebooks are:
* Install F# or Elixir
* Install the Polyglot Notebook extension in VS Code (for F#) or install Livebook (for Elixir)
* Run notebook
The idea of what Emacs provides is irrelevant to my problems of how to efficiently write blog posts either in or support by notebooks. I gave up the path of Emacs long ago for the exact reasons of this chain. Yes, you can do anything or a collection of things, given enough time. For VS Code and these notebook technologies that I use, I do not spend time fussing about with the notebook technology.
I see, this makes sense, thank you for helping to clarify.
That being said, I feel like this kind of the entire point of emacs. Everything is pieced together, and very little is "out of the box".
At least, It's THE main reason I started learning Emacs, I was tired of the lack of interoperability of my different tools and I wanted an ecosystem that lets me piece things together as needed, like the Unix philosophy but with a tighter interactivity loop.
It's a double edged sword, in that it takes much more effort to build and maintain, but there's nothing really like it.
I still use VSCode and Jetbrains IDEs, but they don't drive my workflow like Emacs.
These are more convenient both for the code creation and for the final written exposition than Mathematica notebooks. Among other convenient features, code can be split across notebooks, and cells can be arbitrarily re-ordered on the page without any inherent linear dependency.
Caveats: you need to write your code in Javascript, and your notebook is hosted on a commercial platform (though it’s not inordinately difficult to copy it out from there.)
I have often thought that it would be nice to just write the articles fully in the notebooks, but it's not ideal. One thing is that articles often build up ideas where providing code is often better to just show the complete pieces. Having everything in one notebook muddles these two things. Also, converting notebooks to markdown ot HTML/CSS/JavaScript is not all that straightforward when your notebook includes LaTeX and Mermaid diagrams.
So for now, I'm sticking with articles in markdown supplemented with notebooks. The downside is that the notebooks are not standalone.