> 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.)

FYI, if you want to do both things inside of JupyterLab, you can easily start a console in JupyterLab connected to the same kernel as the notebook in three different ways: right-click in the notebook and select "New console for notebook". Or from the notebook, select the main menu File>"New Console For Notebook". Or simply start a console from the File>New menu and choose the notebook's kernel from the dropdown.

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

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.

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.

I'm teaching someone to code right now on the Raspberry Pi, and JupyterLab is working far better for us than IDLE or a separate text file and terminal. We use the workflow described in http://jupyterlab.readthedocs.io/en/stable/user/documents_ke.... We open up our python file and a console side-by-side, and pressing shift-enter in the file sends a line or selection to a console. We can easily investigate it in the console outside of the file too.

You can just "pip install jupyterlab" on a Raspberry Pi and it works great!

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.

Using python in an editor next to an ipython console is exactly the sort of workflow that JupyterLab supports. See https://jupyterlab.readthedocs.io/en/stable/user/documents_k... for a walk-through of how this workflow can be used in JupyterLab.

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 and https://github.com/jupyterlab/jupyterlab/pull/3802 for more details.

Another possibility for interactively manipulating maps is the ipyleaflet Jupyter widget library: https://github.com/ellisonbg/ipyleaflet. See examples of notebooks at https://github.com/ellisonbg/ipyleaflet/tree/master/examples

(disclosure: I have helped with this library)

One of the best curriculums I've seen for children (grades 2-5) learning math is the Beast Academy series: https://beastacademy.com/

They have challenging problems that emphasize basic and advanced concepts in a variety of ways, often posed as games or puzzles.

I can second this, with a minor caveat. My daughter (third grade) loves these books, and we get a lot of good problem-solving into the curriculum as a result. The caveat, in my opinion, is that they don't provide enough cyclic review in their default configuration.

Each chapter includes 80-100 problems, divided in to usually between 4-8 sections. The problems are great, but once a section is complete they're weak on later refreshes. I've been working around this by doing even-numbered problems the first time through a section, then half of the odds a few days later when we're a couple of sections downstream, then selecting randomly from all of the unfinished problems in the entire curriculum for just a couple of extra "old stuff" problems each day throughout the year. We also supplement with a number of other great resources, if you're looking to implement a more problem- and exploration-oriented math curriculum:

1. Kitchen Table Math is great for selecting concepts to lead number talks with (for building number sense - this is the first part of our day)

2. Saxon has excellent spaced-repetition exercises for shoring up the calculation side of things, and giving the student some easy wins for confidence building (we typically use Saxon's material as a warmup before Beast Academy)

3. Thinking Mathematically (the one by J. Mason and L. Burton) has a unique and useful mental process for attacking hard problems when you're not handed a nice formula to plug things into. Once a week, we work through a hard problem using the method in this book.

4. I haven't worked it in yet, but Arthur Benjamin's "Secrets of Mental Math" has a lot of stuff in it that will solidly connect arithmetic and algebraic thinking later.

Are you home schooling? If not your daughter must be bored out of her mind at school.

https://github.com/QuantStack/xeus is an (in-development) implementation of the Jupyter protocol in C++, which lets you do kernel computation in any number of libraries that expose an API you can use from C++. Is that the sort of thing you are looking for?

Kind of, though C++ is a difficult language to use from anything other than C++ given there's no standard ABI. Either you need C++ glue-code wrappers around whatever language's FFI you actually want to use, or you embed Clang.

Here is another one in development: https://github.com/QuantStack/xeus-cling