jasongrout

(disclaimer: I'm on the Jupyter steering council, but speaking unofficially...)

Very good point about wanting to work together. And we definitely do want to work together with people (and we have a good relationship with William in particular). Another relevant part of the message to William and to the community is:

"We are currently discussing in the steering council guidelines for proper use of the Jupyter name (started in part by your inquiry a few weeks ago). We hope to have such guidelines published soon. In the interim, we ask that you (and others) not use the name Jupyter in a domain name. We feel that this avoids confusion in the community and is being fair to all who have inquired about such matters."

So we (Jupyter steering council and community) are also trying to figure out a good policy - we (speaking generally) want to be conservative and avoid confusion until such policies are in place, though.

It doesn't (yet). I really hope eventually it will include a number of debugging tools, a variable explorer being one of them.

One thing people use it for is ephemeral computations that they don't need/want to be saved, so they don't want to bother with dealing with a notebook file.

Another thing we could support in the future is easily switching kernels mid-stream in the console. Maybe that makes sense---it did come up in conversation yesterday night here at scipy.

That's a cool idea. If you launch the browser in application mode, does it do the same thing (i.e., appear to the OS as a separate application with window grouping?)

We hope to support tearing out tabs into new child windows, so you can have multiple OS window panes associated with the single jupyterlab page that is running.

That's the only way commands are added. Every command on there was added by a plugin. You can see a simple example in the about plugin: a command is created at https://github.com/jupyter/jupyterlab/blob/6d540709ad64e7767..., and is added to the command palette at https://github.com/jupyter/jupyterlab/blob/6d540709ad64e7767....

One of the things about JupyterLab is that it really emphasizes extending and customizing the environment. Think of it as a platform for web-based applications and a reference set of components. We've tried hard to make the underlying platform have good support for power users. We've paid a lot of attention to making a good keyboard shortcut system, for example. I think it makes a lot of sense for someone to write a plugin for the system that registers keyboard shortcuts for doing tab management, maybe in the vein of a tiling window manager. Also, it would take changing only a few lines of code to move the file browser from the left side panel to the main docking area - it's just a widget that is registered on the left side panel rather than the main area.

We also encourage people to theme the environment, and provide themes via plugins. I think theming things with a lot more minimal whitespace would be an interesting project for users like you.

Also, for a power user, I'd definitely suggest running it in the browser application mode, which gets rid of lots of the browser chrome.

Remember - it's an alpha-level project, we're still experimenting a lot, especially on the user experience and UI. JupyterLab was built to be easily extensible and customizable, and we encourage people to experiment with customizing the environment in a way that suits them. And we appreciate feedback as well! Thanks!

Thanks, that makes a lot of sense. I've opened an issue: https://github.com/jupyter/jupyterlab/issues/405.

(disclaimer: I'm one of the authors of the scipy talk the post is about...)

First: JupyterLab is definitely still alpha-level software, and is undergoing very rapid iteration.

I notice that a lot of comments are missing one of the most important ideas behind JupyterLab. It's built on a very flexible plugin framework (provided by PhosphorJS), and all components are provided as plugins. JupyterLab essentially is a reference set of components, but we really see people creating their own components, and a rich 3rd party ecosystem. This also sets a foundation for exploring other ideas for what a web notebook might look like, etc, and provides an easy way to distribute such a component. More than just extending via components, we've paid a lot of attention to getting having a good keyboard shortcut system, a good command/command palette system, etc. The video of the talk shows some simple examples of how JupyterLab can be extended: https://www.youtube.com/watch?v=Ejh0ftSjk6g&list=PLYx7XA2nY5....

Also, I see several people talking about having a UI that is really focused on notebooks. We definitely plan on an easy way to maximize a single pane (which might be a notebook, etc.) to be able to focus on one thing.

Thanks for the feedback on the announcement blog post. I added a short description and link to the project home page at the top of the blog post after reading the feedback here. Thanks!

Cool, thanks for sharing! Another project providing layouts we've been using in the Jupyter project is the phosphor library: http://phosphorjs.github.io/ (demo of layouts at http://phosphorjs.github.io/examples/dockpanel/).

Thanks for your feedback. We're homeschooling, so we are the curriculum :). It seems like our child's hands are just getting big enough to fit on a keyboard, and some of the schooling curriculum we are doing will be much easier if they learn to type, hence the question.

Jupyter dev here. FYI, we're currently working on building a new Jupyter web interface that resembles a more classic IDE experience, which we are calling JupyterLab. A first version is progressively coming together, and is planned to have code editor and terminal components. We also plan to have a notebook component, like the current notebook, in a later version. Our in-progress work is spread across many repos currently (see the various jupyter/jupyter-js-* repos on github).

This is a nice demo. The blurb about flex-basis should be corrected, though. It says on page 33 that flex-basis basically is a min-width for flex items, but instead flex-basis sets the default (main) size, not the minimum size.

SageMathCloud is a completely new thing, which is much more comprehensive than either the IPython notebook or the previous Sage notebook. It provides the ability to run arbitrary services and connect to them, and provides a very easy way to launch an IPython notebook server. Log in, create a project, click "New", and then click "IPython notebook". It starts up an IPython notebook server (patched to allow collaborative editing) and tunnels the connection out so that you are interacting with the IPython notebook server it started up. Beyond that, it has a completely new Sage notebook, terminal, latex editor (all allowing real-time collaboration), automatic snapshots every few minutes, and many more things.

Are you talking about a small group all working together on an IPython notebook + source files? IPython doesn't (yet) support collaborative editing by itself, but SageMathCloud (https://cloud.sagemath.com/, source at https://github.com/sagemath/cloud) has patched IPython to have Google Docs-style collaborative editing. SageMathCloud is still using the latest IPython 2.x release (updated soon, probably in conjunction with upgrading the version of IPython in Sage). Still, it's probably your best bet right now for collaborative editing in IPython notebooks.

That said, several IPython developers are working on adding Google Drive support, and I believe they are working on the collaborative editing capabilities as part of that.

Cool! You can see some of the widgets people have been doing at https://github.com/ipython/ipython/wiki/widgets. If you come up with something, let us know and add your widget there.

Jonathan Frederic just updated the example notebooks for widgets before the release: http://nbviewer.ipython.org/github/ipython/ipython/tree/mast.... We've also listed a few examples of cool widgets at https://github.com/ipython/ipython/wiki/widgets (though some of these may not have been updated to run on IPython 3.x). You're welcome to ask questions on the IPython mailing list or the gitter chat: https://gitter.im/ipython/ipython/help.

Jupyter definitely hasn't lost interest - the IPython team is currently spending a lot of time finishing up IPython 3.0 and seeking funding (grants, etc.). IPython 3.0 is due to be released soon now (3.0 beta 1 was tagged a few days ago, and the development is somewhat in a soft freeze in preparation for 3.0). The general plan is to split up the IPython repo and transition to a Jupyter repo after 3.0 is released, and have a relatively quick iteration to 4.0 (mainly consisting of the repo split).

SageMathCloud (https://cloud.sagemath.com) offers collaborative editing of files, IPython and Sage notebooks, and latex documents, and terminal sessions. Really, it's like a collaborative unix account. It doesn't have a debugger, etc., so it's definitely not a full-blown ide, but it does have syntax highlighting and a shell.

At least for this research, Sage may have been better. This code follows the random matrix example to show that Sage gives at least consistent results in one of the cases they pointed out.

Here's the public SageMathCloud worksheet: https://cloud.sagemath.com/projects/49a2531d-9d02-42c9-9db6-...

I wish they would have supplied those matrices they printed out in machine-readable format so we could easily put those in Sage too.

Just FYI, Sage also has the Sage Cell Server, which is similar in that you can do calculations on a webpage, but also allows embedding live cells in webpages easily, sage interacts, 3d graphics, etc. For example, here is your calculation: http://sagecell.sagemath.org/?q=mthhin. Click the "About" link in the upper right for more information.

Sage also has its own 1.5 million line python/cython library that is part of Sage (https://github.com/sagemath/sage/tree/master/src/sage)

The American Institute of Mathematics has been promoting "knowls", which is a very similar idea and implementation: http://www.aimath.org/knowlepedia/

Rob Beezer's free open-source linear algebra book uses these extensively to provide more details in proofs and in exposition. It's very nice. For example, click on the underlined blue text at http://linear.ups.edu/html/section-SSLE.html

How do the interactive bokeh plots work? Is it necessary to start up a separate server, or can it work through the widget communication channels?

Some Drake University students and I have been working on wrapping the three.js library for 3d webgl graphics and are nearly complete [0]. We also implemented a simple webcam widget [1]. Here's a live demo illustrating both, using the Sage Cell Server: http://sagecell.sagemath.org/?q=qjjurl (you may need to click Evaluate once, and you'll need to click the permission notification to allow the browser to use your webcam)

[0] https://github.com/jasongrout/pythreejs

[1] https://github.com/jasongrout/ipywidgets

I see the docs mention that these only work when importing modules. The dev version of IPython lets you transform the AST of code that is typed in the REPL. It would be really cool to see an IPython AST transformer based on this. Here is an example from the test files in IPython: https://github.com/ipython/ipython/blob/master/IPython/core/...

Would it make a difference if your editor had better support for these sorts of things? For example, collapsed comments, where its shows only the first line, might help a lot. Then you could put a summary in the first line and elaborate in a paragraph that would be hidden by default.

Or what if the editor supported such comments in the margin, like the LibreOffice or Word review comment features?

I had fun implementing "Why Functional Programming Matters" [1] in Python [2], and it turned out to be similar to what you have above.

[1] http://www.cse.chalmers.se/~rjmh/Papers/whyfp.html

[2] http://sage.cs.drake.edu/home/pub/62/

Even python looks more readable to me: [i+9 for i in range(1,6) if i>=3]

Sage [1] (which you might say is the birthplace of Cython) makes a very serious use of Cython as well.

[1] http://sagemath.org