
Jupyter Notebook 5.0 - sornars
http://blog.jupyter.org/2017/04/04/jupyter-notebook-5-0/
======
minimaxir
For those who use R, I strongly recommend looking into R Notebooks
([http://rmarkdown.rstudio.com/r_notebooks.html](http://rmarkdown.rstudio.com/r_notebooks.html)),
as there is a lot more versatility involved, especially over the
Jupyter/IRKernel approach. Although it's R only, unfortunately (you _can_ run
Python code in it but not the way you expect)

I'd like to see some things ported into Jupyter from R Notebooks, like
JavaScript data tables and the separation of code and output, making it easy
to version control only the code. (Atleast this 5.0 release makes tables
nonugly)

~~~
carreau
It would be great to sit with the Rstudio-notebooks developers and user and
discuss how we could get the two platform to converge and be more
interoperable. I guess both team have a lot on their plate, and we would need
more manpower, but understanding and collaborating with other project for the
good of user is always something the Jupyter team is happy to do.

~~~
imcoconut
The jupyter team has been working on jupyter lab which is a more r studio
style environment. It incorperates notebooks, terminals, file editing,
traditional ipython console, plus some other cool stuff in a web ide. You
should be able to use an R jupyter kernel with it.

It's in alpha right now but they're making crazy fast progress on it. I've
been using it and it's awesome

~~~
carreau
Yes I know I'm one of the Jupyter dev :-) there is still a difference in
notebook format and protocols. In that sens JupyterLab is not more compatible
with Rstudio than the normal notebook.

~~~
imcoconut
Lol, sorry - well hopefully someone else reading this thread can find out
about jupyter lab. it really is amazing.

Thanks so much for all your hard work!

------
FiReaNG3L
The only thing I want from Jupyter notebook is easy version control workflow -
not sure what's the best option is right now but last time I checked it was
'delete all outputs before commit' which is great in many cases.

~~~
m_mueller
This very much. I'd like for Jupyter to have an option to keep the cell code
in individual python files in th backend, so you can just check in those to
VCS. It would furthermore allow outside python code to import code from
notebooks if jupyter would just provide a simple __init__.py file together
with the cell files.

~~~
carreau
So you are asking for
[https://github.com/takluyver/nbexplode](https://github.com/takluyver/nbexplode)
and [https://github.com/ipython/ipynb](https://github.com/ipython/ipynb)
respectively. There just not maintained enough to be in the core :-)

------
zeptomu
Did anybody succeed in deploying Jupyter into a multi-user environment? I know
there is jupyterhub and some people deployed it for selected _trustworthy_
users (e.g. in a university course context or a company's intranet), but AFAIK
it hasn't been deployed in production to potential untrustworthy users.
Current approaches seem to rely on the idea to sandbox you in a Docker
environment, but mostly these are work-in-progress solutions and I am not sure
how much more secure they are, beside the fact that also authentication and
persistent storage issues have to be solved.

The obvious problem is that accessing Jupyter is technically similar to
allowing full shell-access and you have to deal with local privilege
escalation, but I wonder if there has been any progress. I evaluated to use it
as a UI for domain-specific applications that give users some kind of
graphical shell, but in the end I decided against it, because of security
concerns.

~~~
williamstein
[https://cloud.sagemath.com](https://cloud.sagemath.com) deploys Jupyter into
a multi-user environment. It's used by hundreds of courses for teaching across
the world. Our Jupyter deployment also supports realtime synchronization
(multiple people editing at once like Google docs) and recording of the
complete history of the document. I've also spent the last few weeks on a
complete rewrite of Jupyter __from scratch __using React to provide more
robust realtime sync support, faster startup, and better integration with the
rest of our platform; this rewrite is of course not live yet.

~~~
sandGorgon
This is incredible. I have been wondering what a react port of jupyter would
look like. Is this opensource ?

Any learning from multi-user deployment ? We are trying to do this internally
inside our company and jupyter hub is a little hard to grok.

I know of a lot of people who would pay for a faster jupyter that can also be
run as a standalone dashboard/script - without the heavy duty interactive
kernels. Basically reduce the prototype-deploy loop.

Check some of the comments here -
[https://news.ycombinator.com/item?id=14033129](https://news.ycombinator.com/item?id=14033129)

~~~
hasch
Yes, that jupyter+react implementation will be open source. It's not clear
though how the feature parity will be. At least the document is exactly the
same.

------
roystonvassey
Hands down the best and most used tool in my portfolio. Well done, guys!

Does anyone know if there's a plan to introduce multi-kernel support in single
notebooks like what Zeppelin does? Not that I have a strong preference for it
but it appears to hold a lot of appeal in Spark-like environments where not
all packages are available in Pyspark and you need to move between native
Scala/spark and Pyspark.

~~~
nl
_Spark-like environments where not all packages are available in Pyspark and
you need to move between native Scala /spark and Pyspark._

What exactly do you mean here? Are you referring to the parts of Spark which
don't currently have a Python API? Because those are becoming smaller and
smaller.

There is also Jupyter magics to let you change languages within a notebook.
See %Rpush and %RPull from [1]. Not sure if there is a way to have a Scala
kernel running and sharing the same Spark context though.

I think IBM is working on something in this area.

[1] [https://blog.dominodatalab.com/lesser-known-ways-of-using-
no...](https://blog.dominodatalab.com/lesser-known-ways-of-using-notebooks/)

~~~
roystonvassey
Yes, that's what I exactly meant. And you're right - that's a pretty small
subset and that's what I tell others too.

But, the ease with which you can load interpreters on Zeppelin (apart from the
pre-loaded ones) is impressive. I imagine it comes at a cost of some
instability because it hangs more often than Jupyter.

------
jacquesm
Jupyter is super useful, together with anaconda it's a winning team. I love
anaconda because it takes the sting out of all the dependencies and cruft that
stops python packages from installing cleanly (besides the v3 / v2 mess and
installing as a regular user rather than root).

~~~
ciupicri
Also Anaconda tends to come with newer versions than those available in most
Linux distributions.

------
m_mueller
I absolutely love Jupyter. Thank you guys and gals for your great efforts.
I've had this idea about how it could become a very simple and powerful rapid
application development tool based upon the widgets you already have: What if
you could preview and bundle it in a mode with hidden code to standalone
executable files on all platforms? There's already many tools in python to do
this, all it would take is some export feature to tie it all together.

~~~
jasongrout
We're going to be exploring building dashboarding solutions more with
JupyterLab. See
[https://github.com/jupyterlab/jupyterlab/issues/1640](https://github.com/jupyterlab/jupyterlab/issues/1640)
for some of our current discussion. That said, the deployment issue you've
talked about has been experimented with in the IBM dashboarding features
(i.e., one-click to deploy an application-like interface).

------
sandGorgon
Does anyone know how to setup a multi user notebook? Because of the nature of
the notebook and how it maintains state ... that a single instance is usable
by a single person.

We are building dashboards in Jupiter and really would love it to be multi
user... Without getting into the hub and stuff (way too complex to set it up)

~~~
yuvipanda
Disclaimer: I work on the hub.

Sorry to hear you found the hub too complex. We're working on making easier-
to-use hub setups that fit different use cases. Can you tell us a little more
about what your use case was and (optionally) which parts of the hub setup you
found too complex?

Thanks!

~~~
sandGorgon
Thanks for replying.

So it's a bunch of different technologies - nodejs,etc. I'm kinda wondering if
it can be built in Python itself. Make it part of a normal jupyter install, so
just a "jupyter hub start " will work ?

EDIT: adding to that, you have built a nodejs based http proxy - can you not
build it within Python (for uniformity) or nginx (for performance as well as
mind share) ? Do you even need to mandate a http proxy ?

Second question is that can it run in a multiprocess - I don't want to run it
in interactive mode, but just straight top to bottom. Perhaps there's huge
memory savings there.

~~~
carreau
I think yuvi wrote the CHP on nginx ([https://github.com/yuvipanda/jupyterhub-
nginx-chp](https://github.com/yuvipanda/jupyterhub-nginx-chp)) when we first
wrote CHP, node was the only viable solution to have a dynamic websocket
proxy. Nowdays Go, or Python 3 with AsyncIO may be potential contenders. It
may be possible to rewrite in Python but time is limitted. I'm unsure about
your second question.. run notebook top to bottom ? `nbconvert --to notebook
--execute --inplace yournotebook.ipynb` ?

~~~
sandGorgon
Well the second question was also related to multi-user deployment. From what
I understand, jupyterhub will spawn multiple kernels every time someone logs
in. But a lot of the time (most of the time?), you don't intend people logging
into your jupyter notebook to be doing interactive stuff - maybe they just
want to run the whole thing as a dashboard.

So it becomes a traditional webapp use case. Do you need all the
proxy/websocket, stuff to do this ? Your nbconvert command still needs every
user to spawn his own kernel right ?

About the first part - it would be great to have a simpler jupyterhub. One of
the steps is to have everything in Python.

~~~
yuvipanda
JupyterHub isn't really setup to do a 'dashboard' style web application - is
purely intended for interactive use. The design choices made reflect this.

There's ongoing work on formalizing the proxy better
([https://github.com/jupyterhub/jupyterhub/issues/848](https://github.com/jupyterhub/jupyterhub/issues/848))
- someone will probably write a pure python proxy when that gets merged :)

~~~
sandGorgon
I just wanted to make sure you guys were aware that it is a large component of
the use case. The very typical prototype in jupyter .. to ..Rewrite in
production code is shortened significantly by doing this.

All the tools already exist in jupyter - except one: lightweight multiuser. I
would argue that building this is going to be a fairly trivial thing for you
guys (as compared to other features you build), but the end user benefit is
immense.

Jupyter becomes much more than an interactive scratchpad - it becomes a full
blown prototyping environment for data science and reporting. I would say, you
would even go against tableau in a lot of use cases.

Please do think about it. My company will be happy to contribute to a gofundme
on this.

~~~
carreau
Reply to this plus 2 comments up. Hub spawns _servers_, not kernels. There are
a lot of indirection layers, and indeed, being able to _view_ a notebook
without starting a kernel is on the todo list. The multi user collaboration is
in progress, it's more complicated than it looks. One of the issue is that if
this is a "solved" [with many quotes] problem for static documents, as soon as
you have code execution it becomes really tricky. The kernel need to run as
someone, but who ? The owner of the document ? What are the permission you
give to who and how ? There are some case where there are possible answers,
but which are really hard to tackle in a generic way across programming
languages and various kind of deployments. Ian has an already well advance
JupyterLab Prototype that you can connect to Google Drive for live editing. If
your company is interested in funding something like that, feel free to write
to any of us privately (git log, and grep to find emails), and we can likely
setup a contract with numfocus (non profit that handle our funds), the
advantage will be that it will be tax deductible for your company (unlike most
of gofundme campaigns).

~~~
sandGorgon
I wish we had the kind of money to fund the full development - I mentioned
gofundme because a small startup in India will not be able to do that, even
though we want to. But I have a feeling that a lot of us will want to us as
well.

I'm talking specifically about the usecase of code-execution (especially
dashboards).

Here's a small point from me - perhaps you are overcomplicating the usecase
for 90% of us. Give a proper ssl/tls+bcrypted password setup and roles: Editor
and User.

I dont think you should be worried here in the context of people wanting to
run a full on sagemath cloud kind of a thing.

If you can give me a low resource way of letting 100 "Users" on a dashboard
form and one "Editor" (who can actually edit the underlying notebook), I'm
golden. And I'm willing to bet that so will 90% of your audience.

------
superfx
Still no collapsable hierarchy of cells. This is the one feature I miss most
from Mathematica notebooks.

~~~
wannesm
I can recommend [http://jupyter-contrib-
nbextensions.readthedocs.io/en/latest...](http://jupyter-contrib-
nbextensions.readthedocs.io/en/latest/nbextensions/collapsible_headings/readme.html)

~~~
mFixman
Also Table of Contents 2 [1] is useful, since it can numerate headings and
subheadings in a natural way.

Jupyter extensions are incredibly powerful, and I don't know how I used to do
data analysis before finding them.

[1] [http://jupyter-contrib-
nbextensions.readthedocs.io/en/latest...](http://jupyter-contrib-
nbextensions.readthedocs.io/en/latest/nbextensions/toc2/README.html)

------
wodenokoto
I didn't understand the purpose of cell-tags. Can anyone give an example of
how they might be used?

~~~
krastanov
An example among others: I tag certain cells as "initialization cells" and
they run automatically when a kernel is restarted (it requires a plugin).

------
jfdi
If you want to install this as part of a more integrated sciences environment
check out vnode
[https://github.com/thomaswilley/vnode](https://github.com/thomaswilley/vnode)

------
krick
Maybe it's just me, but the former table style seems much more readable and,
well, compact, even if you claim otherwise. I hope, this behavior is
customizable?

~~~
wassyape
I agree. It could be because our brains are used to the old style but there
are some objective drawbacks.

The new style right aligns everything which is good for numbers but bad for
text. Also, it might just be the screenshot, but the contrast is poorer and
the column sizes aren't as fitted.

It's a pity, I would rather have a decent default than to customize every
notebook.

------
marcinkuzminski
Looking forward to next OpenSource RhodeCode release which will now support
rendering jupyter notebooks.

It'll be second to Github source code management with Jupyter support.

------
amenod
One major issue for me is copying with mouse select + middle click, which is
unfortunately not solved in this release. Ah well. :-/

------
JupiterMoon
Does this update break all the addons again? (Vim keybindings in edit mode,
code folding etc.)

~~~
tmearnest
It seemed fine for me. All of my addons were working.

------
agumonkey
The computational dom

