
JupyterLab is ready for users - thenipper
https://blog.jupyter.org/jupyterlab-is-ready-for-users-5a6f039b8906
======
danielvf
I'll be teaching a group of nine and ten years olds to code. I'm planning on
using Jupyter.

What I'd really like to do is make a multiplayer naval game, with each player
controlling their ship from their own notebook. Players would start out by
running commands like fire(range=400, bearing=120) right from a cell, but
would later be able automate their ship - for example, pick the nearest enemy,
get the range, and plug that into firing automatically at it.

My server would be projecting a big map of the world up on the wall.

However, to do this nicely, I need the ability to make a cell (or a function
defined in a cell) run every X milliseconds. I know I can do this for one
cell, with a loop and sleep function, but I'd really rather have multiple
cells/functions "running", so we can break the code into smaller chunks, and
to let them build their own ship UIs.

Any advice on how to do this in Juptyer with Python? In an ideal world, I'd
just "tag" a cell somehow so that it ran periodically.

~~~
in9
To be totally honest, even though I love Jupyter notebooks, I wouldn't teach
someone to code using it. See, as someone who's not, originally a programmer,
I believe that teaching someone to code is intertwined with teaching
(gradually) workflows and environments.

Now, Jupyter is great (I'm a statistician btw) precisely because you have a
presentable literate programming tool. That is extremely valuable for data
analysis and model building.

Now, If you are teaching programming in it self, I think the terminal + text
editor is important since that is a step towards how things are done irl. But
if you think that the terminal is too much for your audience, just go for
IDLE, which has many advantages for python development + teaching, and is
already a step towards text editor + terminal or IDE level development.

~~~
dragonwriter
> Now, If you are teaching programming in it self, I think the terminal + text
> editor is important since that is a step towards how things are done irl.

Jupyter (and similar) Notebooks are a way things are done "in real life"; they
aren't just for entertainment purposes; and JupyterLab blends that into an IDE
and the IDE with notebooks approach is also a way things have been done "in
real life"; both with third-party tools incorporating Jupyter (and earlier
IPython) notebooks, and with other IDE's incorporating notebook-style
interaction.

Which isn't to say that there aren't arguments for teaching program outside of
the notebook environment rather than within it (though the notebook is kind of
a super REPL, and REPLs seem to me to be great tools for teaching), but that
not using notebooks is better because it is how things are done "in real life"
is just taking a highly selective view of real life.

------
RobinL
Absolutely love JupyterLab. Having used ipython for years, I switched to
Jupyter Lab about 6 months ago and never looked back.

The things I'm most impressed with (relative to Jupyter Notebooks, which were
already amazing):

\- The ability to render .geojson, .json, markdown, Vega and Vega lite files,
and integrate external tools like Voyager.

\- The new terminal is a joy to use compared to what came before it

\- The ability to set out multiple windows easily, much like an IDE

\- The plugin ecosystem means that we can start writing custom components for
the analytical platform we're building.

Thanks so much to the team!

~~~
SimonBiggs
Also the modular packages they have built are amazing. They have a node
package called @jupyterlab/services which lets you write typescript code for
your own libraries that can then call the Jupyter Server.

An example of using JupyterLab services is provided on their GitHub:

[https://github.com/jupyterlab/jupyterlab/tree/master/package...](https://github.com/jupyterlab/jupyterlab/tree/master/packages/services/examples/typescript-
browser-with-output)

Because of the way they built their packages I have been able to stand on the
shoulder of giants and build the following tool:

[https://github.com/SimonBiggs/scriptedforms](https://github.com/SimonBiggs/scriptedforms)

I am very grateful to the JupyterLab team. They have built something
brilliant.

~~~
pwang
Holy shit. ScriptedForms is amazing. Is there any possibility you would
consider selling a dual-licensed version that is not AGPL3?

------
Quenty
If you like Juypter, Google colabs has a google-docs style juypter notebook
that’s quite good. It’s nice for collaboration.

[https://colab.research.google.com/notebook](https://colab.research.google.com/notebook)

~~~
abetlen
There's also an official Google drive extension for jupyterlab worth checking
out. I know they demoed it a few times before the v1.0 release it looks very
promising.

[https://github.com/jupyterlab/jupyterlab-google-
drive](https://github.com/jupyterlab/jupyterlab-google-drive)

Also worth checking out is the renderers, the vega and geojson ones are really
cool.

~~~
dragonwriter
> There's also an official Google drive extension for jupyterlab worth
> checking out.

As the readme states, the realtime API it relies on has been deprecated.

------
qubex
_Mathematica_ is wonderful in terms of sheer computational power, but the
notebook interface it presents is hopelessly outclassed nowadays by
initiatives such as these. I keep hoping Wolfram will spring some impressive
new interface on us that will enhance usability for power users (rather than
their weird attempts at bringing ‘computation’ to random casual users), but...
I'm giving up hope.

This looks very impressive.

~~~
pmart123
As someone who used Matlab and Mathematica in college, I'm not sure I'd want
to have a closed source solution really take off again at this point. While
they provided great products and documentation, they also made it much more
difficult to share code/visualizations due to restrictive and expensive
licensing. Ultimately, I think the ability to share information easily should
help spur scientific advancement.

~~~
bitL
That's all nice but you go to real-world space/robotics/drones etc. shops and
they all use Matlab or similar for their scientific computation and validation
and treat Jupyter stack as a toy. Similar to telling a photographer to use
Linux because there is GIMP and that should be enough for them.

~~~
_coveredInBees
Yeah, I work at a startup where we specialize in signal processing + ML. We
have a robust set of infrastructure in MATLAB (use our own ML libraries rather
than MATLAB's libs) and try as we might, we haven't been able to switch
altogether to Python (despite a number of us being fans of Python).

MATLAB has a TON of things that you don't get with Python + Numpy + Scipy.
Complicated plots/graphics with interactivity are a pain point in Python
compared to MATLAB. Similarly, the debugging capabilities in MATLAB are truly
magical compared to a pretty terrible experience on the Python side of things.
Even though we deploy software in Python, we are much faster prototyping in
MATLAB and deploying finalized algorithms/software to Python than trying to do
everything in Python from the get go. MATLAB's JIT is also pretty great and
while Numba is pretty great, it still requires more work and can be brittle at
times.

~~~
simonw
Have you tried bokeh for interactive visualizations?
[https://bokeh.pydata.org/en/latest/](https://bokeh.pydata.org/en/latest/)

------
teekert
Loving Jupyter, I use it every day and for sure I will try this out. What I do
miss though is good separation between code and data, it is a pain when
someone just takes a look at your notebook and it autosaves, the code block
counters reset, this alters the file and GIT reports a lot of alterations.

~~~
tda
This so much. It is my only real complaint about notebooks. Would be so much
nicer if a notebook was split in two files, like `my-notebook.input.ipynb` and
`my-notebook.output.ipynb`, where `my-notebook.input.ipynb` would only contain
code and be editable with any text editor similar to a .md file (and not some
verbose xml). The output would contain all outputs, so that would be easily
separated from the input if needed.

I can see the benefits of stuffing everything into a single file, but
separating would be so much better IMHO. Version control is too important to
mess with. Sometimes I want input and output to be version controlled,
sometimes I only want the input. By splitting I can easily do that with simple
.gitignore rules.

~~~
carreau
The notebook server have "contents managers" which decide how notebooks get
stored. It is perfectly possible to write what you request, and some users
have done it:
[https://github.com/aaren/notedown](https://github.com/aaren/notedown) here
without the outputs but it's easy enough to add.

The other possibility is to export a notebook as an actual files and folder
tree:
[https://github.com/takluyver/nbexplode](https://github.com/takluyver/nbexplode)
so rich object (png, svg... etc) are independently editable.

It though can be challenging to have work well because of different
filesystems.

You can even go further and tell the server to store nothing on disk but in a
database, postgres for example
:[https://github.com/quantopian/pgcontents](https://github.com/quantopian/pgcontents)

------
sinab
This is really exciting for the team! However I don't think that I am
particularly sold on the notebook style of coding.. its possible that I simply
haven't found a good use case for it, can anyone suggest an example where the
notebook style outperforms a simple script based style?

For reference, I use Matlab and Mathematica pretty heavily, and python in a
text editor like sublime along with a terminal running ipython shell.

~~~
veritas3241
I find notebooks to be great for prototyping longer pipelines or processes.
Instead of having to constantly get fresh data, particularly if it's from an
external API, the notebook can persist the data in memory and you can iterate
on the next piece of the process right there.

I then take that and make it a more formal script/process w/ version control
and all that fun stuff. They're also really great for learning. I just
wouldn't put them in production :-)

~~~
analog31
I'm using Python for lab automation, so my data comes fresh from an
experiment. I've found that keeping stuff in memory is extremely convenient
until the kernel shuts down for some reason (e.g., I inadvertently kill it
while forgetting that I've left a notebook open).

Still, I love having my data collection scripts documented right there with
the subsequent analysis. So, I've disciplined myself to handle experimental
data in one of two ways:

* For "small" data, format it as a Python thing (list, dict, whatever is appropriate), and paste it into the next cell as an input. I haven't found a way to do this automatically, and I'm careful not to make things too automatic lest I run a cell and over-write old data.

* For "big" data, dump it to a file. I just turn the system time into a filename, to avoid over-writing an old file.

I don't think I've come up with the last word, on using Jupyter as a self data
collecting lab notebook, nor am I yet 100% certain that it's even a good idea.
This is a work in progress, but much better than anything else I've ever
tried. For complicated experiments, I still create stand alone Python programs
to control things.

------
cup-of-tea
So I can now use a decent text editor (emacs) to edit Jupyer notebooks? Great!
I do wish it was possible to interleave languages like with org-mode, though.
I've yet to find a literate programming/notebook format I'm truly happy with.

Edit: oh.. I misread. It doesn't support using external editors. All I want is
some way to edit those text boxes with another program. I can't do any serious
work in a web browser. It's awful.

~~~
rerx
Have you tried "EIN" in Emacs? [https://github.com/millejoh/emacs-ipython-
notebook](https://github.com/millejoh/emacs-ipython-notebook)

I have used it quite productively for a while, but at the moment have mostly
moved back to the browser for my notebooks. I can recommend to collect larger
functions in a separate source file (for Emacs editing bliss) which you import
to the notebook. [import helpers; reload(helpers)]

~~~
cup-of-tea
I did try it, but it seemed to break "undo" unfortunately. That's something
that will make me stop using a package immediately. I also tried ob-ipython
for org-mode but found it not ready unfortunately. I think I will have to do
what you suggest and just minimise the amount of code written in the notebook
itself.

------
smortaz
On behalf of Azure Notebooks team, a huge congrats to the team!

If you like to try it, pick any of your libraries, right click and select
“open in JupyterLab”.

~~~
carreau
Much love from the Jupyter Team to the Azure Notebook team !

------
mirages
I'd really like 1 thing from those articles. I didn't knew what Jupyter was in
first place.

So please dear authors when I click on your articles I'd like to have a single
sentence somewhere on the landing zone where I can easily figure what we're
talking about and not having to read entire paragraphs

Thanks,

~~~
afshin
The closest thing to what you're asking for is the first image in the post,
which is a screenshot that has this caption:

> JupyterLab is an interactive development environment for working with
> notebooks, code, and data.

~~~
isaiahg
But what are jupyter notebooks? Had to Google it to find out. Still not sure
what it does.

~~~
Wehrdo
This isn't meant to be snarky, but maybe this post just isn't for you, in the
same way that posts about Ruby on Rails simply aren't for me.

On the other hand, if you use Python, you should definitely check out Jupyter
notebooks (formerly IPython notebooks, and now JupyterLab, I guess). They're
useful when prototyping data pipelines, since the state of the interpreter is
saved, letting you iterate on ideas and see the outputs quickly.

------
shalabhc
If you like Jupyter you might also like
[https://beta.observablehq.com/](https://beta.observablehq.com/) which was
released recently, in case you missed it.

------
mav3r1ck
I love the term "reproducible computational narratives" from their post. This
is a great step toward making software accessible for everyone. In addition,
imagine how transparent governments and open source communities can be by
helping explain the algorithms in use with a clear provided sense of
understanding for everyone. On the project level, it can be useful for keeping
it simple. It's all good stuff!

~~~
po84
Though a year old, [https://www.oreilly.com/ideas/the-state-of-
jupyter](https://www.oreilly.com/ideas/the-state-of-jupyter) might interest
you as well.

------
fizixer
So let's say I am progressing inside a jupyter notebook top to bottom. I run
code blocks, then some markdown, then code blocks, and so on.

At some point I need to drop down to the terminal to run something. I run
commands in the terminal I collect some results or collect some info and go
back to my notebook to resume my work inside it.

Later I need to look up something in a text file. I open a certain text file.
Browse to a certain line number, read that line, maybe edit the text file, and
close the text file to go back to my notebook.

Does JupyterLab keep a record of the point in my progress in the notebook when
I switched to the terminal or the text file, what I ran in the terminal, and
what info was used? If I edited the text file, what was before and after of
the text file? In other words, does JupyterLab help with the chronology of
workflow events?

If not, I don't see how this is anything other than hundreds of "IDE"s out
there.

Notebook format has its own issues, but going back to IDE is not a solution.
Offering both notebook and an IDE at the same time and leaving it up to the
user to make the best of the combo is not a solution either, unless the
offering helps some kind of a way of eliminating the cons of either format.

~~~
fizixer
Replying to my own comment, I have a plot and a text file open side by side. I
want to change a value in the text file and I want the plot to be updated
automatically. The update might not be trivial, behind the scenes maybe the
text file is an input to a simulation that runs for a minute, then computes
some values in a table that are used for the plot. Can Jupyter allow you to do
that?

Point being, offering an IDE in 2018 is not interesting unless you added
something "smart" to the IDE that makes the life of the engineer/scientist
easier compared to the rest. Otherwise, IDE's are being developed for the last
three decades or more.

~~~
wenc
With respect to your parent comment: the IDE can be made to log UI context
switches, but it cannot interpret intention. This is a very unusual and I
suspect very sub-optimal thing for an IDE to support, whatever year it is
supposed to have been built. If you really want those events to be recorded,
you need to either annotate your code, or programatically have it invoke
something.

As for graphics updating on file-change event, that can probably be supported
through an extension. This is similar to how certain LaTeX editors
automatically re-render the doc on a change-event.

------
KKKKkkkk1
_At the same time, the community has faced challenges in using various
software workflows with the notebook alone, such as running code from text
files interactively. The classic Jupyter Notebook, built on web technologies
from 2011, is also difficult to customize and extend._

Do I read this correctly as hinting that Jupyter Notebook is being replaced by
an IDE?

~~~
jasongrout
We should disambiguate the term "jupyter notebook" here. Jupyter notebooks, as
documents that contain code, markdown, math, widgets, etc., are a central
feature of JupyterLab. Jupyter notebooks are not going away, and are getting
better in JupyterLab.

The "Jupyter Notebook" web application (i.e., the browser application that was
originally released in 2011) will eventually be replaced with JupyterLab.

------
fredley
Jupyter was already one of the greatest Python projects out there, this just
takes it to another level. I can't wait to use this. Enormous kudos to the
Jupyter team.

------
goerz
I very heavily rely on the "official" notebook extensions from
[https://github.com/ipython-
contrib/jupyter_contrib_nbextensi...](https://github.com/ipython-
contrib/jupyter_contrib_nbextensions)

This especially includes things like "Table of Contents", "Variable
Inspector", "Ruler", and "Execute Time". How easy will it be to have all of
this functionality in the JupyterLab notebooks? There's certainly advantages
to having data/terminals/notebooks in an IDE-style layout, but for the moment
it would still be two steps back, one step forward for me personally. This is
to disparage the effort, JupyterLab clearly is the future!

~~~
carreau
First of all these are not "official" (hence why it's a different organisation
on GitHub) and all is maintained by community.

It will take some time to port all the existing extensions, but the good news
is that JupyterLab has been thought to work with extensions (actually
everything in JupyterLab is an extension with no privileged component), so it
will be easier to write these for JupyterLab than for current notebook.

The documentation on writing extension is also way better than for Classic
notebook, and we had new contributor writing extension in 2 to 3 hours.

So we encourage you to try and send us feedback !

~~~
goerz
Will do! And thanks for all the great work around the Jupyter ecosystem. I
didn't mean to come across as too critical!

~~~
carreau
Didn't meant to imply you were critical, sorry if it's how I expressed myself.
Just trying to explain what did not ended in the blog post. Thanks!

------
kfk
Been trying to use JupyterLab over the weekend and had some issues with it.
The idea is great though. I also look forward for the extensions. Data
pipelines and dashboards can be built in visual applications much more quickly
than with coding, so maybe we can now program extensions for that? Also, with
vegalite and flask you can build dashboards from scratch and jupyterlab is
great there (as you can mix code and notebooks). I think jupyterlab is very
well positioned for being a complete end to end analytics tool from raw data
to dashboards and visuals. If the extensions are powerful enough on the UI
side, who knows? Maybe even business users could use jupyterlab.

------
ibdf
I like Medium, but I always struggle to find a link to the company's site. Is
this hidden somewhere? I had to google it to find it, not that it was hard,
but I thought it would somewhere on their Medium blog.

~~~
carreau
Oh ! Thanks, we'll try to fix that ! BTW we're not a company, but sponsored by
a non profit, academics and volunteers mostly.

~~~
mistermann
As someone new to not just Jupyter (and for someone coming from the Microsoft
c# world, mind = blown, many kudos)....do you (or anyone else reading) happen
to know off the top of your head a particularly well done, information dense
(not dumbed down, showing _what_ you can do, but skipping a hand holding
explanation, one can go get that elsewhere) notebook that demonstrates a broad
range of Pandas & Jupyter capabilities?

~~~
adricnet
The Nature article and notebooks from a few years back are still pretty good
for demos, though everything has updated since then , especially iPython ->
Jupyter.

[https://www.nature.com/news/interactive-notebooks-sharing-
th...](https://www.nature.com/news/interactive-notebooks-sharing-the-
code-1.16261)

hth

adric

~~~
carreau
s/iPython/IPython/g otherwise it looks like an Apple product :-)

------
skshetry
When i checked two weeks ago, there was a bug that when opened a notebook with
large number of cells(~200), in firefox, it would freeze for about 10 seconds
if the window was resized. The problem, as i know, only occurs in Firefox, not
in Chrome.

This was problematic, especially for me, as I open documentation on other side
of the window and keep resizing the window as part of my habit. But, overall
JupyterLab was great. You can work on the same notebook side by side too and
has a file manager/viewer panel.

~~~
jasongrout
Please try it again. In the last few weeks we've made some changes that
drastically sped up things in Firefox, and we have plans for more changes in
the pipeline.

See
[https://github.com/jupyterlab/jupyterlab/pull/3805](https://github.com/jupyterlab/jupyterlab/pull/3805)
and
[https://github.com/jupyterlab/jupyterlab/pull/3802](https://github.com/jupyterlab/jupyterlab/pull/3802)
for more details.

------
wodenokoto
This looks like it could be quite the competitor to RStudio!

~~~
carreau
Complementary ! We love R-Studio (and JupyterHub can run R-Studio). R-Studio
is still more tightly integrated with R, but we are progressing.

It would be great to have community plugins that make R-Studio able to open
Jupyter files, and JupyterLab open R-Studio files !

------
SimonBiggs
Woohoo! Congratulations JupyterLab team. It is a brilliant thing being built.

------
lifeisstillgood
I am going to ask a very dumb question, but if I am not an exploratory data
scientist, what and how do i use jupyter/ipython for? I keep meaning to try it
out but never quite got round to anything but toy stuff.

how does it fit into a developer workflow, or do i need a different mindset?

what should I try to do with this beta to get my mind right is probably the
best question

~~~
wenc
No, it's a fair question.

To be honest, if you're not doing exploration or quick prototyping work (you
don't have to be a data scientist though), Jupyter might not be that useful to
you.

Jupyter is really useful when you have intermediate results that you don't
want to keep regenerating. It lets you test different ideas at any given point
in the program without re-running everything above it -- kind of like a pause
button. (garden of forking paths) And if you do have to change any code, you
can change things in-situ without re-running the entire program. It's like
programming with a tape-recorder with mutable state.... hmm, ok maybe that
isn't a good analogy, but close enough.

For quick scripts, I reach for vim and run my code on the console, and insert
"import ipdb;ipdb.set_trace()" wherever I need breakpoints.

For more complex work where there are different permutations, and many
throwaway branches of ideas that I have to test, Jupyter (or any notebook type
tool) is way more useful.

------
techwizrd
I'm trying to get a JupyterHub or JupyterLab instance deployed at my
university. JupyterHub has documentation on deployment, authentication (e.g,.
LDAP, CAS), and so on. I'm guessing that JupyterLab will eventually get things
like this. Does anyone know if there will be a migration path for JupyterHub
to JupyterLab?

~~~
aeroevan
JupyterHub is the multi-user application which will proxy a single user
application. Jupyter notebook is the default single user app, but it can be
configured to use jupyterlab.

~~~
eigengrau
Also, it should be noted that, since it just proxies a single user notebook
server, JupyterHub doesn’t support any interaction, sharing, or other
collaboration between users (though one could implement some of that by
mounting an NFS share inside notebook containers). Still, I’ve found it quite
useful for teaching. IIRC, there’s also a project underway to bring
collaboration features to Jupyterhub.

~~~
carreau
To JupyterLab, yes it's working but google retired the real-time API, so the
project have seen some delay as we are reimplementing the Backend server where
we were hoping to use Google Drive. CoCalc (ex sagemath cloud) already have
real-time notebooks.

------
gd2
A key point - for me as a user unlikely to develop extensions- is buried some
paragraphs down. "JupyterLab 1.0 will eventually replace the classic Jupyter
Notebook. Throughout this transition, the same notebook document format will
be supported by both the classic Notebook and JupyterLab."

------
dman
Wanted to give a shout out to phosphor - the underlying UI framework used in
JupyterLab. Used it for some non JupyterLab use cases and found it a pleasure
to use. ([https://github.com/phosphorjs/](https://github.com/phosphorjs/))

------
yourapostasy
This is the closest I've seen anyone actually deliver upon the promise of
OpenDoc [1] and similar tech like KParts, but in a more user-accessible
packaging. I'll be interested to find out its scalability and performance. If
it renders only the part of a notebook that is visible, while continuing to
run threaded computations of hidden components, then that might help some of
the performance limitations I'm seeing people write about. That might be
important to scale up collaboration as well in the future.

[1]
[https://en.wikipedia.org/wiki/OpenDoc](https://en.wikipedia.org/wiki/OpenDoc)

~~~
carreau
It does render the all doc (at least for notebook) IIRC, but that an
implementation choice. As long as there is a model somewhere it could only
render what's visible.

Note that almost all the rendering is - for JupyterLab – client side, and that
for scaling we know of Single JupyterHub deployments that have close to 5k
users. Horizontal scaling of Hubs is improving, and we hope to have more
robust solution soon.

------
kpeterson
Love the original version of jupyter and this looks great too. Thanks for all
you guys do

------
zitterbewegung
I used the beta of Juypterlab and I was really impressed. Congrats on the
Juypter team for releasing this! I was at Juypter Day at 2016 and they were
talking about the roadmap to this feature. Its really exciting for this to
come out!

------
eoinmurray92
This is awesome - jupyter basically drives my whole company at
[https://kyso.io](https://kyso.io) we are gonna implement jupyterlab really
soon once we've done sufficient testing.

~~~
simsla
I think you have a typo (or mobile font problem) on the homepage. "platformin"
on Chrome Android.

------
laserson
Is it possible to have a notebook and a console using a single, shared kernel?

~~~
afshin
If you have a notebook open in JupyterLab with a running kernel, you can go to
the menu and open File > New > Console.

It will prompt you for what sort of kernel to use, including the ability to
use any currently running session.

------
monkmartinez
There is only one mention of Python in the entire post... there are 5 mention
of JavaScript. Recently, I have been mulling over the GUI creation problems
and packaging problems that still plague the Python ecosystem. That being just
the start of it...

I guess my love affair with Python is souring a bit. Compared to JavaScript it
seems like it has slowed to a crawl on the innovation front. That is, for
anything NOT related to machine learning.

I use Jupyter notebooks with Python all the time and only recently started
using them with Node.js it seems like JS is just killing it...

~~~
carreau
Haha, don't worry the Python side is still quite active, and IPython is still
evolving. JupyterLab is (so far) only a new UI. It still connects to all the
kernels via the same protocol in the back, and we were not willing to change
both at the same time. But thanks for caring and expressing concerns.

~~~
monkmartinez
The fact that the GUI is written in JS is my point. The reports of Python's
death... you heard it here first.

------
TheAlchemist
I've started using Jupyter Notebooks 2 years ago and I found it fantastic for
data exploration, analysis, quick coding and prototyping.

Switched to Jupyter Lab recently and I can only recommend it. It's an absolute
joy to work (I especially like the full screen mode - really great). Even for
simple tasks where I used to open file in Excel by default (when I just need
to take a look or do very simple operations), I now prefer the Jupyter Lab
experience.

Anyway, thanks for the excellent work !

------
madengr
Is there a way to integrate a debugger and browse variables? I have been using
Spyder for casual programming, and don’t think I could do without a debugger.

~~~
bocklund
In Python, the Jupyter notebook kernels are based on IPython which has some
magic commands for pdb debugging hooks.

If you want more then that, someone (maybe you) will build an extension at
some point.

------
raymondgh
I tried Jupyter Lab two weeks ago and found it to run unbearably slow. I'll
try it again eventually I suppose, very well could have been a local issue

~~~
jasongrout
Please try again. We had some drastic speedups with notebooks, particularly on
Firefox, in the last few weeks.

~~~
bosie
i installed it now (v0.31.8) via pip on centos7 with python 3.6. Switching to
a notebook tab takes about two seconds (notebook has 45 python code cells),
saving a texteditor with python code in it takes about 1 second. Chrome
Version 63.0.3239.132 on macosx (15" macbook pro). "regular" jupyter notebook
is instant on both things.

~~~
jasongrout
There are definitely more optimizations planned in the future. The
optimizations that happened in the last few weeks took it down from tens of
seconds to open and deal with large notebooks.

------
make3
Maybe this will motivate the otherwise great pycharm team to improve their
product's dismal Python jupyter notebook support

------
cdancette
I really hope they will add a panel to inspect current defined variables, like
in Matlab, that would be so useful!

~~~
SimonBiggs
The extension framework means anybody can build something like that. The
beauty of it is that because that feature is so useful it's almost guaranteed
someone will make it at some point.

------
bguberfain
Does anybody knows if with JupyterLab I will be able to keep some code
running, close the browser, and still get the output of the code afterwards?
For what I know, currently I have to keep the browser open if I want to
capture the output of a cell.

~~~
carreau
If you update the `notebook` package there should be a workaround. Messages
will be buffered on server-side until a client reconnect. It is still not
perfect, but get part of the way. One long term plan is to have server-side
model (not sure if it will be by default, or an extension), and have the
browser just be a vue on this. It is quite hard to design as many
visualisation libraries assume to be in a browser context, and have access to
DOM.

~~~
bguberfain
Buffering is indeed helpful, but will not solve the problem. I always thought
that a proxy server holding the current state and sending diffs to clients
would be enough, but it would still have issues with visualization libs. Is
there somewhere were this issue can be discussed and addressed? GitHub?

~~~
carreau
There are a couple of issues about that, a bit scattered around. And many
moving pieces. I agree that a proxy would be a nice thing, and IIRC someone
made a prototype. This also hook into the JupyterLab "StateDB"/"modeldb" work
and making it CRDT (Conflict-free Replicated Data Types) which is WIP
somewhere; but I'm not sure where the best place is to discuss this. Work may
happen on jupyter/notebook , jupyterlab/jupyterlab or maybe even
[https://github.com/phosphorjs/phosphor](https://github.com/phosphorjs/phosphor)
I would take my chance on the main mailing list/google group.

------
jiggunjer
What put me off Jupyter is that it can't do dynamic text. I can't link to a
variable in the code, such that the text updates when I run the code again
with new parameters. This would be a great feature for demos/presentations.

~~~
dragonwriter
> What put me off Jupyter is that it can't do dynamic text. I can't link to a
> variable in the code, such that the text updates when I run the code again
> with new parameters.

You can either output text (including HTML/Markdown) from a code cell, or (at
least for python, don't know of similar for other languages) use the Python
Markdown notebook extension to do this.

------
raonyguimaraes
I still cant get this plugin working with JupiterLab
[https://github.com/genepattern/jupyter-
wysiwyg](https://github.com/genepattern/jupyter-wysiwyg)

~~~
SylvainCorlay
This plugin is a classic notebook plugin, not a JupyterLab plugin
unfortunately.

------
lihan
I really care
[https://github.com/jupyter/notebook/issues/1647](https://github.com/jupyter/notebook/issues/1647)
more.

------
neumann
Just tried it and found it tremendously easy to use. Well done

One thing I couldn't seem to figure out is if it is possible to plot
interactive matplotlib plots (for getting mouseover values zooming etc).

------
djhworld
Anyone know of any maintained Docker images for this?

I'm not a fan of pip etc and prefer to isolate my notebooks in a docker
container.

EDIT: never mind, you can run it using the official images by executing
`start.sh jupyter lab`

------
Myrmornis
Is it clear yet how one will use text editors (emacs, vim) with JupyterLab?

~~~
qacek
Are you referring to editing text files or in notebooks?

~~~
Myrmornis
I'm interested in any jupyter workflows that allow me to use my text editor
and a terminal-based language REPL/shell.

In general,

\- I want to use my text editor to write any non-trivial function/class
implementations.

\- I want any substantial amount of code to be held and version-controlled in
regular files of code, not inside JSON.

\- I want to use the notebook for display (tables, figures, rendered
markdown/LaTeX, etc)

So the most important question is:

\- How do I conveniently work on a code file in my text editor, and then
execute code in the notebook so that the most recent variable definitions in
the code file are honored during the jupyter execution?

Also

\- How do I start a terminal-based REPL/shell that is sharing the same kernel
as the notebook? (Relevant to text editors, because this might be for example
an ipython shell running inside emacs, allowing me to easily evaluate
fragments of code in the text editor.)

There are more sophisticated things one could imagine, but I don't think I
want (e.g. evaluate a cell/notebook from the text editor, create a cell from
text editor).

~~~
qacek
I see, well you might get a better answer from a Jupyter dev. I use the
autoreload extension to automagically pull in my lastest code [1]. It usually
works. For your second question you can connect multiple frontends to the same
kernel [2].

[1]
[https://ipython.readthedocs.io/en/stable/config/extensions/a...](https://ipython.readthedocs.io/en/stable/config/extensions/autoreload.html)

[2] [https://jupyter-
notebook.readthedocs.io/en/stable/examples/N...](https://jupyter-
notebook.readthedocs.io/en/stable/examples/Notebook/Connecting%20with%20the%20Qt%20Console.html)

~~~
Myrmornis
Thanks, yes I'm somewhat familiar with the story under the current jupyter
notebook. E.g. when I'm feeling very energetic, I sometimes manage to come up
with the right series of shell invocations to get a notebook running in a
browser and a terminal python shell sharing the same kernel via `jupyter
console --existing`, with the right python version and virtualenv. Or even
have the shell running in emacs, though there's usually something broken
somewhere along the way in my setup.

I'm vaguely aware of autoreload but it seemed a bit confusing; there are
various similar-sounding alternatives.

------
stewbrew
Not a single note on how to debug code. Or did I miss something?

~~~
carreau
Debugging story has not changed. The core team is in discussions with some
large company to get funding and work on debugging protocol and collaborate.

------
ChrisRackauckas
Excited for a new Julia IDE. Seems like it's a nice interactive style which
surprisingly doesn't feel like it has the kludge of the notebooks.

~~~
carreau
We don't have enough Julia developers involved ! It would be great to have
more feedback and patches !

------
pknerd
I am a heavy PyCharm user, will try it as I am gradually shifting to
Notebooks. This IDE should help for a smooth transition.

------
tzakrajs
Give me collaborative editing please. It's a great potential feature for pair
programming or instructing with Jupyter.

~~~
qacek
Have you tried [https://github.com/jupyterlab/jupyterlab-google-
drive](https://github.com/jupyterlab/jupyterlab-google-drive)?

~~~
carreau
Unfortunately Google retired the Google Drive API, so you can't create new
application the use RT. So while it works, there is no point in releasing it.

------
bllguo
If I can have a console view simultaneously with everything else, I may
finally switch to Python

------
monkeydust
Is JuypterLab available on a cloud service? I use azure notebook a lot, it's
great.

~~~
manigandham
It's already available on Azure Notebooks:
[https://news.ycombinator.com/item?id=16422217](https://news.ycombinator.com/item?id=16422217)

>> If you like to try it, pick any of your libraries, right click and select
“open in JupyterLab”.

------
neves
How does this affects the other environments? Will this be the demise of R
Studio?

~~~
minimaxir
RStudio has had a server-based semi-collab SKU since before JupyterHub was
even in development:
[https://www.rstudio.com/products/rstudio/](https://www.rstudio.com/products/rstudio/)

~~~
cag_ii
What does "SKU" mean in this context?

~~~
minimaxir
Meant product, but brain was failing at time of comment.

------
r0cky
What would be the best way to install JupyterLab on a fresh Mac?

------
sandGorgon
is there now a viable way to create multi-user read-only notebooks ?

so that a data scientist can prototype a dashboard on jupyter and then
multiple people can use the dashboard ?

------
agumonkey
It's a bit of a mathematica for the current era :)

------
kazakx
Every programming language needs something like this!

~~~
carreau
That's why Jupyter support more than 60 languages
([https://github.com/jupyter/jupyter/wiki/Jupyter-
kernels](https://github.com/jupyter/jupyter/wiki/Jupyter-kernels)) which
language did you had in mind ?

~~~
mistermann
Perhaps a dumb question, but do those languages tend to have wrappers for
common Python libraries like Pandas?

~~~
yorwba
I doubt it. Python is not very embedding-friendly. You might be able to bridge
the gap via the foreign function interface, but it's unlikely that the Pandas
API will feel as comfortable in another language that it wasn't designed for.

~~~
carreau
What you can do is the opposite, run Python as the main language and integrate
with other. There are demos around of notebook with multiple languages. Old
example I wrote: Python, R, Rust, C, Cython, Julia and Fortran all calling
each others: [https://matthiasbussonnier.com/posts/23-Cross-Language-
Integ...](https://matthiasbussonnier.com/posts/23-Cross-Language-
Integration.html)

------
dsign
Can't wait to put my paws on this!!!

------
gdelfino01
With no support for Microsoft IE or Edge, this cannot be used in numerous
enterprise environments where installing alternative browsers is not allowed.

~~~
carreau
No support does not mean that it won't work. As this is an open-source and
free tool, the support is announced only for the publicly available code which
is regularly tested and fixed. Now if a company want to pitch in, and sell
IE/Edge support that would be great. Even better would be windows developers
to contribute fixes back until the quality and regular fixes on IE/Edge make
it possible to officially say they are supported.

------
pjmlp
I guess we just killed the demo site.

------
nmca
Those sliders look sweet :)

------
rayalez
Will this be in anaconda?

~~~
carreau
Yes, it may already be, but an older version. It will be on cada-forge at
least ([https://conda-forge.org/](https://conda-forge.org/)) but it may take a
few hours to appear.

------
kishoresurana
Does it support Intellisense?

