I'm curious what your thoughts on are on emacs-jupyter[0] which seems to integrate reasonably well with Org mode. I have some complaints about how it has to handle output blocks, but otherwise it seems like a great way for Emacs to act as a frontend to a Jupyter kernel.

[0]: https://github.com/emacs-jupyter/jupyter

I can't recall exactly right now (incidentally I started recording decisions like this to be able to answer questions like this - mainly for myself - but only recently).

To refresh my memory I just started it and tried using it with a julia kernel on a remote jupyter. To start, it wouldn't connect to https endpoint. Maybe because it's signed by a private CA? idk, but the mac trusts it for eg the browser and curl. Well anyway, let's forward the http port and try connecting to localhost.

Great, that works, and I'm offered some uuid as a "choice of kernel to connect to". I don't recall having one running before I connected, so it probably was started for me. How do I name it? Ah, there's `jupyter-server-kernel-list-name-kernel`, and now I'm recalling that whatever you name it as, will disappear if you quit emacs. Let's try.

Meanwhile, I import PlotlyJS and try to create a plot. I get complaints about WebIO (julia package that facilitates interaction with browser) like I do in jupyter (the package is old and doesn't work with current jupyter), except in the browser only the back communication (browser->kernel) is broken, for interactivity. Showing plots works. Anyway, PlotlyJS displays nothing. `Plots`, which renders to a png, somehow produces the axes but not data. Eventually I get PlotlyJS to display an image using explicit image mime types.

Still no interactivity - I would need node for that, to compile widget support for whatever reason - but it does display. I should retest widget support. Sending code to repl works, although at this point I'm used to seeing an overlay over variables that get set.

Ok. Close emacs, restart, go to session list (`jupyter-server-list-kernels`). Name has been cleared. I can reassociate the buffer to the kernel, but, if I have two, open kernels, how do I tell which buffers is associates with which kernel?

Overall it mostly works although there's room for polish. However, interactivity or any kind of bidirectional communication remains somewhat difficult.

Have you tried https://github.com/emacs-jupyter/jupyter Eg as org-mode code blocks.

There already is a library that can interface emacs with Juypter it is called ein. I think what you really want is a kernel that executes emacs code and if you did make that kernel it would probably work in any of these systems.

See https://github.com/emacs-jupyter/jupyter

Yes, I'm aware of EIN. To start, it's been abandoned by it's author/maintainer as of April 2024 IIRC.

Further, I do not need a kernel to execute emacs code - I have one and it's called emacs. The point regarding executing elisp code was a cheeky way to state that I am not looking forward to finding replacement and/or porting of all the custom code - mine and others' - that my editor runs, and that no amount of "features" from a webui editor will ever replace that. Hence I also mentioned vim since over time it got customized for me as well and I wouldn't want to port that either. Nor the convenience of the terminal, which is what vim is for.

Putting that aside as with all respect and gratitude to the author, it was rather clunky in many respects - no interactive story, poor handling of sessions and remote kernels (have you tried to start one, disconnect and reconnect?), no integration with LSP, and lack of many many more features that /could/ be made.

I don't know how much use you make of jupyter kernels or mathematica notebooks or similar technologies, but in my case I explored the available landcape quite thoroughly and regularly revisit. I know what I'm looking for and EIN is/was not it.

[EDIT] I just noticed you mentioned EIN but linked to emacs-jupyer. Used that as well, of course. Ill add a bit more detail to that in sibling

I'm guessing you already looked at org-mode code blocks which basically do the same thing as a juypter notebook without a web protocol, webUI and anything else if you wanted an experience that is easier to commit to a git repo and has a notion of cells which is the magic sauce for juypter (it was originally derived from ipython which is a command line interface). I am also a emacs user :)

Juypter has an interface and API built in. What Zasper is the reimplementation of the juypter protocol. You can see this at [1]. Juypter kernels are very different from Mathematica notebooks. Mathematica notebooks aren't related to juypter.

Juypter kernels encapsulate language runtimes so that they can be interfaced when called from a notebook.

[1] https://jupyter-client.readthedocs.io/en/stable/

> Mathematica notebooks aren't related to juypter.

I don't think that's fair. Rather, IPython, and later Jupyter, explicitly (successfully) sought to create a Mathematica-like notebook experience for Python.

I agree. The command line IPython by Fernando Perez was very inspired by Mathematica. He used Mathematica as a grad student and wanted a similar environment. In 2006-2007 Tom Boothby, Alex Clemesha and I wrote the first general used interactive web notebook called "The Sage Notebook", which became very popular with SageMath users over the years; the first version of Jupyter looked very similar to the Sage notebook. The Sage notebook was heavily inspired by everything around Google Wave and Google Docs (at the time), but definitely also by Mathematica's notebook. In particular, Alex Clemesha had recently been a physics undergrad and was a heavy Mathematica (and "Web Mathematica") user, and wanted a similar environment in a browser.

Thanks, I'm quite aware of org-mode. All my emacs config is in it, I have 1000s of LOC configuring /just/ org, I use it my computers and on my phones for any kind of information management, and I absolutely love it.

I think it can be very suitable eg when you are preparing a presentation, report, a paper or a repeatable analysis/process. Especially - as with most of those examples - if you want to interleave narrative and code/results. It is less suitable for doing exploratory analysis, for any kind of interactivity, for connecting to remote sessions (it's possible but clunky), for showing a chart that you can zoom into. For displaying a table with 10,000 rows, for displaying a large plot. Or multiple plots. For being able to zoom into a plot. It's not great at integrating with LSP and similar tools. Could be better at managing code blocks, though one could write additional helpers and bindings fairly easily.

And, finally, it is quite a pain in the ass to have the code stored in a document rather than as code since it does tie me down even to my beloved emacs. I develop most of my code as library code which I can directly import/run. During the development it is still helpful to see the results of running defined functions and to be able to interact with the dataset. I currently do have a solution and a workflow but the tools aren't ideal for it.

I want to be able to have my codebase run inside a docker container, to be able to `git pull` to update it on the remote without involving emacs on the remote end, without having duplicate versions of the code in the repo (ie one in the org document and one tangled) for me to manage, and I also want to be able to make a small change in vim and push it back without involving emacs.

> Juypter has an interface and API built in. What Zasper is the reimplementation of the juypter protocol. You can see this at [1].Juypter kernels are very different from Mathematica notebooks. Mathematica notebooks aren't related to juypter.

Thank you for the explanation. Up until this very moment I thought mathematica and jupyter were exactly the same. Just to make sure, when you say they are very different and unrelated, do you mean like matlab is unrelated to numpy+ecosystem, like how Honda cars are unrelated to Ford cars, or like how pandas is unrelated to excel?

It helps when you are actually familiar with the technologies before making any - especially contradictory - claims. Mathematica for all it's faults - primary of them being proprietary - has a quite finely polished product and jupyter notebook interface draws heavily from it. I'f I'm not mistaken it is the OG notebook interface, though I'm not making a strong claim here.

Mathematica also has an interface and an API built in. You can run mathematica (or is it "wolfram" these days?) code on a headless kernel, you can connect your notebook frontend to a remote kernel, and you can make your own completely independent UI using the APIs in the language. Alternatively, you can connect the notebook interface to a kernel in another language using J/Link MathLink or C/++Link APIs. Or you can embed the mathematica kernel into jupyter - an existing project/duct and run mathematica code in jupyter/Zasper/whatever. Or run it in their webui for the past .. decade at this point?

I'll give you the benefit of doubt and not assume that you are a trollbot but I sincerely don't understand your need to offer "first page of google" suggestions when you clearly don't use the technologies you're commenting on.

Did somebody say eMacs? I dunno, I think VI integration could be more important.

I mentioned vim as well and generally proposed something that would be editor agnostic. Shoo! back to your cave.