refer to https://github.com/coderefinery/git-intro/issues/129 for details

Reported by a helper:

In the Jupyter-lab installation instructions, this is missing
jupyter labextension install @jupyter-widgets/jupyterlab-manager
Later in the lesson it is mentioned but somehow, I missed it since it was not in the instructions

https://coderefinery.github.io/jupyter/05-exercises/#solution

It would have been nicer to have fit function which gets a degree as parameter and is reusable on its own and wrapper function which takes care of the interaction. Currently the function that does all in one go is not really reusable on its own. (this was a good comment from the audience)

Add "calculation of pi" example as a different way of starting the lesson.

But #7 may be a better option in fact, since it's the same example. Adapt that instead if possible.

• add sample notebook
• add instructor guide to explain how to build up the example and in what order. (the idea is to not just make a final notebook to see, but build it up piece by piece and show how each step works and the reasoning)
• add other starting method to instructor guide.

it says cluster[:] when it should be client[:]

before moving on to a more advanced/realistic type-along in jupyter-usecases

https://github.com/guillaume-chevalier/How-to-Grow-Neat-Software-Architecture-out-of-Jupyter-Notebooks

... which can run notebooks directly off GitHub. See also:
https://twitter.com/jakevdp/status/1032810402227187712

Related to #28, I felt that this lesson got a relatively slow start and because I was new, it carried over to most of the rest of it. When I taught jupyter earlier, I had a different strategy which I'll suggest here.

First, here is my model notebook:
https://github.com/AaltoScienceIT/python-r-data-analysis-course/blob/master/02_Jupyter_demo_pi.ipynb

I started a new notebook and started telling a story:

• I am a researcher who wants to calculate pi. I don't know what I am doing so begin at the beginning.
• Add a markdown cell at the top saying what I am doing.
• Import relevant things and add simple loop and stochastic calculation (pick random points, are the yin a circle or not?)
• Now I have to convert my statistics to pi. I could do my derivations on paper and then enter the formula, but instead I enter a markdown cell and do the derivations directly there.
• Then, I implement the formula to calculate pi.
• Small discussion: when reporting my work to my advisor, this is a much more useful form! They can review everything.
• Now, we want to extend our work. Let's add a visualization. Go back and record all of the points and make a matplotlib visualization of what falls in the circle.
• Then I go add add some line magics - %timeit for example. Demonstrate these but we will get back to more later.
• Discussions: notebook advantages and disadvantages. When to use, when not to use.

I found that this was a dynamic and interesting story to begin with. After this, lead in to the material here which explains how to actually use jupyter - the details. The real examples can be immediately after this, or before.

As for presenting, it was fairly easy, but I did need to refer to the document to copy from - it's hard do do the derivations in real time with an audience! A bit more advanced thought and planning is needed, too (you should probably go through it once before presenting).

https://github.com/coderefinery/word-count is the perfect example project to play around with in notebook.

• visualizations
• debug
• extend the code to plot the full zipf distributions
• interactive widget fitting of Zipfs law to the data
• etc

In the zipf example the code block looks like a code cell but is code inside a text cell. This tries to connect to the rest of the workshop but it felt artificial to me and does not look like a natural use case for notebook. Also I am not sure non-Python developers get the "aha" effect there with all the Python code that is to be copy-pasted.

import matplotlib.pyplot as plt is missing in one or two cells.

This throws participants new to Python off the boat.

Please go through all exercises and make sure that we provide all the text needed.

Motivation (discussion on the Carpentries mailing list): https://carpentries.topicbox.com/groups/discuss/Td64229aeb252a027

In short, the motivation is to simplify reuse for those who wish to take parts of our lessons and remix them into material which is CC-BY.

At the team meeting 2019-08-12 we have decided to change the license to CC-BY provided that all contributors to this lesson material agree to this change.

This issue will track the progress of this change.

... using markdown. Gives a nice overview for longer notebooks.

RShiny is a nice R alternative/solution a la ipywidgets which can be interesting for R developers.

jupyterlab isn't exactly an IDE but is similar to one, so since we don't teach the IDE lesson any longer it might be worth including a short discussion on IDEs in the jupyter lesson

using some basic example data (e.g. iris) and e.g. keras

In the second example in lesson 01, when opening https://github.com/timalthoff/activityinequality in mybinder, the R kernel is not loaded. According to mybinder documentation (https://mybinder.readthedocs.io/en/latest/using/config_files.html) the repository should have a runtime.txt or a DESCRIPTION for the R kernel to be included.

The simple solution would be to for the repository, fix and add create a pull request. We could use the fork in the meantime But do we want to depend on external repositories keeping up to date?

to end the lesson with a general discussion about what possible use cases the learners can imagine

It is good to mention in passing it but also mention that 1) in practice we anyway run all cells in order, 2) one should not reuse variable names, and 3) if one has to, one should do that within one cell.

a participant pointed out:

The documentation on the jupyterlab-git repo mentions the command 'jupyter lab build' to complete installation

he had complained that he could not see the github button, however running the command did not solve the issue. Several people in his room had the same issue.

Comment there that this plots every n-th point. We should add a Python comment right above or in that line.

We often have trouble installing/enabling these and showing that it exists is in my opinion more useful rather than "requiring" it in exercises and let exercise rooms run into trouble.

Also I find Binder/Zenodo part relevant for everybody and more important than the interact widgets. We often spend 20 minutes on the latter and 5-10 minutes on the former and I suggest to make the Binder/Zenodo part more prominent and a part of a core exercise instead of a quick demo.

Example: in the classroom we wanted to try https://coderefinery.github.io/jupyter/04-extra-features/#playing-around-with-a-widget but this failed since it assumed that arrays were set and defined earlier. It would be nicer to have more pure functions which will work even though we skipped stuff.

In my understanding this creates notebooks with side-effects.

I think this will flow better: We start with the notebook, commit, push, do some more changes, inspect diff, discover nbdiff.

but it renders correctly locally with jekyll serve. Surely there must be a solution to this...

could be particularly useful to windows users (at least those that are able to install docker on their machines)

the official jupyter image can be run like this:
docker run --rm -it -p 8888:8888 -v "$(pwd):/notebooks" jupyter/notebook
and the IP address it produces can be entered in browser, with port 8888

We used to have that in the material but took it out but it is a nice example where we can also discuss the importance of requirements.txt.

I am experimenting with changing the exercise. I find in the current form it's difficult to "sell"/explain plotting every N-th point.

I find the function fitting more convincing. Alternatively we plot the actual random points and vary N and not only slices.

I would like to try converting the material into a conventional Jekyll lesson.
The motivation is:

• other lessons use this, so it'll be easier for all instructors (including those not using nor teaching jupyter) to contribute
• copy-pasting code from lesson material will be easier/more intuitive (and more similar to other lessons) than loading source files into cells or copy-pasting from markdown cells
• more modularity using episodes
• more easily extensible, just add episodes (including optional ones)
• purpose and take-home messages more clearly communicated via episode questions/objectives/keypoints
• lesson can be browsed and learned from even without running jupyter, material more accessible compared to rendering the notebooks on github
• task and challenge boxes from jekyll layout more clearly demarcate exercises, and support clickable solutions

Any comments on this?

It is possible to hide all the code and only show the output. This can be nice for notebook readers who don't need/want to see the code.

https://blog.jupyter.org/and-voil%C3%A0-f6a2c08a4a93

I think worth a mention in our material.

add 1-2 new notebooks with other types of use cases, which can be used in group work after the introduction. Include also R and octave/matlab notebooks

remove this comment from jupyter_usecases.ipynp

because wget is only available by default on linux (but can be conda installed on osx).
Also add an alternative for windows!

but one can see the actual jupyterlab keyboard shortcuts in the top menu

particularly spaces between variables in function calls

I don't think this is a typical use case. Following the lesson I felt rather confused with all the shell commands and shell escapes. Please let us stick to a typical notebook use-case.

In particular ipywidgets. It is IMO not realistic to expect that all participants have them working before the lesson and it can be frustrating to not have them working. [conclusion from a discussion on chat]

as an example of cool use case. The activity inequality study is mentioned in exercise in episode 6 so would be good to have briefly mentioned in before in the motivation episode

like the curve fitting widget example

I am not sure this is still correct:
https://coderefinery.github.io/installation/jupyter/#widget-extension

I installed jupyter using pip and widgets worked out of the box.

In the tab-completion example.