If you haven't used them in awhile, Visual Studio Code notebooks (which leverage Jupyter) are now at a level that they're better than Jupyter/JupyterLab for Python Data Science. It now integrates more closely with themes/settings, and has many additional features such as native debugging, native diffing for Git, Intellisense/autocomplete, and in general the UI/UX is faster.

That said, a desktop JupyterLab is still very valuable as it increases accessibility dramatically, but it's no longer the only player in the space.

I use all three of JupyterLab, Jupyter Notebooks and VS Code Notebooks.

What I love about VS Code Notebooks - it's almost zero context switching to jump from the the code you are working on to a REPL and back.

What I don't love about VS Code Notebooks (and why I still spend a lot of time in JupyterLab) - the context gets confused as to what cell you are in frequently - so your Ctrl-Enter keys don't work, and you have to manually run each cell one at a time.

~Removed comment about graphs not being inline~ - I stand corrected. Just checked an the latest version does let you show your graphs inline. And they look awesome.

I use VS Code notebooks a lot, I like the workflow so much that I made an extension for Go called gobook using the API. I bind everything notebook related to shift+alt, so shift+alt+enter to run cell, shift+alt+r to run all etc. I'm learning Rust and working on a VS Code notebook for it now.

A notebook for Rust? How does that work? I thought notebooks can only be used for interpreted language and not for compiled ones...

Theres a repl for rust that can be used in a Jupyter notebook. I am also curious about how it works under the hood but here it is for anyone to check out: https://github.com/google/evcxr

The way I did it for Go was by having a API start up on the local machine that executes the code and returns the result to VS Code, going to do the same for Rust.

> Also - and this is the deal breaker for most people I know - you can't display graphs within your notebook. Until we get that ability - everyone I know who does work and lives off of their matplotlib workstream is going to continue using Jupyter Lab/Notebooks.

Hmm? The latest demos seem to imply that a plt.show() does embed the plot images into the Notebook.

The major limit on cell outputs is more limited interactivity.

The API microsoft provides allow you to make outputs that do anything that JavaScript can do, when making an extension. One of their engineers made a something called REST Book that's a really good example.

I tried VS Code notebooks on Windows again this week and went back to the webapp within 2 days. The simplest things -- like ability to copy a cell's output to the system clipboard -- didn't work, with multiple outstanding / unresolved issues on GitHub. Lots of problems with pandas plots / pyplot.

I'm surprised to see it recommended on HN, it still felt "alpha" to me.

I use it a lot, and a big advantage is how configurable it is compared to other options. You can change practically everything in Settings. So you can customize it in the way you prefer.

Hey, it looks like ipywidgets finally work in VSCode notebooks! Light/dark colorscheme clashes that would make Star Wars proud, but I'll take it.

Pyviz (panel, holoviews, etc) interactivity doesn't look like it works yet. Ipywidgets might be enough, though!

JupyterLab has had debugging for a while. It seems to be broken in both VSCode and Jupyter, though (or, rather, it hasn't broken on the breakpoints, where it ought to have broken). Ah well, probably needs more futzing around with the kernel.

Oh man. Lack of proper debugging and diffing is a _huge_ problem with jupyterlab notebooks. In several cases I've seen, data scientists don't even realise that these tools exist.

I know VS Code has been making progress recently but a good jupyter competitor with some halfway decent software development features would be a game changer.

Notebooks are the out-of-order log of a fancy terminal. That can be great! But trying to use them for anything more than interaction or the most basic scripting is a fool’s errand. Build software in a real environment, then use it a notebook.

The advantage of notebooks is extremely fast iteration. They are amazing for very fast "trial-and-error". Building software in "real" env has a slightly different use case than notebooks. If you are a data scientist or working with a lot of data, you definitely want to use a notebook over a normal environment.

Imagine you want to read a lot of data from csv file and plot a graph of it. But then you realize that the alpha value used for graph should be 0.3 rather than 0.1. In real env, you would need to read the huge amount of data again. In notebooks, you avoid that!

Right, that’s interactive computing. Notebooks are a strict improvement over a standard REPL-in-terminal for those use cases.

The problem come when you want to make that process reusable for other CSVs, on other machines, in other environments, to repeat it in the future, to test components of it, to make and track changes over time, to share with a coworker, etc.

To put in perspective, notebooks are how using the REPL on Lisp Machines and Xerox workstations (Interlisp-D, Mesa XDE, Mesa/Cedar, Smalltalk) feels like.

Those machines came and went a bit before my time, but I do recognize the sense of excitement and power I feel in notebooks in the recollections I’ve read.

Similarly, comments about ‘how do I distribute a Smalltalk program if it’s just the image of the entire VM’ rhyme just a bit to my ear with ‘how do I share my notebook with my coworker if it’s really the agglomerated state of my interpreter and language environment’

In terms of Smalltalk the answer is quite easy, you would trim down the image as kind of "release build" and ship it alongside a tiny executable that would load it.

No big deal other that talking rumors without reading manuals.

I didn't mean to imply that the answer to either question was 'can't be done', but that the analogy might extend to the the points of friction as well.

Sure, and my point was that mostly the friction in Smalltalk's case, was not reading the documentation and having an opinion without Smalltalk experience.

RMarkdown has neither of these issues, and it supports Python. It is baffling to me that most data scientists use Jupyter, since its diffs are meaningless. Its export options are very underwhelming compared to Rmd as well. Notebooks [1] are simply a special case of R Markdown formats. Besides, Rmd are literally text files that work with any text editor, including vim.

[1] https://bookdown.org/yihui/rmarkdown/notebook.html

You can use Jupytext and basically get the best of both worlds (it hooks into jupyterlab to save/restore a markdown version of the notebook). A possible downside is that it doesn't store the outputs of the cells, though that is intended as a feature.

And since rMarkdown just uses pandoc under the hood, it's a bit unfair to say it has better export options than ipynb which is also supported by pandoc.

The closest thing to RMarkdown is MyST — the native .md format for the jupyterbook project: https://jupyterbook.org/content/myst.html

I've switched to that instead of notebooks, and loving the text-based life... gittable, diffable, peer-reviewable code, etc.

I’ll take a moment to plug jupytext. It just takes an easy pre-commit hook to have auto-synchronized .ipynb and .md (and more!) versions of the notebook, which makes diffing and code review feasible.

some things are less-great in the FOSS world. I used MetroWerks tooling that really, really was nice. I even wrote code for them once .. it has been a long while and the real win with Jupyter is the massive popularity I think.

I’ve been using JupyterLab for the past couple years and tried VS Code two or three months ago and it was not a smooth experience. I regularly use VS Code for my non data science coding, but VS Code notebooks were much slower than JupyterLab and they would often hang, requiring me to kill the kernel and VS Code. Switched back to JupyterLab and had zero problems.

You should give it a spin again. Notebooks _used_ to be a web view in VS Code. But we re-wrote them to use native UI elements and the performance is much better.

I use JupyterLab professionally and have never been able to get VSCode notebooks working at the same level. For example, simple bracket highlighting doesn't work in the VSCode notebooks I've tried. I want to like them, but they don't get the job done for me.

One cool feature of Visual Studio Code notebooks is you can set VSCode as the default "opener" for .ipynb files, which allows you to open notebooks using double click.

I still run jupterlab for my "main" environment, but I've been using VSCode to explore notebooks I download from the web. Very convenient.

I hate the automatic bottom right pop ups for every little thing in VS Code, its so annoying

Do you have a link of resource explaining more about the VSC notebook workflow?

Here's the official page on the integration: https://code.visualstudio.com/docs/datascience/jupyter-noteb...

Some more demos: https://code.visualstudio.com/learn/educators/notebooks

Once the extensions are installed, just open an .ipynb file in VS Code.

Just a fair warning if you are using the latest version of the jupyter notebook extension (I dont think it will be a problem if you are not using the extension but I haven't tried that method). It has much better support for intellisense than its previous version but it still has a couple of bugs that sometimes require restarting vscode to fix it. It is pretty easy to switch between versions though

Interesting. I've been very excited by and disappointed by pycharm's work on that front. I'll have to check out the VS code version. Thanks!

I’ve tried vs code notebooks. For me, they don’t run as fast as jupyter.

That said the convert jupyter NB to Python in VS saves a lot of time.

Have you tried recently? We re-wrote them from scratch to use native UI elements (used to be a web view) so perf should be much improved.

Nope but if it’s been improved, I will take a look. Would be nice to run with remote containers.

Is "Visual Studio Code notebooks" fully open source, like JupyterLab is?

VS Code is here: https://github.com/microsoft/vscode

The extension that enables Jupyter Notebooks is here: https://github.com/Microsoft/vscode-jupyter

This is really interesting to see. I've been trying to solve a similar problem over the past few weeks - bundling up a Python web application as an installable Desktop app, in my case for https://datasette.io/desktop - so it's really interesting to see how they've approached the problem.

I ended up including a full copy of Python using https://github.com/indygreg/python-build-standalone - it looks like they've bundled a Conda environment using https://github.com/conda/constructor

I wrote up detailed notes on how I solved the Python bundling problem in https://simonwillison.net/2021/Sep/8/datasette-desktop/#how-... and in https://til.simonwillison.net/electron/python-inside-electro...

Had to build a standalone python app with pyinstaller for BitRook and it was surprisingly hard!

Wish I had some of these tutorials. Thanks for posting.

I'm aware that you are doing something similar, but interesting that both used different approaches.

I feel like this is going to be really great for people getting started with programming. A Big Fat Binary is really what early programmers need.

Now imagine that it comes with Postgres.app as well (with a little glue to turn it on via a button in the Jupyter UI, and automatic off when the server shuts down...), and the xeus-sql kernel.

If this gets halfway decent reviews, this is how I'm going to tell people to learn to program. No more needing to learn how the terminal works, explaining what a binary is, what an interpreter is, etc. All of that can come later.

A fat binary might also be a good way to share a notebook with a non-programmer. To make a comparison, right now it's easy to share an Excel spreadsheet because "everybody" has Excel. But hard to share a Jupyter notebook because people have to get through the Python installation process. A simple one-and-done installer for Jupyter would make this a lot easier.

so true! I've been trying to figure out a way to get my social sciences student friend learn programming and I was dreading to install python/conda/jupyter ? on their computer. A single-click jupyter app with electron indeed sounds like a lifesaver.

Notebooks are really getting real. I am just trying to figure out some of the implications of VS Code notebook support, in addition to remote sessions and .NET Interactive.

PowerShell, C#, F#, Python, in notebooks: https://devblogs.microsoft.com/dotnet/net-interactive-is-her...

I was able to run a VSCode session ("Code Space") hosted by GutHub, the front end on an unmodified Amazon Kindle Fire HD that I got for $100.

Another case of Microsoft playing the role of iceberg to Jupyter.org's Titanic? Somehow, I think not. They all seem to be having fun. But I'm an optimist. I think notebooks are a big step forward.

This is just badly written announcement, which doesn’t answer basic questions:

1) How is JupyterLab App different from the JupyterLab? Is it just the same thing packaged in the electron app?

2) It comes with it’s own conda environment. But can it ran in my conda environment? Which is pretty much a requirement for any serious project.

For #2: I tried it, downloaded the large file and installed. Then on launch, it couldn't find any JupyterLab install from my Conda environments, and it asked me to find it. I just uninstalled. I'm not sure what it wants or how it interacts with my many Conda envs and it's too much hassle to try and sort that out right now.

Same here - I filed a bug. I've got Jupyter-lab running, I have a clean venv - but couldn't start jupyterlab_app - even when I manually told it where to find the module in my .venv.

Based at on the comments it looks like it is Jupyter Lab just packaged in an electron app.

I am unsure of what problem this is trying to solve as common use is to use Jupyter Lab remotely and then tunnel in to run excitements on a large cloud instance.

I run Jupyter Lab locally, so it would be nice to run it as separate app, but I need it to run from me env, of course.

I’ve written an overview of the Jupyter Notebooks ecosystem with overviews on the different apps, IDEs and cloud services around notebooks including: JupyterLab, Jupyter Notebook, PyCharm, JetBrains DataSpell, VS Code, cloud services like free Binder, Google Colab, JetBrains Datalore, Amazon SageMaker as well GitHub’s built-in support of rendering notebooks as they do with markdown documents.

https://docs.servicestack.net/jupyter-notebooks

Looks pretty cool. I feel like I would be tempted to point people towards this rather than anaconda if they're just going to dip their toes into the python world.

Point beginners to python.org and give them more credit for what they can learn. No one really needs Anaconda. If you like the conda package manager without all the 3rd party libraries, you can install miniconda but there’s no reason for beginners to start with it.

Installing the language and trying to figure out if its working is a big hurdle to a lot of beginners. Getting an intuitive interface is too. CLI is not intuitive to a first time coder.

A single download with relevant packages, bundled python env, and a nice front end interface (jupyterlab) sounds like a great idea to me.

I dont expect this to go down well but here goes.

What I really want to be able to do is point people to the Windows Store python / Apple default python.

This may not be the norm, but I have found Anaconda to be extremely useful because I get 90% of the packages I need in a single blob. Certain networks don't allow you to go around pip installing packages and it is easier to push through a single approval than 20 when a major update comes along.

Yep. I use Anaconda fairly frequently, and it's consistently buggy on both the UI and CLI front; this seems like a better alternative for beginners at least. On the flip side, I'm not sure I like that it's yet another electron app.

This is a godsend to those of us with way too many browser tabs open all the time. Don't get me wrong, I like starting up Jupyterlab with docker-compose and hacking away, but I hate hunting for the tab.

You should try out tab groups: https://blog.google/products/chrome/manage-tabs-with-google-...

I disable tabbed browsing altogether and rely on multiple workspaces + auto tiling WMs.

Then alt-tab on Windows or something like rofi finds your browser windows by name.

One more Electron app on my desktop - no, thanks. Just install anaconda and run jupyter with the browser, as good god intended :)

Or miniconda, full anaconda is kinda bloated soyware

Or org-babel - text file all the way

Yep, emacs org-mode (org-babel for code exec, etc) is such an awesome datascience platform, I wish more knew about it and used it. One primary issue I have sometimes though is the barrier to entry for others to use, as everyone has a favorite editor and only emacs really properly handles org files, but, I have also found that it's not that hard to put the notebooks in a ci pipeline that processes so people can just submit pr's independent of using emacs and still see the results. What they miss though is the interactive nature of org-babel.

Maybe someone can share their methods,

I find notebooks tend to get messy very fast, a lot of scrolling and forgetting where certain cells are and what context is at the point, did you do any tests before, has a variable changed.

What I wanted was a production panel and a explore panel. To separate the exploring from the production code.

Maybe panels, maybe colour coded maybe hiding cells except a title. Anyway to stop the mindless scrolling.

Cells should be searchable via the first comment similar to sublime @funtion_name will take you to that function.

I spend half my time scrolling around getting lost.

I often cut cells and move them around to a new context which is time consuming and I have lost cells more than once by forgetting to paste them and copying something else mid way scrolling up the page. Would be nice to have a have a panel for saved cells where I can call by !call:cell_name or similar.

Notebooks are very helpful, has anyone found any ways to solve these problems?

If you're a (neo)vim user, I highly recommend using something like https://github.com/hkupty/iron.nvim .

Using this, I never have to copy and paste "production code" into "exploration code/notebook", because I simply select the part that I want to test in the production code, and then type in some key mapping to run it.

I'm working on an open-source desktop app [0] similar to Jupyter but more oriented toward non-data-science developer workflows like querying/joining data from multiple databases and scripting and graphing for internal reporting.

Another similar tool, but maybe more data science focused, is Simon Willison's Datasette [1].

[0] https://github.com/multiprocessio/datastation

[1] https://github.com/simonw/datasette

I've been using a poor-man's version of this using a tab-to-window chrome extension for a while https://chrome.google.com/webstore/detail/tab-to-windowpopup...

seems like the desktop app doesn't support extensions yet (need my vim and snippets), so I'll stick to the original for now.

It was great to finally get PlotAPI (https://plotapi.com) working with Jupyter Lab, Notebook, Google Colab, and VS Code...

They all have their own versions of packages used for displaying video/images/HTML, and how they handle the inclusion of external JavaScript, e.g. where Jupyter Notebook (classic) uses Require JS

I hope the Desktop App doesn't introduce another variation!

Can you change the built in environment by installing/removing packages or picking a different or new environment altogether?

Market is moving towards a democratization of ML. Apps like this and others like SweetViz & BitRook are helping it make a reality.

With the large increase of people getting into data science these kinds of apps that help them to start using popular libraries and make coding easier is crucial.

I would suggest to keep the app as an independent front end Letting users choose the server back end.

Eagerly awaiting the Homebrew cask for this (yes I know I should probably make it myself and share).

What's wrong with pip install?

What problem is this trying to solve?

Maybe novice programmers who don't know about pip?

Sadly, pip install (at least on macOS) is a huge barrier to entry.

First, install Python 3.

Oh wait... you probably need Homebrew to do that. So install Homebrew.

... but Homebrew needs Xcode, so install that first.

OK, assuming you've now got a working python3, you should probably use a virtual environment to avoid messing up your system. So learn what those are.

Or maybe you should use pipx for that? So go and learn what pipx is, how to install it and how to use it.

Done all of that? Great, now you can install JupyterLab and start using it!

I'm totally ignorant about the macOS installing issue, shouldn't the binaries for mac suffice?

https://www.python.org/downloads/release/python-397/

Not unless you want to janitor the python install and nurse it along manually through minor and major updates. Most folks will just want to use pyenv or similar: https://github.com/pyenv/pyenv

Sadly everything you need to know about Python on macOS is in this xkcd: https://m.xkcd.com/1987/

Is there still no way to disable the blinking cursor?

How do you install extra packages? (sympy, etc)

Can I change shortcuts to emacs friendly ones?

If only Mathematica would just go Python…

Well you can manage to run the Wolfram Engine through a jupyter kernel directly in VS Code. Although, I believe when I set it up the output was an image, no matter the object being returned (for instance 2+3 would return an image of 5 black on white).