Hacker News Reader

Comment by loveparade | Hacker News Reader

Jupyter is the main reason I come back to writing Python. I really wish there was a Jupyter environment for any language. I'm aware there exist kernels for other languages, but many of them are unstable, slow, outdated, or miss important features. I have tried multiple, and every time I come back to Python, not because I want to write Python, but because Jupyter works so well.

View on HN

R and Julia’s aren’t good? They’re in the name, so I would have thought support would continue to be strong. I like Julia’s Pluto and the reactive style more than Jupyter anyway.

Jupyter

Ju(lia)-pyt(hon)-eR

To make it clear

This just blew my mind, never realized that!

Hint: Do not use the conda package. Just install R and IPRkernel (an R package) and you are good to go.

On the topic of Conda and Jupyter, install jupyter via a virtualenv pip installation, and then to use a specific conda kernel, load your conda environment in another shell, and install IRkernel in that environment. As long as you install to the main Jupyer prefix, jupyter should see the new conda kernel.

You can do this for as many kernels/conda envs as you need

Anaconda foundation does really great marketing, outreach, advocacy, education...it's a good first place for data scientists to land. But actually installing and using Conda is always annoying. I wind up doing everything with pip and venv, because pip jsut works.

Is there a language/system which begins w/ the letter "e" which would be suitable to add?

Elixir, but there’s LiveBook already.

Every year, most JuliaCon workshops are presented via Jupyter notebooks; the Julia support is pretty good and has remained stable for a long while.

Some of the unofficial extensions like `code_prettify` don't work for Julia kernels, but at least for my usage, I've never felt the need for such tools in a Jupyter notebook.

IJulia is falling behind. If you look at github activity, it has 1 commit in past month. Compared to 9 authors and 39 commits in past month for IPython. IJulia issues are piling up.

Jupyter's idea is based on how Smalltalk and Lisp environments work.

Can we squint and squeeze in postgres in there as well.

Jetbrains dataSpell is what you want.

But is that accidentally rediscovering things, or is it intentional and simply still has a long way to go?

Since Julia is Lisp-inspired and part of Jupyter since the beginning, I do think it's intentional.

Jupyter spun off IPython which has existed since 2000.

Cannot see how. Smalltalk and Lisp basis are allowing modification of the environment itself even while running. Jupyter cannot do that and the notebook interface (basically originating from Mathematica) isn't suitable, or even has goal to be, for generic programming.

Here is how then,

"Symbolics Lisp Machine demo", special focus on 5 minute onwards.

https://www.youtube.com/watch?v=o4-YnLpLgtk

Mathematica was inspired from Lisp,

https://writings.stephenwolfram.com/2013/06/there-was-a-time...

>"Symbolics Lisp Machine demo", special focus on 5 minute onwards.

To provide more information since video description lacks, this is OpenGenera a Lisp Machine OS designed to also run hosted on Unix systems. This specific version (seeing it uses jpeg) should be from mid- to late- 90s. Had tried some version but didn't remembered being able to have graphics on REPL.

Yes, that's basically how Jupyter console works. But will still argue that the Jupyter model is such weaker version of this that can hardly be called a derivative. Listener isn't only limited to being used like an isolated shell but can be attached to any part of the environment. (And this introspection is core to Lisp and Smalltalks environments.)

>Mathematica was inspired from Lisp

The language Wolfram, yes. The cell-based notebook interface was new. But similar to previous is a more limited version of what you had available; specifically interchanging text and code in Zmacs. Something that was also an advantage (easier of reason with) for what Mathematica was used for.

Isn’t it mainly based on how Wolfram Mathematica works?

Where do you think it got its inspiration from?

https://writings.stephenwolfram.com/2013/06/there-was-a-time...

Thanks for the link!

The bits I was aware of (/lived through), from UX standpoint was:

Mathematica -> iPython notebooks -> jupyter notebooks.

And from whatever source, I knew Mathematica notebooks had looked how they had /at least/ since the mid 90s. (My Mathematica days were college, and I did not spend much time contemplating the history of my tooling)

From elsewhere in the comments, it sounds like iPython->jupyter wasn't just a rebranding, as I assumed it was at the time.

Check out the Polyglot Notebooks extension for VS Code. It supports other languages but also, notably, mixing languages in the same notebook.

Even crazier, it lets you interop between the languages by way of sharing variables between them. Polyglot is pretty darn impressive.

I do all my data analysis in groovy using JupyterLab via beakerx:

https://github.com/twosigma/beakerx

It has some quirks, but it works amazingly well really, esp. with the enhanced widgets BeakerX gives you.

I’ve been messing around with Microsoft’s Polyglot Notebooks which looks pretty interesting. Caveat: I’ve not used Jupyter and that was my first experience of notebooks.

orgmode + org-babel comes really close, but I feel like org just doesn't get much traction outside of Emacs,because markdown is good enough.

This [1] looks ugly and distracting.

    #+begin_src R :colnames yes
      words <- tolower(scan("intro.org", what="", na.strings=c("|",":")))
      t(sort(table(words[nchar(words) > 3]), decreasing=TRUE)[1:10])
    #+end_src

Is it possible to have minimal syntax for these code blocks? Markdown is nice because it looks clean, and the syntax does not get in the way. Markdown codeblocks are

    ```
    code
    ```

[1] https://orgmode.org/worg/org-contrib/babel/intro.html#source...

You could, for example, use Python which I believe would be clearer than this R mess ;-)

Joking aside though, if src block header (which can have a lot of options set up including specifying environment, tangling other block variable of setting totally separate interpreter version) is huge problem there are plethora of presentation customization.

Emacs allows customizing face and more. Org-modern [1], for example, uses font signatures and fringes for making it less “technical”

[1]: https://github.com/minad/org-modern

You could put all the common headers in a property drawer of top-level heading, and all child source code blocks inside that heading will inherit them.

    * Notebook
    :PROPERTIES:
    :header-args:R: :colnames yes
    :END:

    #+begin_src R
    words <- tolower(scan("intro.org", what="", na.strings=c("|",":")))
    t(sort(table(words[nchar(words) > 3]), decreasing=TRUE)[1:10])
    #+end_src

As for making the block delimiter look different, there are various ways of making the text display differently from the actual text. For example, you could use the built-in `prettify-symbol-mode` with this config:

    (setq prettify-symbols-alist
          '(("#+begin_src" . ?)
            ("#+end_src"   . ?―))

I'd expect there will be a lot of new solutions coming soon, because Polymode [0] seemingly solves the hard problem the org-babel struggles against. The immiscible major modes, and all that extra syntax and buffer-switching that org-babel needs to work around that problem.

[0] https://www.masteringemacs.org/article/polymode-multiple-maj...

There is EIN, which indeed uses Polymode, and of which I am a happy user: http://millejoh.github.io/emacs-ipython-notebook/

Binder handles a stack of languages, but I've only tried Python & Julia.

Gonna place a bet that AI delivers your wish within 2-3 years.

What kind of programs do you use Jupyter for and what are the main benefits in your opinion?

Come to think of it, I don’t know why Node doesn’t have this. It’d be pretty trivial, no?

Creating something in the scope of Jupiter is not trivial.

You do have a few nodejs/typescript/javascript kernels that work fine, so I don't see the point for rewriting Jupiter in node specifically for any reason.

In any case, maybe creating something for the browser only is easier because JS is native, but still I wouldn't call it "pretty trivial". For this use case (and more) you have projects like

https://starboard.gg/

https://observablehq.com/

Perhaps I’m not fully up to speed with everything Jupyter does. It strikes me as a REPL with a canvas in what is basically MDX. What am I overlooking?

You're overlooking the power that a preconfigured REPL with a persisted canvas integrated with markdown brings to the table.

It is a really powerful toolset, and building your own environment from separate parts is not trivial; so having it preconfigured in a standard way that others can reuse is no small matter.

I prefer online notebooks with a functional-reactive behaviour, such as ObservableHQ (which is JavaScript-based, rather than python); but Jupyter was the first popular one, so it hit hard.

https://mobile.twitter.com/observablehq/status/1234868724588...

You might be misinterpreting me here. I’m not dismissing the utility. Quite the contrary, I’m saying that it wouldn’t be terribly groundbreaking or challenging to implement compared to some other green field problem. Although at this point I do agree that trivial was the wrong word.

Observable looks cool, but it doesn’t seem portable. It really bums me out that so much of the JS ecosystem is so sheerly commercial in this way. Sometimes I don’t understand why this is like this compared to the Python ecosystem. It’s not that I’m cheap either. I’ll happily pay for things that are properly monetized and provide a good value for my time. This doesn’t seem like it.

You might like tslab. It allows you to have the full notebook experience with either JavaScript or Typescript. My day to day is data analysis. JS/TS runs circles around pandas and you aren’t constrained to vectorized operations. If there were a suitable replacement for matplotlib I would leave python behind altogether.

https://github.com/yunabe/tslab

Rust works great in Jupyter.

What is the experience like using a compiled language in such interactive environment? Like you cannot for example do something in one cell and utilize the result to another, or can you?

Yes you can, it is no different from using OCaml or Haskell REPLs, for example.

https://github.com/google/evcxr/blob/main/evcxr_jupyter/samp...

Reply on news.ycombinator.com