NetworkX has a dependency on the decorator library, and netx cannot plot graphs while using decorator==5.0.6

So they patched it to 5.0.7: https://github.com/networkx/networkx/commit/01d9cfe028e82ce7f2f7fd378ffe6e43ba2fddbb

decorator==5.0.6 is in /shared-libs/python3.7/py-core/lib/python3.7/site-packages, so I cannot uninstall it manually

Sometimes it is useful to inspect JSON on-the-go.
And currently, you need to write json.dumps(..., sort_keys=True, indent=4) for it.

Maybe having a cell with functionality like http://jsonviewer.stack.hu/ would be useful

You know, sometimes (actually, quite often) I need to change the source of the data, leaving other notebook contents as is.

And in this case, I need either to duplicate (which leads to doubling "as is" code as well) or to comment out code blocks etc.

So what I propose is like "configuration": so you have some dropdown near a sequence of cells. When you change its state, then the sequence of cells is changing on the corresponding configuration.

An example: I have a code to handle some table. And I have 2 sources: Notion-py and pandas. So if I choose configuration "pandas", I don't need these notion-py loading, and it disappears. If I choose "notion-py", then I don't need pandas loading... you got it

Emails are not case-sensitive, but if I add a user by some email address with a wrongly capitalized symbol, then he cannot access the project.

Solution: lowercase all emails under the hood

You know, everyone uses Ctrl + Z to revert something. You typed "gjdjfgdfg" instead of "import pandas as pd" -- whoops, sorry, dear computer, please revert that

But sometimes we make something wrong with computations: for example, you typed a = b + a * 34234234.3434 instead of a = b + a * 1.5

And now you need to restart the whole notebook.

But what if the history of values of variables would be stored somewhere? 
Ofc you need to limit depth because one can copy a 5Gb file into memory, then modify it -- and that's all, the whole operating memory is not full.

So I propose Ctrl + Z for values.

Possible way: store in operating memory history of 5-10 (by the way, maybe just 1 or 2 would be enough), if too large -- serialize on disk.

You know, sometimes it is sooo strange to rerun the whole notebook, especially if it is large

So what I propose is a special flag, which you can set to a cell and rerun from there next time you click on "Run notebook". 

After reboot it (maybe) should reset to the first cell

You know, I've recently researched your docs and found out that you have an integration with Neptune.ai.

And the following idea visited me: why use Neptune, this function of tracking experiments could be implemented using the existing version control system!

What I propose: a cell that will save a snapshot to the current version control system with name and description.

The use case is pretty simple: imagine you're trying to find a model which fits best, and you change parameters on each iteration of this process.

And if you add a special cell that automatically creates a snapshot with title *model name*: *accuracy score* and *combination of parameters* in the description, then you can easily review the progress and go back if needed.

Maybe there can possibly be a special page for tracking progress, but I think that for the first iteration that would be enough.



User can choose to create checkpoint cell as usual: 


And you pass two strings (description and title) to create a snapshot. I don't think that this design below is good, because it's not evident at first glance that upper input stands for title, but it is a good starting point



So concluding, you can implement a version control system for experiments relatively easily using an existing version control system

You can try to train a huge machine learning thing to estimate execution time based on cell code + memory consumption by variables used there + characteristics of the machine.

Ways to train that:

Maybe you can split that into several parts and code on Twitch stream. For example:

As that will be a hard task to estimate precise time, then you can make 3 (or more) categories: 

That has its benefits:

In Deepnote we can interactively review pandas frames. 
But what if we can interactively review, for example, networkx graphs? For example, you select 2 vertices, and Deepnote automatially draws the shortest path

You know, sometimes you remember that you've already implemented something similar to what you're trying to implement now, but you don't remember where.

Mbe somehow address that? For example: let's suppose that I remember myself using pd.merge somewhere, but I don't remember where. 

And finding that piece of code would save me time googling for the solution.