What method do you use to share files with your students?

[James Slack]

I wanted to throw this question at the community here as well as looking around within the University of Edinburgh.

What methods do all of you use to get any course files uploaded to student directories?

Do you let students manually upload the files individually? Do you get them to upload and then unzip a folder? Do you use a Git clone or do you have your own fancy method?

In this case I am particularly interested in anyone doing this with Jupyterhub.

Thanks in advance!

[Doug Blank]

I have used three methods:

1. Use nbgrader! It is a very nice way to distribute (and collect) materials other than just assignments.

2. We built in a nbviewer-like service into out jupyterhub, called public_handler: 

https://github.com/BrynMawrCollege/jupyterhub

That should be updated to use nbconvert directly as this version has limitations.

3. We wrote a nice and easy magic called %download that can download zip files as a URL:

https://github.com/Calysto/metakernel/#use-metakernel-magics-in-ipython

https://github.com/Calysto/metakernel/blob/master/metakernel/magics/README.md#download

I have a more advanced version that will also unzip the files as well:

https://github.com/Calysto/conx/blob/master/conx/utils.py#L534

Hope that helps,

-Doug

 

Thanks in advance!

--
You received this message because you are subscribed to the Google Groups "Teaching with Jupyter Notebooks" group.
To unsubscribe from this group and stop receiving emails from it, send an email to jupyter-educat...@googlegroups.com.
To post to this group, send email to jupyter-...@googlegroups.com.
Visit this group at https://groups.google.com/group/jupyter-education.
To view this discussion on the web visit https://groups.google.com/d/msgid/jupyter-education/b6159bd4-595b-4bfd-b4c3-dec18157a471%40googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

[Chris Holdgraf]

At Berkeley we use a tool called `nbgitpuller`. It's a little Jupyter server extension that lets you create links that point to content online (e.g. a notebook within a github repository).

When students click the link, it takes them to their JupyterHub session and pulls in / displays this content. If the content has *already* been pulled in before, it updates the content unless the student has already made changes. We also use it for bootcamps and such as well. Quite useful!

https://github.com/jupyterhub/nbgitpuller

To view this discussion on the web visit https://groups.google.com/d/msgid/jupyter-education/CAAusYCg2V4-N1q0uVHwY1qvSnDjjpHfAv5QA1gokhF4suCtJ6Q%40mail.gmail.com.

[Doug Blank]

On Thu, Oct 18, 2018 at 11:04 AM Chris Holdgraf <chol...@gmail.com> wrote:

At Berkeley we use a tool called `nbgitpuller`. It's a little Jupyter server extension that lets you create links that point to content online (e.g. a notebook within a github repository).

When students click the link, it takes them to their JupyterHub session and pulls in / displays this content. If the content has *already* been pulled in before, it updates the content unless the student has already made changes. We also use it for bootcamps and such as well. Quite useful!

That does sound useful! One of the downsides of using nbgrader (and the other suggestions I gave) was that the downloaded materials can't be updated once the students get them. This would help with that, at least until the student changes the materials.

-Doug

[Josh Greenhalgh]

I really think it's a mistake to not use this as an introduction to using git. Just get them to clone the repo. Make some changes as you spot mistakes and show them how to pull down the changes. 

To view this discussion on the web visit https://groups.google.com/d/msgid/jupyter-education/CAD7kTDFaLnUSg_kD3D-Eo7WbVd6VcMzWSizdbV%3DixZ5P7c2c5A%40mail.gmail.com.

[James Slack]

Yes I think the ability to push more changes is certainly useful. I do like the nbgrader function to push files to students but it seems somewhat hacky (or at least not optimised to be used in that way) and it can cause issues if the students make changes

[Doug Blank]

On Thu, Oct 18, 2018 at 11:17 AM James Slack <slack....@gmail.com> wrote:

Yes I think the ability to push more changes is certainly useful. I do like the nbgrader function to push files to students but it seems somewhat hacky (or at least not optimised to be used in that way) and it can cause issues if the students make changes

nbgrader won't overwrite the downloaded folder once it has been downloaded, so it isn't hacky at all. (Students have to delete folder to get it again). You just have to be really sure that the assignment is done when you release it. Just like email :)

Regarding using git: I would not assume that that would be a good choice in many situations. You really don't want to weed out your class on the first day of class! Sure, at some point in a student's career you might want to introduce git. But I never did that in class. I introduced that in one-on-one projects in the lab.

-Doug

 

To view this discussion on the web visit https://groups.google.com/d/msgid/jupyter-education/6bfbc4dc-5f91-4ad7-8b97-d7afe111c711%40googlegroups.com.

[Chris Holdgraf]

To reiterate what Doug just said: we use nbgitpuller because it lets the instructor *choose* when to teach git, instead of making it a pre-requisite for interacting with the course from Day 1 (which ends up losing like 30% of the course in the git forest)

To view this discussion on the web visit https://groups.google.com/d/msgid/jupyter-education/CAAusYCha4P34XncsWJKW%2BkmBvUuOnjssjVRuO2k%2B9tzSm4qUPw%40mail.gmail.com.

[Josh Greenhalgh]

I'm in no way suggesting to go all the way into the git forest. Just that it's a good place to dip a toe in. Stick to using it for getting the resources to them and point out that there's a lot more to it if they're interested... 

To view this discussion on the web visit https://groups.google.com/d/msgid/jupyter-education/CAD7kTDEvTzeuX-yc6bBaYa9mZpAwEqQTYOCc4-LOWMmOyB4szw%40mail.gmail.com.

[Chris Holdgraf]

I like the idea of "ok you clicked this button and some magic happened, let's talk a bit about what just happened with git" :-) 

[William Stein]

Here's how sharing Jupyter notebooks works for instructors using CoCalc:

https://tutorial.cocalc.com/course_management/course_management.html

> --
> You received this message because you are subscribed to the Google Groups "Teaching with Jupyter Notebooks" group.
> To unsubscribe from this group and stop receiving emails from it, send an email to jupyter-educat...@googlegroups.com.
> To post to this group, send email to jupyter-...@googlegroups.com.
> Visit this group at https://groups.google.com/group/jupyter-education.
> To view this discussion on the web visit https://groups.google.com/d/msgid/jupyter-education/b6159bd4-595b-4bfd-b4c3-dec18157a471%40googlegroups.com.
> For more options, visit https://groups.google.com/d/optout.



--

William (http://wstein.org)

[kirby urner]

I do agree that toe-dipping in Github by showing cloning is highly worth while, but where and when is the question.  I'm all for sharing such skills at the secondary school level where feasible.  So many doors open when you know how to clone a repo.  Just that.  No pushing, no branching, no pull requests -- not right then.

I devoted a portion of a summer school course in Portland, Oregon this year, to introducing middle schoolers to this specific skill, having them clone the Martian Math Jupyter Notebooks repeatedly, as an exercise. 

https://github.com/4dsolutions/MartianMath/blob/master/mm1.ipynb  (one of the notebooks)

This was in a computer lab at Reed College with git already installed on all computers.  So was Anaconda i.e. Jupyter Notebooks client.

When a course is BYOD (bring your own device), that's another can of worms. 

I wasn't doing any grading and have yet to use nbgrader, so you can see where multiple approaches make sense.  Everything depends on the specific curriculum, which is precisely what we don't all have in common (I'm the only Martian Math teach I know :-D).

Kirby

[Nicolas M. Thiery]

Hi,

Thanks for sharing your practices! My turn ...

For our 400 students introductory programming class for freshmen [1],
our students learn some terminal basics on week one (one hour). And
then we have a wrapper script that we use for a bunch of things:

info-111 jupyter notebook
info-111 fetch Week1
info-111 submit Week1
info-111 g++ ...
...

The script first switches to the appropriate conda environment.
`submit` actually calls `nbgrader` with appropriate configuration
options; `fetch` currently calls wget + unzip from a web page (the
archive comes with a git repo); I am thinking of using `nbgitpuller`
or `nbgrader fetch` instead. `g++` and `jupyter` call the eponymous
commands with some additional configuration options.

This does not seem to put off the students (but they are in maths,
physics or computer science major; your mileage may vary). I actually
find it much more robust to tell students what commands to type in a
terminal than where to click. Sort of «student reproducibility through
automation».

The inconvenient is that this deviates from standard commands; so what
they learn is less reusable in other contexts. We try to mitigate that
by not deviating too much and making sure to write in bold the actual
commands behind the scene.

The advantage is that this abstracts away the specific choices of
options. So at any point we can add more, or simply switch the
underlying implementation.

The students work either locally on the computer lab machines, or on a
JupyterHub which share the same conda environment and script (albeit
not yet the same user directories, which is a pain).

Cheers,
Nicolas

[1] sorry in French ...
http://nicolas.thiery.name/Enseignement/Info111/
https://gitlab.u-psud.fr/Info111/Info111
https://github.com/nthiery/Info111-notebooks

--
Nicolas M. Thiéry "Isil" <nth...@users.sf.net>
http://Nicolas.Thiery.name/

[David Race]

Our courses are a little different because we are not teaching coding, but getting students excited about the combination of Math, CS, and Science via online courses.  We don't get any support from the school, so I settled on Colaboratory (Jupyter on Google) and I share the codes directly out of my Google Drive.  Normally the students run these in the sandbox, so there isn't an issue of changing the files.  There are three levels of labs:

1) Labs where they are doing homework (some of the larger homework problems that students don't want to do on a calculator).  They enter the inputs, execute the code cells and copy the output to the homework system.  I usually introduce a bug in one of the later labs so they have to debug it to get the correct answer.  

2)  Labs that are much larger than they want to do with a calculator (say 500 x 500 matrices).  These they run, study the graphs and later have to contribute to course Discussion Boards.  They are graded on the quality of their discussion content.  It is a little tedious to grade, but some of them like the interactions in the online course.  It is interesting to see them "correct" each other for not contributing a good comment.

3)  Challenge Labs are designed so they have to solve a specific problem based upon an example.  The input is from my github.  The problems are a little different than the example, so there is some work to do to solve the problem.  The python is easy enough to grasp that I don't spend any time on the programming concepts. (Too bad, but it is what it is.)

We use this approach in Cal, Linear Algebra and DiffE.  

It isn't perfect, but since we don't have any support it works well.

David  Race

--
You received this message because you are subscribed to the Google Groups "Teaching with Jupyter Notebooks" group.
To unsubscribe from this group and stop receiving emails from it, send an email to jupyter-educat...@googlegroups.com.
To post to this group, send email to jupyter-...@googlegroups.com.
Visit this group at https://groups.google.com/group/jupyter-education.

To view this discussion on the web visit https://groups.google.com/d/msgid/jupyter-education/20181018205401.k4m7ihxmftd4hjsr%40mistral.