1 h as allocated is typically not enough.

for learners who would like to play around with docker during lesson

• https://training.play-with-docker.com/ops-s1-hello
  note that this requires docker login

for example, prepare Docker image with simple Sumatra exercise

• Sometimes data is too huge to travel over network.
• Sometimes we are not allowed to send the data (sensitive data).

since the differences are important

try to explain better what the different tools are useful for, but don't go into details

Snakemake tutorial starts by forking https://github.com/coderefinery/word-count but one can clone the project directly without forking. This would make tutorial smoother when snakemake is taught before collaborative git.

Jonah from the carpentries told me we should definitely reach out to Ben Marwick (https://faculty.washington.edu/bmarwick/) when we start working on the reproducible project idea

We need at least 0.5h module on data in a 3-day workshop, and it might fit into this lesson. Discuss e.g. file formats, databases, flat files...

i.e. automation and reproducibility easier in command line

I suggest there be a two-rule Makefile, with the output of one rule the input of another (at the very top of the file). I had to explain the concept of dependencies there, and a real example to point at would have helped (in place of / below the one with target/dependencies/command in it).

the points under this section don't seem to correspond to the section title, "Main drawbacks of not able to reproduce research".
In episode 02

Instead of in the social coding lesson, I have a feeling they would be better listed in this lesson: https://github.com/coderefinery/social-coding/issues/6

... among the available tools/services.

remove sumatra (too narrow in scope), add CWL, zenodo, figshare, etc

first show the problems with reproduciblity, and at the end what we have learned to increase reproducibility

We were informed by a participants that there is the --delete-all-output flag which does that already.

There is also some connection to mybinder.org in the jupyterlab lesson. binder allows the environment with the packages and versions in requirements.txt to be built automatically.

cat and python are used in the make exercise, but on some windows laptops git-bash didn't have python in PATH

With new schedule, this is the first lesson where we needed the conda environment (for snakemake). Thus, I had to briefly explain the concept of conda environments, enough to make "and now I activate my conda environment" make sense. But conda is introduced in the last section after snakemake.

It does make sense with virtual environments in some sense, but perhaps flow could be made better by splitting conda and docker (the section gets quite long) and putting conda earlier.

In episode 3, the learner is instructed to clone the bast/make-pipeline repo somewhere, and then later copy the datafiles and source files to a project directory. Would it be better (more realistic and a better practice) to create a separate repo which already has the correct directory structure, so that the example project directory is already a git repo?

Notes raised in Gothenburg workshop regarding conda and performance / filesystem burden in HPC environment:

• Option to specify build (e.g., MKL vs openblas)
• Environment location conda create -n NAME vs conda create -p PATH (non-backed-up filesystem can be preferred)
• conda clean to clean cached files

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

Seems smaller and seems it works well for our exercises. To be verified but possibly offers a more lightweight install alternative.

I see that images are missing in the SnakeMake episode. A typo in episode 2 - wordcount.py, finds the frequency wdistribution of ords used in a text

Web search is the only option for searching for channels if you have installed miniconda. Anaconda is not provided.

It is a nice lesson but cannot be taught in 1 or 2 hours.
Second time I see this lesson (last time was in Goteborg) and I have the same feeling. We have it at the workshop (everybody is tired and we have no more than 1 hour for this lesson, including exercises) but do not have a clear idea on how this tool fits into the Software development framework.

I suggest we make a 1/1.5 hour lesson:

• Teach this lesson after Reproducible Research or documentation (on Wednesday morning) and show how to use jupyter notebooks to document/publish worflows/examples using repo2docker (binder)
• Have one single exercise where using binder is the main objective.

We could also add links to examples such as (these are from Geosciences but you probably have good examples too!):

• https://github.com/binder-examples
• https://github.com/OpenGeoVis/omfvista
• https://github.com/K3D-tools/K3D-jupyter
• https://github.com/jupyter-widgets/ipyleaflet
• https://github.com/pangeo-data/pangeo-example-notebooks

Keep a separate 1/2 day lesson on Jupyter ecosystem we can use as standalone lesson (we would use it in Oslo for 1 day workshop).

What do you think?

This person was using windows. The conda install instructions on the snakemake site didn't work. Also the windows installation instructions didn't work. (both said package not found in the requested channels).

This person's computer had plenty of problems and I'm not sure if the environment was set up correctly. The problems mostly seem related to confusion about (git bash shell vs anaconda shell (windows shell)) and conda environments and and environment variables.

Anyway, if installation instructions work on other windows computer (win10), then you can probably just close this issue.

Interesting minimum dependency alternative to makefiles: https://taskfile.dev

an excellent overview of methods and tools for reproducible research can be found at
this workshop page

Since compilation is possibly never mentioned.

I would instead of "recompile" use "rebuild by re-running make" or similar.

We require Python 3 but it would be really nice if this also works on Python 2.

Discuss when it is better to write a script and when it might be better to create a Makefile for a pipeline.

When reviewing the lesson some time ago, I remember the docker analogy of images/containers not being very good, so have been trying to come up with a better one. Here's the best I have so far (does anyone have something better?):

A docker container is like a piece of paper with all the operating system on it. When you run it, a transparent sheet is placed on top to form a container. The container runs and writes only on that transparent sheet (and what other mounts have been layered on top). When you are done, transparency is thrown away. It can be repeated as often as you want, and base is always the same.

Analogy breaks down when you use the same base to run multiple containers without copying the base. But it works when you discuss how images are composed (multiple transparent sheets stacked on top of each other, not that we go into it).

I found https://github.com/pyenv/pyenv to be a better option after suggesting it to some of my colleagues, even more so for those that had no experience with python, as it can be set as a global version and no need to change further.

They do not contain dependency on the scripts.

Mention that github + zenodo can give you a DOI via the releases feature

Good talk on Open Reproducible Research,
http://inundata.org/talks/index.html

It can also be used to detect hidden dependencies (e.g. exercise has a few things declared in the README, but a hidden function imports something else).

Followed-up from #66 (comment).

there should be a simpler way to install python3 and snakemake, and the existing dockerfile might not follow good docker practices

• https://github.com/alan-turing-institute/the-turing-way/blob/master/chapters/open_research.md
• http://lorenabarba.com/blog/barbagroup-reproducibility-syllabus/

would be good if participants in all nordic countries can get a useful pointer to services they can use

this will hopefully make workflows more concrete and understandable, and add context on why CWL exists

especially the zenodo and conda exercises need to be explained

For the upgrade of snake-minimal to work must the command be
conda update -c bioconda snakemake-minimal